System-design interview practice · 2026 edition
Understand the concept.
Practise the answer.
Learn the foundations, then build a complete design for a 45-minute interview. Each case establishes numbered functional and non-functional requirements, then develops a working design and checks it against those requirements. The full advanced version is linked at the top.
Choose a lesson
Concepts first. Designs next.
Learn the concepts
System design interview framework
Structure a system-design answer around requirements, capacity estimates, API and data contracts, architecture, correctness, and operational tradeoffs.
9 interview questions Open lesson →ConceptHTTP APIs and request lifecycle
Explain DNS, transport and TLS setup, HTTP contracts, authentication, authorization, deadlines, and API evolution.
8 interview questions Open lesson →ConceptCapacity estimation: throughput, latency, concurrency and storage
Estimate throughput, storage, bandwidth, concurrency, and failure headroom with explicit workload assumptions and units.
8 interview questions Open lesson →ConceptDistributed systems: scalability, reliability, availability and efficiency
Distinguish scalability, reliability, availability, efficiency, and manageability, and set a measurable target for each.
8 interview questions Open lesson →ConceptDatabases, data models, and ACID transactions
Compare data models and database families, then connect access patterns, ACID properties, and concurrency controls to transaction boundaries.
8 interview questions Open lesson →ConceptDatabase indexes: B-trees, composite keys and query access
Design indexes around filters, ordering, and limits; compare lookup structures, write cost, covering queries, and pagination.
8 interview questions Open lesson →ConceptStorage engines and data models
Separate logical data models from physical storage, then compare B-trees, LSM trees, WAL, compaction, and row or column layouts.
8 interview questions Open lesson →ConceptLoad balancing: definition, algorithms and failover
Compare L4 and L7 routing, balancing algorithms, session state, health detection, draining, and surviving capacity.
8 interview questions Open lesson →ConceptCaching: cache hits, misses, write policies and invalidation
Define cache placement, read/write policies, freshness, invalidation, eviction, and overload protection.
8 interview questions Open lesson →ConceptProxies: forward proxy, reverse proxy and API gateway
Distinguish forward proxies, reverse proxies, and API gateways, including TLS, forwarded identity, caching, and retry boundaries.
8 interview questions Open lesson →ConceptData partitioning and sharding
Choose partition keys from access patterns, compare placement strategies, and transfer ownership safely during resharding.
8 interview questions Open lesson →ConceptConsistent hashing and virtual nodes
Compute ring ownership and virtual-node placement, estimate movement, and distinguish placement from migration, replication, and hot-key control.
8 interview questions Open lesson →ConceptReplication and durability
Define replication acknowledgments, durability, replica lag, safe leader replacement, and recovery from replicated errors.
8 interview questions Open lesson →ConceptCAP theorem: consistency, availability, and partition tolerance
Define the CAP theorem and derive the consistency/availability tradeoff during a partition without conflating it with business invariants.
8 interview questions Open lesson →ConceptConsistency models
Define permitted read/write histories and compare linearizable, sequential, causal, session, eventual, and bounded-staleness guarantees.
9 interview questions Open lesson →ConceptTransaction isolation
Explain read anomalies, lost updates, write skew, and the locking or validation mechanisms that protect concurrent transactions.
8 interview questions Open lesson →ConceptQuorums, consensus, leases, and fencing
Separate quorum intersection, consensus, leases, and resource-enforced fencing, including their assumptions and failure limits.
8 interview questions Open lesson →ConceptIdempotency, retries, and timeouts
Design duplicate-safe effects and bound retry work with request identities, deadlines, backoff, jitter, and concurrency limits.
8 interview questions Open lesson →ConceptMessage queues, event logs, delivery guarantees, and backpressure
Explain durable asynchronous handoff, delivery semantics, outbox publication, idempotent effects, ordering, backlog growth, and backpressure.
8 interview questions Open lesson →ConceptDistributed transactions and sagas
Compare local transactions, two-phase commit, and durable sagas across independent databases and external APIs.
8 interview questions Open lesson →ConceptReal-time communication: polling, long polling, SSE, and WebSocket
Compare polling, long polling, SSE, and WebSocket by direction, delay, connection state, and replay requirements.
8 interview questions Open lesson →ConceptProbabilistic data structures
Explain Bloom filters, HyperLogLog, and Count-Min Sketch through their mechanisms, resource savings, and the kinds and sizes of error each permits.
8 interview questions Open lesson →ConceptKeyword search and vector retrieval
Compare inverted indexes, embeddings, exact and approximate nearest-neighbor search, hybrid ranking, and retrieval evaluation.
8 interview questions Open lesson →ConceptAuthentication, authorization, and tenant isolation
Separate authentication, authorization, tenant isolation, encryption, capability URLs, and resource fairness across every access path.
8 interview questions Open lesson →ConceptMulti-region architecture and disaster recovery
Define RPO and RTO, compare regional topologies, and design safe failover, capacity, restore, and failback procedures.
8 interview questions Open lesson →ConceptProduction readiness: SLI, SLO, observability, and recovery
Define SLIs, SLOs, error budgets, observability, actionable alerts, safe rollout, and verified recovery.
8 interview questions Open lesson →Practise the core system designs
Design a URL shortener
Build a durable code-to-URL service, then justify uniqueness, retries, caching and storage growth from one concrete redirect.
45-minute interview · 8 interview questions Open lesson →Core designDesign Pastebin
Design immutable text sharing around complete publication, safe rendering and permission checks before introducing independently scaled body storage.
45-minute interview · 8 interview questions Open lesson →Core designDesign a photo-sharing service
Separate durable photo publication, follower feed preparation and authorized image delivery, then scale each for its own workload.
45-minute interview · 8 interview questions Open lesson →Core designDesign a file synchronization service
Build file synchronization around immutable revisions, explicit conflicts and durable device catch-up, then add chunk reuse and notification gateways.
45-minute interview · 8 interview questions Open lesson →Core designDesign a chat messaging service
Design durable chat by separating accepted messages, live delivery, per-device history recovery and advisory presence.
45-minute interview · 8 interview questions Open lesson →Core designDesign a microblogging service
Build a chronological posting service, then use measured reader activity and follower skew to choose where feed assembly happens.
45-minute interview · 8 interview questions Open lesson →Core designDesign a video streaming service
Turn an uploaded original into a verified playable video, then separate playback authorization from adaptive segment delivery.
45-minute interview · 8 interview questions Open lesson →Core designDesign a typeahead service
Build fast prefix suggestions by moving ranking work into a versioned index while keeping browser input, privacy and removal rules correct.
45-minute interview · 8 interview questions Open lesson →Core designDesign an API rate limiter
Choose the quota contract first, then enforce one atomic admission decision across gateways without confusing rate limits, retries and business execution.
45-minute interview · 8 interview questions Open lesson →Core designDesign public post search
Build a recoverable public-post search index, then merge bounded shard results without confusing matching, ranking, freshness and permission.
45-minute interview · 8 interview questions Open lesson →Core designDesign a web crawler
Build a durable, polite crawl pipeline that can repeat work after failures without losing discovered links or turning arbitrary URLs into unsafe network access.
45-minute interview · 8 interview questions Open lesson →Core designDesign a personalized news feed
Separate publication, candidate generation, ranking and delivery so a personalized feed remains explainable, recoverable and safe when relationships change.
45-minute interview · 8 interview questions Open lesson →Core designDesign nearby place search and friend discovery
Find the nearest eligible places within a stated radius, then extend the design to private, expiring friend locations without confusing search freshness with permission.
45-minute interview · 8 interview questions Open lesson →Core designDesign a ride-hailing backend
Design ride discovery, exclusive driver assignment and recoverable trip tracking, while keeping frequent GPS updates separate from durable trip decisions.
45-minute interview · 8 interview questions Open lesson →Core designDesign a ticket-booking service
Sell exact seats without overselling: separate advisory maps from atomic holds, then handle payment uncertainty and expiry with explicit recoverable states.
45-minute interview · 9 interview questions Open lesson →Practise additional and modern systems
Design a distributed key-value store
Build a durable exact-key store with conditional updates, safe retries and strong regional reads, then partition independent keys and replicate each partition.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a notification service
Accept one notification intent, plan eligible channel deliveries and recover provider outcomes while respecting current preferences and protecting urgent traffic.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a payment system and ledger
Coordinate a merchant payment with an external processor, post balanced immutable journals and protect refund capacity while uncertain outcomes are reconciled.
45-minute interview · 9 interview questions Open lesson →Additional designDesign a collaborative text editor
Build an online plain-text editor with immediate local typing, durable accepted operations and reconnect recovery, using a proven operational-transformation implementation.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a metrics, logging and tracing platform
Build an operational telemetry platform that links metrics, logs and traces, bounds ingestion and query costs, and distinguishes missing evidence from healthy behavior.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a distributed job scheduler
Turn recurring rules into durable run records, retry failed attempts and accept results only from the current worker, with explicit timing, overlap and side-effect limits.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a distributed message log
Design a retained partitioned event log with durable producer acceptance, independent consumer groups and replay-safe database effects, while keeping broker and application guarantees separate.
45-minute interview · 8 interview questions Open lesson →Additional designDesign ecommerce checkout and inventory reservation
Complete a physical-goods checkout with atomic inventory holds, durable payment progress and a guarded fulfillment decision, then explain when independent warehouses require a saga.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a leaderboard with exact snapshot ranks
Maintain trusted cumulative scores and a single ordered index per board, handling ties, duplicate results and downward corrections before introducing distributed rank queries.
45-minute interview · 8 interview questions Open lesson →Additional designDesign maps and route planning
Design legal driving routes from a versioned road graph, then scale search and map delivery while keeping traffic updates and cached paths coherent.
45-minute interview · 8 interview questions Open lesson →Additional designDesign event-time click analytics
Count validated event-time clicks with durable input and a transactional duplicate-safe counter, then scale processing and report honestly on late data, hot keys and lag.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a distributed unique-ID generator
Allocate unique integer IDs with a database baseline, then reserve durable numeric ranges so local counters can serve high throughput without per-ID coordination.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a webhook delivery platform
Deliver signed events through bounded retries, explain a lost receiver acknowledgment, and isolate slow endpoints without claiming transport can guarantee arbitrary business effects.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a feature-flag and configuration platform
Publish validated configuration and evaluate deterministic local rules, while making rollout freshness, offline fallback and rollback behavior explicit.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a multitenant SaaS platform
Build a shared business application with end-to-end tenant scope, fair resource use and a controlled move that never creates two active write owners.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a distributed object store
Store large immutable byte sequences behind named keys, with safe publication, authorized reads and measured durability.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a permission-aware RAG knowledge assistant
Build a read-only assistant that retrieves current, authorized evidence and returns a cited answer, with separate checks for permission, retrieval quality and factual support.
45-minute interview · 8 interview questions Open lesson →Additional designDesign an LLM inference platform
Serve versioned language models with bounded queues, token-aware admission and safe streaming; use measured scheduling and memory improvements before introducing specialized distributed execution.
45-minute interview · 8 interview questions Open lesson →Additional designDesign durable agent workflows
Run an AI-assisted business process across waits and crashes while keeping approved actions, saved progress and uncertain outcomes explicit.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a recommendation platform
Return a useful, permitted set of content by narrowing candidates, ranking a bounded set and learning from correctly interpreted feedback.
45-minute interview · 8 interview questions Open lesson →Additional designDesign a live video-conferencing service
Connect a small interactive call, then scale it with selective forwarding while keeping media quality, membership and recovery explicit.
45-minute interview · 8 interview questions Open lesson →