Katkat

practice a little every day, paws crossed ♡

System Design Interview Questions

Practice 9403 coding, system design and machine learning questions from 546 companies, sorted by role, topic and interview round. Every question has step-by-step hints, a code runner that supports 8 languages and an AI mentor; members also get the full solution walkthrough.

9403
Questions
546
Companies
11
Topics
8
Languages

Showing 481–510 of 1311 results

  • GoogleMediumSoftware Engineer
    Design a Security Monitoring Framework

    Design a scalable, low-overhead security monitoring framework capable of capturing OS-level events via eBPF across a massive cloud fleet, streaming telemetry, and detecting malicious activity in near-real-time.

    System DesignTechnical ScreenSecurityeBPFStreaming
  • GoogleMediumSoftware Engineer
    Design a System to Distribute Large ML Model Files Across a Serving Fleet

    System design interview question from a senior software engineer loop at Google: design a system that distributes very large ML model files to a fleet of serving machines. It examines bandwidth reasoning, fan-out strategies, integrity verification, staged rollout and rollback, and recovery from failed or partial transfers.

    System DesignOther
  • GoogleHardSoftware Engineer
    Design a Task Scheduler for Opaque Long-Running GPU Jobs ("Design Sora")

    This question tests your ability to design a distributed job scheduler and execution engine for long-running, compute-intensive GPU workloads. It evaluates distributed system fundamentals including multi-tenant fairness, gang scheduling, node failure recovery, and resource utilization.

    System DesignTechnical ScreenDistributed SystemsGPU SchedulingResource Management
  • GoogleHardSoftware Engineer
    Design a distributed rate limiter

    This question evaluates skills in distributed systems design, concurrency control, rate-limiting algorithms (token bucket and sliding window), distributed coordination and consistency, API design, and operational monitoring for scalability and fault tolerance.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design a global real-time notification system

    This question assesses the ability to design a distributed, global-scale notification platform that handles massive throughput, multi-channel delivery, and reliability requirements.

    System DesignOnsiteDistributed SystemsScalabilityReliability
  • GoogleHardSoftware Engineer
    Design a key-value store

    This question tests the ability to design a distributed, scalable, and fault-tolerant key-value store while addressing challenges related to data distribution, consistency, and storage engine implementation.

    System DesignTechnical ScreenDistributed SystemsStorageScalability
  • GoogleMediumSoftware Engineer
    Design a large-scale distributed rate limiter

    This question tests the ability to design a high-throughput, distributed rate-limiting service that handles multi-tenancy, ensures low latency, and manages consistency trade-offs.

    System DesignOnsiteDistributed SystemsScalabilityCaching
  • GoogleHardSoftware Engineer
    Design a prioritized log manager with eviction

    Design a prioritized log manager with eviction evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    System DesignTechnical Screen
  • GoogleHardFrontend Engineer
    Design an Embeddable Streaming Chat Interface

    Design an embeddable chat-agent widget with resumable streaming, virtualized history, safe caching, accessibility, and meaningful metrics.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design an Enterprise AI Adoption Agent for a Global Company

    Prepare for a Google system design interview about design an enterprise ai adoption agent for a global company. This question focuses on requirements, architecture, trade-offs, reliability, and follow-up discussion areas.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design an Offline-First Client That Syncs Edits and Resolves Multi-Device Conflicts

    Design the client side of an app where users keep editing data offline, store every edit locally, and sync with the server when the network returns. Covers the local data model and edit queue, a sync protocol that is safe to retry, and detecting and resolving version conflicts when several devices change the same data.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design an Online Coding Judge Platform

    This question tests the ability to design a high-throughput, secure, and fault-tolerant distributed system capable of executing untrusted user code in isolated environments.

    System DesignOnsiteScalabilitySecurityQueues
  • GoogleHardSoftware Engineer
    Design an elevator control system

    This question evaluates system design skills including architectural modeling of components, scheduling and concurrency control, state-machine design, and fault-tolerance for real-time control systems, and falls under the System Design domain.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design at-least-once notification delivery

    This question evaluates expertise in reliable distributed systems design, including at-least-once delivery semantics, idempotency and deduplication strategies, retry and dead-letter handling, API and message-schema design, ordering and out-of-order handling, and scalability for high-throughput multi-tenant notification platforms.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design deduplicated file storage on filesystem

    This question evaluates system design and storage engineering competencies, including multi-tenant isolation, authentication and authorization models, content-addressable storage and deduplication, reference counting and garbage collection, concurrency control, API surface design, and scaling across nodes using only filesystem primitives.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design distributed log storage service

    This question evaluates a candidate's expertise in designing distributed storage systems, covering partitioned append-only logs, high-throughput writes and reads, replication, retention, indexing, compaction, leader/follower roles, and recovery mechanisms.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design distributed transactions protocol

    This question evaluates a candidate's understanding of distributed transactions, coordination protocols, fault tolerance, consistency, and reliability across microservices and databases.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design executable notebook service APIs

    This question evaluates a candidate's competence in designing secure, scalable systems for executing user-supplied code, covering API design, sandboxing and isolation, dependency management, resource limits, scheduling, and streaming proxies for logs/results.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design high-throughput event subscription system

    This question evaluates a candidate's ability to design scalable, fault-tolerant event ingestion and subscription architectures, covering distributed systems, high-throughput messaging, content-based filtering, multi-tenant isolation, API/webhook design, delivery semantics, backpressure, sharding, security, and operational observability.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design key management service

    This question evaluates system design and security competencies—specifically cryptographic key lifecycle management, HSM integration, access control, auditing, multi-tenant isolation, and scalability—within the System Design domain.

    System DesignTechnical Screen
  • GoogleHardMachine Learning Engineer
    Design large-scale near-duplicate video detection

    This question tests the ability to design an end-to-end pipeline for detecting near-duplicate videos at a massive scale, focusing on embedding generation, vector indexing, and trade-offs between precision and recall.

    System DesignOnsiteComputer VisionEmbeddingsANN Search
  • GoogleMediumSoftware Engineer
    Design nearest-available-taxi lookup with updates

    This question assesses the ability to design a high-concurrency geospatial system that maintains real-time state for moving entities and supports low-latency queries.

    System DesignTechnical ScreenGeospatialScalabilityCaching
  • GoogleHardSoftware Engineer
    Design quota enforcement for high concurrency

    This question evaluates a candidate's understanding of distributed system design and engineering competencies related to quota enforcement, high-throughput rate limiting, consistency models, sharding, and concurrency control under very high QPS.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design relational-to-NoSQL migration pipeline

    This question evaluates a candidate's competency in designing a relational-to-NoSQL migration pipeline, covering distributed systems and data engineering concepts such as consistent snapshotting, change-data-capture, per-key ordering, idempotency, exactly-once behavior, schema evolution, partitioning, and operational reliability.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design street-view image ingestion and storage system

    This question tests the ability to design a high-throughput, fault-tolerant ingestion pipeline for massive geospatial media, focusing on distributed storage strategies, data integrity, and efficient retrieval at scale.

    System DesignTechnical ScreenScalabilitySpatial IndexingData Ingestion
  • GoogleHardSoftware Engineer
    Design viewing history and resume service

    This question evaluates a candidate's ability in large-scale system design, covering distributed state management, API design, data modeling for per-user progress, idempotent update semantics, cross-device synchronization, and privacy/compliance considerations.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Enforce a Country's IP Ban List on Incoming Connections Using Its Lookup API

    A system design exercise where a country provides an API reporting whether an IP address is banned and the service must refuse connections from banned addresses. It tests scoping questions such as IPv6 and address ranges, fast local enforcement at the edge, keeping ban data fresh, and fail-safe compliance behavior.

    System DesignOnsite
  • GoogleMediumProduct Manager
    Grounding Misinformation Moderation Decisions with a Retrieval-Augmented LLM Pipeline

    A product manager system design prompt about using retrieval-augmented generation to help moderate misinformation on a platform at large scale. It tests pipeline design from claim detection through evidence retrieval to human review, evidence freshness, precision and recall trade-offs, success metrics, and risks such as prompt injection.

    System DesignOther
  • GoogleMediumSoftware Engineer
    How to host many domains on one IP?

    Evaluates knowledge of DNS, HTTP/HTTPS request routing, TLS certificate management, and operational/security trade-offs when hosting multiple domains on a single public IP. Commonly asked to probe architectural reasoning and practical deployment trade-offs in the System Design domain at an architectural/operational level of abstraction.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Match Tagged Problems to Skilled Programmers at Scale

    Design a distributed matching platform that pairs incoming tagged tasks with skilled programmers using graph algorithms at scale.

    System DesignOnsitesystem-designgraph-algorithmsdistributed-systems