← Frontier Lab Interview Curriculum·Study guide 07 of 13
Senior-staff study guide · 07

Product and distributed system design

System design rounds test whether you can take an ambiguous product or infrastructure problem, scope it, and build a design whose every component you can defend under follow-up. OpenAI and Anthropic ask concrete product systems (payments with holds and settlement, webhooks, CI/CD, devboxes, real-time games, metrics ingestion, chat at 100M DAU, a prompt playground) and push on internals. A senior-staff candidate must lead the 45 minutes, quantify load and cost, name the consistency and failure semantics of each piece, choose what not to build, and absorb a mid-interview requirement change without restarting.

81resources8courses5with video42from 2025–2644%advanced89/89question groups covered11%of interview evidence (13% at staff+)
Intro 7Core 38Advanced 36

The senior-staff bar

What L7-level depth looks like in this topic, the follow-up an interviewer would push on, and the resources that prepare you for it.

From the interview reportsSenior-staff loops include at least two design rounds (Google L7, Anthropic senior staff, OpenAI staff). Interviewers ask you to defend internals and justify each component (“why do you need this?”), not just draw boxes.

Start here

The best resources for a time-poor senior engineer, newest first.

2026Book

Designing Data-Intensive Applications, 2nd Edition

Martin Kleppmann, Chris Riccomini (O'Reilly) · Mar 2026 · ~40 h

The reference for replication, partitioning, transactions, consistency, stream processing and derived data, updated in 2026 for cloud-native storage; every deep-dive question traces back to a chapter here.

2026Course

MIT 6.5840 Distributed Systems (Spring 2026)

Robert Morris, Frans Kaashoek (MIT PDOS) · Feb 2026 · ~80 h

Paper-driven course (GFS, Raft, ZooKeeper, Spanner, Chain Replication, DynamoDB guest talk) with Go labs that build MapReduce, Raft and a sharded fault-tolerant KV store.

2026Tutorial

Design a Messaging App Like WhatsApp

Hello Interview (Evan King, Stefan Mai) · Feb 2026 · ~2 h

1:1 and small-group chat with offline delivery, message inbox per device, WebSocket connection routing and pub/sub between chat servers.

2025Tutorial

Design a Payment System like Stripe

Hello Interview (Evan King, Stefan Mai) · Jul 2025 · ~1.5 h

Payment intents, idempotency keys, webhook callbacks to merchants, and reconciliation with the external processor.

2020Blog post

Design Docs at Google

Malte Ubl · Jul 2020 · ~0.5 h

Structure of a Google design doc (context, goals and non-goals, design, alternatives considered, cross-cutting concerns) and when not to write one.

2020Blog post

Avoiding insurmountable queue backlogs

David Yanacek (AWS Builders' Library) · 2020 · ~1 h

Multi-tenant queue fairness, shuffle sharding, sidelining hot tenants, LIFO during backlog and backpressure.

Learning path

Work through the stages in order. The last stage is the senior-staff layer: production case studies, papers to critique and large-scale trade-offs. Each resource's L7 line says what it adds at your level.

  1. 1

    Refresh the framework

    Run a 45-minute design with a fixed pacing script and quick estimates · Week 1 (6–8 h)

    • 2024
      Hello Interview (Evan King, Stefan Mai) · Jul 2024 · Tutorial · Intro · ~6 h
      Fastest route to the requirements → entities → API → high-level design → deep dives delivery framework that interviewers at OpenAI and Anthropic expect, plus core concepts and numbers to know.
      L7Baseline; skim if known. Use it only to lock in a 45-minute pacing script so the deep dives get the time.
    • 2025
      Hello Interview (Evan King, Stefan Mai) · Sep 2025 · Reference · Intro · ~1 h
      Round-by-round description of OpenAI's loop with the reported system-design prompts (payments, webhooks, CI/CD, devbox, chess), so you know which designs to drill.
      L7Baseline; read once to calibrate what 'staff signal' looks like in OpenAI's design rounds versus L5.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Sep 2026 · Reference · Intro · ~1 h
      Anthropic's loop structure and reported design prompts (1:1 chat at scale, prompt playground, design-doc review), with notes on how interviewers probe.
      L7Baseline; use it to pick which Anthropic prompts to mock, not as content.
    • 2026
      Donne Martin · 2026 · Practice · Intro · ~8 h
      Free index of building blocks (caching, replication, queues, consistency) with Anki cards and solved exercises; good for filling vocabulary gaps fast.
      L7Baseline; skim if known. Does not reach staff depth on failure handling.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · 2026 · Tutorial · Core · ~1 h
      Token bucket vs sliding window, centralized Redis counters vs local limits, and failure behaviour; also the core of a model-API gateway.
      L7Lets you discuss fail-open vs fail-closed and global vs per-region limits.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · 2026 · Tutorial · Core · ~1 h
      Consistent hashing, replication, eviction and hot keys for a cache or in-memory store; covers 'design Redis' and file-cache prompts.
      L7Lets you handle hot-key and rebalancing follow-ups; L7 adds what consistency the cache promises its clients.
    • 2026
      Mermaid project · 2026 · Tool · Intro · ~1 h
      Text-based diagramming used in AI-assisted, CoderPad-style design rounds; practising flowchart and sequence diagrams avoids fumbling syntax live.
      L7Baseline; one hour of practice so the tool never costs you interview time.
  2. 2

    Foundations of data systems

    Know replication, partitioning, consistency and storage engines well enough to argue them · Weeks 1–3 (25–35 h)

  3. 3

    OpenAI and Anthropic problem set

    One worked design per recurring prompt, each with numbers and a failure story · Weeks 3–5 (20–25 h)

    • 2025
      Hello Interview (Evan King, Stefan Mai) · Jul 2025 · Tutorial · Core · ~1.5 h
      Payment intents, idempotency keys, webhook callbacks to merchants, and reconciliation with the external processor.
      L7Mid-level baseline; pair with Stripe's ledger and idempotency posts for holds, settlement batches and double-entry correctness.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~2 h
      1:1 and small-group chat with offline delivery, message inbox per device, WebSocket connection routing and pub/sub between chat servers.
      L7Mid-level answer by itself; at L7 add explicit ordering guarantees, at-least-once plus client dedup, and DB load numbers for 100M DAU.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
      High fan-out real-time delivery to many viewers of one stream: SSE vs WebSocket, partitioned pub/sub, and why per-viewer state is avoided.
      L7Use it to argue fan-out cost per message and when to drop or sample; that's the livestream and spectator follow-up.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · May 2026 · Tutorial · Core · ~1.5 h
      LLM chat product: streaming responses, conversation storage, GPU-backed inference queueing and rate limiting; the closest public write-up to 'design the Claude chat service'.
      L7Lets you discuss token streaming, resumable generations and per-tenant quotas; L7 adds cost per request and graceful degradation when GPU capacity is short.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Oct 2026 · Tutorial · Core · ~1.5 h
      Matchmaking, authoritative game state, move validation, clocks and reconnection for real-time 1v1 games.
      L7L7 depth is server-authoritative clocks with latency compensation and recovering a game when a game server dies; this page gets you the skeleton.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
      Running untrusted user code: job queue, isolated containers, resource limits, and result delivery; a template for code-execution, malware-analysis and CI runner questions.
      L7Mid-level isolation story; L7 goes to microVMs vs gVisor, noisy-neighbour limits and warm pools (see Firecracker and gVisor).
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
      Agent → ingestion → Kafka → time-series store → query/alerting, with cardinality and retention trade-offs.
      L7Baseline structure; L7 adds late/out-of-order data handling, downsampling policy and alert evaluation at scale (Monarch, Gorilla, Dataflow).
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
      Scheduling, leasing and retrying jobs and DAG steps; the base for CI/CD pipelines and task systems with sub-tasks.
      L7Lets you defend lease-based exactly-once-effect execution and what happens when a worker dies mid-job.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Jul 2026 · Tutorial · Core · ~1.5 h
      Fan-out to many channels and endpoints with retries, rate limits, preferences and dedup; closest worked problem to webhook delivery.
      L7Baseline; L7 webhook answers add per-endpoint isolation, retry scheduling at billions/day and signing (see Svix and AWS backlog posts).
    • 2024
      Hello Interview (Evan King, Stefan Mai) · Jul 2024 · Tutorial · Core · ~1.5 h
      Real-time collaborative editing with OT/CRDTs, document servers, presence and versioning; the core of a collaborative prompt playground.
      L7Use it for the collaboration layer; L7 means choosing OT vs CRDT vs Figma-style last-writer-wins per field and justifying it.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
      Presigned uploads, chunking, content hashing for dedup, metadata DB and sync; covers photo storage with SHA-256 dedup and file upload for chat apps.
      L7Lets you handle reference counting on delete and concurrent uploads of the same hash, which is where interviewers push.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
      Stream aggregation with Kafka and Flink, idempotent counting, reconciliation with a batch path; maps to analytics dashboards and per-type IoT metrics.
      L7Lets you explain exactly-once aggregation and late data reconciliation, the heart of the IoT and analytics prompts.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1 h
      Polling vs long-polling vs SSE vs WebSockets, plus server-side pub/sub for routing updates to the right connection.
      L7Baseline; at L7 you should quote connection counts per host and explain reconnection storms.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Jun 2026 · Tutorial · Core · ~1 h
      Sagas, workflow engines (Temporal) and event sourcing for processes that span services: payments, CI pipelines, tasks with sub-tasks.
      L7Lets you argue durable-execution engines vs hand-rolled state machines and compensation for partial failure.
    • 2026
      Hello Interview (Evan King, Stefan Mai) · Oct 2026 · Tutorial · Core · ~1 h
      Async job APIs (submit, status, cancel), worker pools, queues and progress reporting: the shape of the image-processing and fine-tuning style prompts.
      L7Baseline; add cancellation semantics, visibility timeouts and backpressure to reach staff depth.
    • 2025
      Hello Interview (Evan King, Stefan Mai) · Nov 2025 · Tutorial · Core · ~1 h
      How TSDBs store and compress metrics, handle cardinality and downsample; supports metrics, electricity-monitoring and IoT prompts.
      L7Baseline; go to Gorilla and Monarch for the numbers.
    • 2022
      Alex Xu (Vol 2 with Sahn Lam) / ByteByteGo · 2022 · Book · Core · ~30 h · paid
      Worked chapters for chat, notification, rate limiter, autocomplete (Vol 1) and payment system, digital wallet, metrics monitoring and alerting (Vol 2); each has numbers, data models and diagrams.
      L7Mid-level depth: use the payment, wallet and metrics chapters as a checklist, then go deeper with the ledger, Gorilla and Monarch sources.
    • 2026
      Svix · Oct 2026 · Tutorial · Core · ~1 h
      Fan-out from events to per-endpoint deliveries, per-tenant partitioning, retry schedules, dead-letter queues and rate limiting toward slow receivers.
      L7Gives you the vendor's real design choices; at L7 add numbers (deliveries/s, retry backlog after an outage) and isolation of noisy endpoints.
    • 2010
      Glenn Fiedler (Gaffer On Games) · Feb 2010 · Blog post · Core · ~1 h
      Lockstep vs client-side prediction vs authoritative server, and why latency hiding matters in real-time games.
      L7Lets you answer 'reduce network delay differences between players' in a typing race or trivia round.
    • 2023
      GitHub Engineering · Sep 2023 · Blog post · Core · ~0.5 h
      How a large monorepo's CI runs on hosted larger runners: job fan-out, runner sizing and cost.
      L7Use with the runner-controller docs to describe the dispatch path (job queue → runner long-poll → ephemeral VM) a GitHub Actions design needs.
    • 2026
      Anthropic · 2026 · Reference · Core · ~0.5 h
      How a frontier lab exposes models to developers: API keys, workspaces, per-tier request/token limits, streaming and error codes.
      L7Lets you ground a 'design APIs for our models' answer in the real contract (token-based limits, 429 handling) and then argue the gateway behind it.
    • 2026
      OpenTelemetry (CNCF) · 2026 · Reference · Core · ~0.5 h
      Versioned schema URLs and transformations that map renamed attributes and metrics between versions.
      L7Gives a principled answer to 'old clients send different names for the same metric': versioned schemas plus server-side translation.
    • 2026
      Amazon Web Services · 2026 · Reference · Core · ~1 h
      Desired vs reported state per device, versioning and delta messages for devices that are offline or ignore commands.
      L7Lets you design command dispatch with reconciliation for devices that may not receive or execute (grid dispatch, IoT log requests).
    • 2026
      Hello Interview (Evan King, Stefan Mai) · 2026 · Practice · Core · ~6 h
      Worked answers for the standard screen prompts (video streaming/Netflix, search over billions of documents, Yelp/Foursquare proximity, Twitter feed, web crawler).
      L7Baseline for pre-onsite screens; at L7 practise them only to rehearse leading the discussion and estimating.
    • 2025
      Jordan Epstein · 2025 · Video · Core · ~20 h · video
      Long whiteboard videos that go into storage engines, replication, stream processing and full problem walkthroughs, closer to DDIA depth than most interview channels.
      L7Good for hearing internals argued aloud (e.g. why Flink over a cron job); pick episodes on topics you are weakest in.
  4. 4

    Design docs and mocks

    Critique a flawed design doc and run six mocks with a mid-interview requirement change · Weeks 5–6 (10 h + mocks)

    • 2020
      Malte Ubl · Jul 2020 · Blog post · Core · ~0.5 h
      Structure of a Google design doc (context, goals and non-goals, design, alternatives considered, cross-cutting concerns) and when not to write one.
      L7Gives you the checklist to critique someone else's doc: missing non-goals, no alternatives, no failure or migration story.
    • 2026
      Michael Lynch · Jun 2026 · Tutorial · Core · ~1 h
      Practical guidance on writing and reviewing design docs, including how to give useful feedback.
      L7Use the feedback chapter to rehearse a design-doc review round: prioritise the two flaws that matter, not ten nits.
    • 2025
      Will Larson · Oct 2025 · Book · Advanced · ~8 h · paid
      How staff+ engineers write strategy and design guidance: diagnosis, policies, operations, and testing a strategy before rolling it out.
      L7Supplies the org-level judgment L7 rounds look for: scoping an MVP, choosing what not to build, and justifying it to other teams.
    • 2025
      GreatFrontEnd (Yangshun Tay) · 2025 · Tutorial · Core · ~6 h · paid
      Frontend-heavy design framework (component architecture, state, API contract, rendering, offline) for full-stack rounds that start from a product spec.
      L7Use only if a loop includes a full-stack/frontend design round; staff signal is the API and data contract between client and server.
  5. 5

    Senior-staff depth

    Defend internals with production evidence: papers and frontier/hyperscale write-ups you can cite and critique · Weeks 4–8, interleaved (30–40 h)

What the interviews ask

Problems that recur in this track across 75 reports (37 firsthand), with the resources that prepare you for each.

ReportsProblemPrepare with
18Chat / messaging at scale (1:1, Slack, livestream)4 firsthand · example reportDesign a Messaging App Like WhatsAppDesigning Data-Intensive Applications, 2nd EditionBigtable: A Distributed Storage System for Structured DataKafka: a Distributed Messaging System for Log ProcessingDatabase Internals
12Payments (authorization, settlement, holds)6 firsthand · example reportDesigning robust and predictable APIs with idempotencyLedger: Stripe's system for tracking and validating money movementDesign a Payment System like StripeDesigning Data-Intensive Applications, 2nd EditionSpanner: Google's Globally-Distributed Database
10Real-time game (chess, typing race, trivia)6 firsthand · example reportWhat Every Programmer Needs To Know About Game NetworkingDurable Objects: Easy, Fast, Correct — Choose threeOpenAI L5 Interview Guides & Questions (2026)Design Facebook's Live Comments SystemReal-time Updates pattern
8Cloud IDE / devbox sandbox7 firsthand · example reportFirecracker: Lightweight Virtualization for Serverless ApplicationsWe're leaving KubernetesOpenAI L5 Interview Guides & Questions (2026)gVisor documentationDesign a Coding Platform Like LeetCode
8Metrics / telemetry / IoT ingestion7 firsthand · example reportMonarch: Google's Planet-Scale In-Memory Time Series DatabaseDesigning Data-Intensive Applications, 2nd EditionMapReduce: Simplified Data Processing on Large ClustersBigtable: A Distributed Storage System for Structured DataDapper, a Large-Scale Distributed Systems Tracing Infrastructure
7Webhook delivery platform2 firsthand · example reportDesigning robust and predictable APIs with idempotencyAvoiding insurmountable queue backlogsDesign a Payment System like StripeKafka: a Distributed Messaging System for Log ProcessingScaling Slack's Job Queue
7CI/CD / job execution platform2 firsthand · example reportAvoiding insurmountable queue backlogsFirecracker: Lightweight Virtualization for Serverless ApplicationsThe Chubby lock service for loosely-coupled distributed systemsScaling Slack's Job QueueHow GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.com
6Prompt playground / sharing product1 firsthand · example reportHow Figma's multiplayer technology worksDistributed Systems lecture series (Cambridge)Durable Objects: Easy, Fast, Correct — Choose threeDesign a Collaborative Document Editor Like Google DocsFront End System Design Playbook
2Design-doc critique2 firsthand · example reportDesign Docs at GoogleA postmortem of three recent issuesCrafting Engineering StrategyRefactoring English: How to write an effective design doc / get meaningful feedbackAnthropic Senior Software Engineer Interview Guide (2026)
2Photo storage with dedup2 firsthand · example reportFinding a Needle in Haystack: Facebook's Photo StorageDesign a File Storage Service Like Dropbox

Question coverage

Every question group collected for this topic from candidate reports, mapped to the resources that prepare you for it. 89 of 89 groups are covered, which is 100% of all report mentions. Hover an example to see the full question.

ReportsQuestion group and examplePrepare with
7payment systemOpenAI 7 · 1 staff+Design a payment system (workflow and component responsibilities)Design a Payment System like StripeStripe's payments APIs: The first 10 yearsLedger: Stripe's system for tracking and validating money movementDesigning robust and predictable APIs with idempotencyPayment intent workflow, ledger entries, idempotent retries, processor callbacks
4one-to-one chat systemAnthropic 4 · 1 staff+One-to-One Chat System: Design the backend for direct messaging between exactly two people:Design a Messaging App Like WhatsAppHow Discord Stores Trillions of MessagesConsistency Models1:1 delivery, offline inbox, message storage schema, ordering guarantees
3webhook delivery platformOpenAI 3 · 1 staff+Implement a webhook platform: create a webhook request (cxid, JSON blob), URL is queried from serviceB, retry for 24 hoursWebhook scalability: how to scale webhook deliveryDesign a Notification SystemTimeouts, retries, and backoff with jitterDesigning robust and predictable APIs with idempotencyFan-out to endpoints, retry schedules, DLQ, idempotent deliveries
3Slack messagingOpenAI 3 · 1 staff+Design Slack (system design)Real-time MessagingDesign a Messaging App Like WhatsAppHow Discord Stores Trillions of MessagesSlack channel/gateway servers, fan-out, message storage
3file distribution to thousands of hostsAnthropic 3Design a file-sharing / distribution system.Design a File Storage Service Like DropboxKafka: a Distributed Messaging System for Log ProcessingClassic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerChunked transfer and fan-out; see mlinfra P2P resources for depth
3online chess platformOpenAI 3 · 1 staff+Online Chess Platform (Chess.com-style): Design the real-time backend for a one-on-one online chess platform.Design an Online Chess PlatformDurable Objects: Easy, Fast, Correct — Choose threeWhat Every Programmer Needs To Know About Game NetworkingMatchmaking, authoritative game state, clocks, reconnection
2gridOpenAI 2System design: "Grid"System Design in a HurryDesign a Collaborative Document Editor Like Google DocsDurable Objects: Easy, Fast, Correct — Choose threePrompt unspecified; framework plus collaborative grid/state design
2cloud IDEOpenAI 2Design a CloudIDE (candidate gave SSH version where one or several users share a host)We're leaving KubernetesFirecracker: Lightweight Virtualization for Serverless ApplicationsDesign a Coding Platform Like LeetCodeDevbox lifecycle, persistent disks, isolation, multi-user hosts
2online chessOpenAI 2Design chess (online multiplayer chess service)Design an Online Chess PlatformReal-time Updates patternMatchmaking, routing to game server, timeouts, scaling
2multi-tenant CI/CDOpenAI 2Design a multi-tenant CI/CD system that schedules and executes user-defined workflows (sequence of jobs from a YAML file in each repo) after…Design a Distributed Job Scheduler Like AirflowThe Chubby lock service for loosely-coupled distributed systemsAvoiding insurmountable queue backlogsHow GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.comLeased job execution, worker death, tenant fairness, runners
2webhook deliveryOpenAI 2 · 1 staff+Design a webhook callback system / webhook delivery platform for third-party integrationsWebhook scalability: how to scale webhook deliveryDesign a Notification SystemThird-party webhook delivery, signing, retries, endpoint isolation
2malware analysis systemAnthropic 2 · 2 staff+Design a Malware Analysis System.VirusTotal: How it worksFirecracker: Lightweight Virtualization for Serverless ApplicationsDesign a Coding Platform Like LeetCodeScanner fan-out, isolated detonation sandboxes, job queue
2developer API for modelsAnthropic 2Design APIs for developers to access Anthropic's models securely and efficiently.Claude API: rate limits and API overviewDesign a Distributed Rate LimiterDesign ChatGPTModel API contract, token rate limits, streaming, gateway
2distributed job schedulerOpenAI 2Design a system to schedule jobs in a distributed environment.Design a Distributed Job Scheduler Like AirflowThe Chubby lock service for loosely-coupled distributed systemsManaging Long Running Tasks patternScheduling, leases, retries, worker failure
2design SlackOpenAI 2Design an in-memory database. / Design Slack.Real-time MessagingDesign a Distributed Cache Like RedisSlack architecture; in-memory store design for the companion prompt
2prompt playground designAnthropic 2Prompt Playground (Product and Data Design): Design a browser-based playground where developers at a customer organization write, run and it…Design a Collaborative Document Editor Like Google DocsHow Figma's multiplayer technology worksDesign ChatGPTPrompt storage, versioning, real-time collaboration, model calls
2CI/CD GitHub ActionsOpenAI 2 · 1 staff+Design Github ActionsHow GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.comDesign a Distributed Job Scheduler Like AirflowFirecracker: Lightweight Virtualization for Serverless ApplicationsWorkflow DAGs, runner dispatch, ephemeral isolated runners
1design doc reviewAnthropic 1 · 1 staff+Staff SWE system design: review an existing design doc and give feedback, then deep dive on failure handling and overload protectionDesign Docs at GoogleRefactoring English: How to write an effective design doc / get meaningful feedbackGoogle SRE books (Site Reliability Engineering; The Site Reliability Workbook)Doc review checklist, then failure handling deep dive
1payment processing systemOpenAI 1System design: design a payment processing system, pushing on failure modes, retries, idempotency, operational concerns and correctnessDesigning robust and predictable APIs with idempotencyMaking retries safe with idempotent APIsDesign a Payment System like StripeFailure modes, retries, idempotency keys, operations
1Playground designOpenAI 1Phone screen design prompt: design the (OpenAI) PlaygroundDesign ChatGPTClaude API: rate limits and API overviewHow Figma's multiplayer technology worksPlayground: model calls, saved prompts, sharing, quotas
1Slack MVPOpenAI 1design slack, how to deliver a MVP in 2 weeks. how would we do message delivery scalability/reliabilityReal-time MessagingCrafting Engineering StrategyMVP scoping plus reliable message delivery
1webhook delivery at scaleOpenAI 1Design a webhook delivery platform at very high scale (billions of requests), drilling into implementation specifics for reliability and per…Webhook scalability: how to scale webhook deliveryAvoiding insurmountable queue backlogsFixing retries with token buckets and circuit breakersBillions of deliveries: partitioning, backlog draining, retry budgets
1CI/CD like GitHub ActionsOpenAI 1Design a CI/CD system similar to GitHub Actions, reliability first then performance; drilled into internals of standard components (DB, load…How GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.comDesign a Distributed Job Scheduler Like AirflowAvoiding insurmountable queue backlogsReliability-first CI: durable queue, leases, runner internals
1typeaheadxAI 1system design- typeahead systemSystem Design Interview – An Insider's Guide, Vols 1–2Vol 1 autocomplete chapter: trie, top-k caching, data pipeline
1product-focused designAnthropic 1Product/system design worked in a shared Google Doc: UX flows, data models, pragmatic user-centred design choices (little drawing)System Design in a HurryDesign Docs at GoogleDoc-based product design: user flows, entities, API, pragmatic choices
Show the other 64 question groups
1telemetry ingestion naming variantsAnthropic 1Design a telemetry system; follow-up: if previously deployed clients used different naming variants for the same telemetry_name, how should …OpenTelemetry Telemetry SchemasDesign a Metrics Monitoring Platform like DatadogVersioned telemetry schemas, server-side name translation
1flawed design doc reviewAnthropic 1System design: review and improve a design doc that has problems in itRefactoring English: How to write an effective design doc / get meaningful feedbackDesign Docs at GoogleCrafting Engineering StrategyFinding and prioritising flaws in a design doc
11:1 messaging 100M DAUAnthropic 1Design a one-to-one text-messaging web app at 100M DAU that keeps messages for offline recipients; follow-ups: DB load at this scale, findin…Design a Messaging App Like WhatsAppHow Discord Stores Trillions of MessagesDesigning Data-Intensive Applications, 2nd Edition100M DAU load, chat-ID lookup, lifecycle, lost/out-of-order messages
11:1 chat systemAnthropic 1Design a 1-on-1 chat system (no groups/channels): offline push, presence, session storage, then Kafka vs Redis and Kafka internalsDesign a Messaging App Like WhatsAppKafka Deep DiveReal-time Updates patternOffline push, presence, sessions, Kafka vs Redis pub/sub
1real-time chess serviceOpenAI 1Design a chess game: tracking a user's remaining time, recovery after a client failsDesign an Online Chess PlatformDurable Objects: Easy, Fast, Correct — Choose threeServer-side clocks, game-state recovery after client failure
1command dispatch + telemetry reconciliationOpenAI 1Design a power-grid dispatch center sending commands to devices by region (e.g. cut all Northeast air conditioners' usage by 20%) over unrel…AWS IoT Device Shadow serviceThe Dataflow ModelDesired vs reported state, late telemetry reconciliation, next-round adjustment
1fullstack app designOpenAI 1Fullstack system design with frontend focus from a 2-3 page doc with requirements, screenshot and GIF demoFront End System Design PlaybookFrontend-focused system design from a product spec
1IoT logging late metricsOpenAI 1Design an IoT log platform: many devices collect logs online/offline and batch-upload when online; platform can request devices record certa…The Dataflow ModelDesign an Ad Click AggregatorAWS IoT Device Shadow serviceLate-arriving logs, watermarks, per-type metrics, device log requests
1real-time electricity monitoringOpenAI 1Design a system to monitor electricity use of devices in real time and adjust usage strategies based on consumptionTime Series DatabasesMonarch: Google's Planet-Scale In-Memory Time Series DatabaseAWS IoT Device Shadow serviceReal-time device metrics, TSDB storage, control feedback
1devbox serviceOpenAI 1Design a devbox (on-demand remote development environment) serviceWe're leaving KubernetesFirecracker: Lightweight Virtualization for Serverless ApplicationsOn-demand devbox lifecycle, storage, isolation
1dedup photo storageOpenAI 1Extra SD: design a system where users upload, download and delete photos, keeping only one copy when content SHA256 matches an existing phot…Design a File Storage Service Like DropboxFinding a Needle in Haystack: Facebook's Photo StorageContent-hash dedup, reference counting, blob storage
1online devboxOpenAI 1Design an online devboxWe're leaving KubernetesgVisor documentationOnline devbox: environments, sandboxing, persistence
1metrics monitoringOpenAI 1Metrics monitoring system design variation, going deep on 1-2 areasDesign a Metrics Monitoring Platform like DatadogMonarch: Google's Planet-Scale In-Memory Time Series DatabaseGorilla: A Fast, Scalable, In-Memory Time Series DatabaseMetrics pipeline; deep dives on storage and aggregation
1content-addressed photo storageOpenAI 1Design a photo-storage service (upload/view/delete) with SHA-256 hashing: object storage, metadata, handling duplicate hashes, upload consis…Design a File Storage Service Like DropboxFinding a Needle in Haystack: Facebook's Photo StorageSHA-256 addressing, object storage, metadata, duplicate handling
1payment holds/charges/batchesOpenAI 1Design a payment processor: merchant hold request forwarded to upstream payment network for approval/rejection, later separate charge, charg…Stripe's payments APIs: The first 10 yearsLedger: Stripe's system for tracking and validating money movementDesign a Payment System like StripeHolds via upstream network, captures, batched settlement
1multiplayer typing raceOpenAI 1Design a typing race game for 2-8 players: generated passage, first to finish wins, 1-second freeze on a typo; cooldown/unfreeze mechanism, …Durable Objects: Easy, Fast, Correct — Choose threeWhat Every Programmer Needs To Know About Game NetworkingReal-time Updates patternRoom actor, freeze timers, latency compensation, matchmaking
1cloud IDE sandboxOpenAI 1Design a cloud IDE sandbox, including what happens inside the VM when the sandbox executes a user's programgVisor documentationFirecracker: Lightweight Virtualization for Serverless ApplicationsBerkeley CS 162 Operating Systems and Systems ProgrammingSyscall interception and VM internals when running user programs
1design SteamOpenAI 1Design Steam (digital game store and distribution platform)Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerDesign a File Storage Service Like DropboxGame distribution via CDN and chunked downloads, store catalog
1payment authorization + settlementOpenAI 1Design a payment system: transactions approved/denied via an external payment service, approved amounts held, daily batch processing, ~10,00…Stripe's payments APIs: The first 10 yearsLedger: Stripe's system for tracking and validating money movementSpanner: Google's Globally-Distributed DatabaseAuthorization, holds, settlement, ledger consistency
1trivia battle royaleOpenAI 1Design a real-time trivia battle royale platform: dozens to ~100 players per room, questions released round by round, each round eliminates …Durable Objects: Easy, Fast, Correct — Choose threeDesign Facebook's Live Comments SystemWhat Every Programmer Needs To Know About Game NetworkingPer-room authority, round timing, spectator fan-out
1rate limiterOpenAI 1System design: rate limitingDesign a Distributed Rate LimiterSystem Design Interview – An Insider's Guide, Vols 1–2Token bucket vs sliding window, distributed counters
1eventual consistencyOpenAI 1Phone screen system design about eventual-consistency guaranteesConsistency ModelsDynamo: Amazon's Highly Available Key-value StoreDesigning Data-Intensive Applications, 2nd EditionConsistency models, quorums, conflict resolution
1OS and backend conceptsxAI 1Phone screen: OS conceptual questions and backend topicsBerkeley CS 162 Operating Systems and Systems ProgrammingStanford CS 144 Introduction to Computer NetworkingOS processes, memory, I/O; networking fundamentals
1system design screenxAI 1Phone screen: system design discussion (onsite would have been 2 system design interviews)System Design in a HurryGeneral screen: delivery framework and core concepts
1Slack at scaleOpenAI 1Design Slack; what breaks at 100x or 1000x scale, and how do your assumptions hold up under much larger usage?Real-time MessagingHow Discord Stores Trillions of MessagesScaling PostgreSQL to power 800 million ChatGPT usersWhat breaks at 100x: hot channels, DB load, fan-out
1video streaming platformOpenAI 1Design a streaming platform: handling different frame rates and users worldwide; what changes at 10x, 100x, 1000x usage.Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerYouTube breakdown: transcoding, adaptive bitrate, CDN, global users
1image processing serviceAnthropic 1Design an image processor: single processor then multiple; APIs for submit, check status, cancel; concurrency, producer-consumer, thread saf…Managing Long Running Tasks patternDesign a Distributed Job Scheduler Like AirflowSubmit/status/cancel APIs, worker pools, producer-consumer concurrency
1prompt sharing productAnthropic 1Design a prompt-sharing system: user flows, database schema, sharing mechanics, scaling for viral growthDesign a Collaborative Document Editor Like Google DocsDesign ChatGPTClassic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerSharing model, schema, viral read scaling and caching
1collaborative prompt playgroundAnthropic 1 · 1 staff+Design a Collaborative Prompt Playground: create, edit, test and collaborate on prompts (storage, real-time collaboration, versioning, execu…How Figma's multiplayer technology worksDesign a Collaborative Document Editor Like Google DocsDistributed Systems lecture series (Cambridge)Real-time collaboration, CRDT/LWW sync, prompt storage
1scale event-log processingxAI 1Part 2 of the Spaces problem: system design discussion on scaling the active-time computationThe Dataflow ModelKafka Deep DiveMapReduce: Simplified Data Processing on Large ClustersScaling event-log aggregation: stream windows vs batch
1payments hold and settleOpenAI 1Design a payments pipeline that forwards to a payment processor, holds funds, then batch-settles dailyLedger: Stripe's system for tracking and validating money movementMulti-step Processes patternStripe's payments APIs: The first 10 yearsHold, forward to processor, daily batch settlement and reconciliation
1GitHub ActionsOpenAI 1Design a multi-tenant CI/CD workflow system for many orgs / design GitHub Actions from scratchHow GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.comDesign a Distributed Job Scheduler Like AirflowAvoiding insurmountable queue backlogsMulti-org workflow engine, runner isolation, fair scheduling
1online chess real-timeOpenAI 1Design online chessDesign an Online Chess PlatformOnline chess end to end
1team messagingOpenAI 1Design a Slack-like team messaging serviceReal-time MessagingDesign a Messaging App Like WhatsAppTeam messaging channels, fan-out, storage
1video streamingOpenAI 1Design NetflixClassic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerVideo streaming: encoding pipeline, CDN, metadata
1sandboxed cloud IDEOpenAI 1Design a multi-tenant, isolated cloud IDE / code execution environment (like Google Colab or Replit) from scratchFirecracker: Lightweight Virtualization for Serverless ApplicationsgVisor documentationWe're leaving KubernetesMulti-tenant isolation, microVMs, notebook/IDE lifecycle
11:1 chat at scaleAnthropic 1 · 1 staff+Design a 1:1 chat system; interviewer kept pushing on scale (candidate suspected a Pub/Sub channel design was expected).Design a Messaging App Like WhatsAppHow Discord Stores Trillions of MessagesReal-time MessagingScaling beyond single pub/sub: partitioned routing, storage
1livestream chatAnthropic 1 · 1 staff+Design a Livestream Chat Service.Design Facebook's Live Comments SystemHigh fan-out livestream comments
1CI job execution platformOpenAI 1 · 1 staff+Design GitHub Actions.How GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.comDesign a Distributed Job Scheduler Like AirflowGitHub Actions dispatch and execution
1time-boxed chat MVPOpenAI 1 · 1 staff+Design a Slack-like service with a two-week MVP deadline.Crafting Engineering StrategyReal-time MessagingMVP cut list, then scaling the delivery path
1Claude chat serviceAnthropic 1Design the Claude chat service.Design ChatGPTScaling PostgreSQL to power 800 million ChatGPT usersLLM chat service: streaming, conversations, capacity
1distributed search 1B docsAnthropic 1Design a distributed search system for 1 billion documents at 1 million QPS.Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerBigtable: A Distributed Storage System for Structured DataPost Search and Elasticsearch: sharded inverted index, replicas, QPS
1webhook delivery systemOpenAI 1Design and build a webhook delivery system that reliably delivers events to customer-registered URLs.Webhook scalability: how to scale webhook deliveryDesigning robust and predictable APIs with idempotencyReliable delivery to customer URLs with retries and dedup
1banking app designAnthropic 1Design a banking appSystem Design Interview – An Insider's Guide, Vols 1–2Ledger: Stripe's system for tracking and validating money movementDigital wallet chapter, double-entry balances, transfers
1design YelpOpenAI 1Design Yelp (pre-onsite system design screen, Excalidraw).Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerYelp breakdown and proximity-search deep dive
1design FoursquareOpenAI 1Design Foursquare (pre-onsite system design screen, Excalidraw).Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerProximity search and check-ins, same as Yelp pattern
1design TwitterOpenAI 1Design Twitter (pre-onsite system design screen, Excalidraw).Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerNews feed breakdown: fan-out on write vs read
1notifications systemOpenAI 1Design a notifications system (pre-onsite system design screen, Excalidraw).Design a Notification SystemNotification channels, preferences, retries, dedup
1design then code alternativeOpenAI 1System design round where, after designing a solution, the candidate was asked to code up a new solution using a different method.System Design in a HurryJordan has no life (system design YouTube)Practise alternative designs and trade-offs aloud
1low-level system design E6+Meta MSL 3 · 3 staff+Design RedisDesign a Distributed Cache Like RedisKafka Deep DiveKafka: a Distributed Messaging System for Log ProcessingRedis internals and Kafka log design
1AI-native design MermaidMeta MSL 1AI-native design interview: system design done in CoderPad using Mermaid Markdown diagrams with the authorized AI assistant available.Mermaid diagram syntaxSystem Design in a HurryMermaid diagram syntax plus standard delivery framework
1file cache systemAnthropic 1Design a file cache system.Design a Distributed Cache Like RedisDatabase InternalsCache eviction, sharding, consistency, storage layout
1web crawler designAnthropic 1Design a web crawler.Classic problem breakdowns: YouTube, Post Search, Yelp, News Feed, Web CrawlerWeb crawler breakdown: frontier, politeness, dedup
1design OpenAI PlaygroundOpenAI 1Design the OpenAI Playground.Design ChatGPTClaude API: rate limits and API overviewPlayground product backed by a model API
1task manager with subtasksxAI 1Design a task management system with tasks broken into sub-tasks.Multi-step Processes patternDesign a Distributed Job Scheduler Like AirflowParent/child tasks, workflow state, retries
1file upload for AI chat appxAI 1Design a file upload feature for an AI chat application.Design a File Storage Service Like DropboxPresigned chunked uploads, large-blob pattern, processing
1rate limiter designxAI 1Design a rate limiter.Design a Distributed Rate LimiterDistributed rate limiter design
1design GitHubOpenAI 1Design a system like GitHub and explain how a user interacts with it.Stretching SpokesHow GitHub uses GitHub Actions and Actions larger runners to build and test GitHub.comGit repository replication, CI integration, user flows
1architecture overload protectionAnthropic 1Walk through the end-to-end flow of this architecture, then explain how it handles overload.Google SRE books (Site Reliability Engineering; The Site Reliability Workbook)Avoiding insurmountable queue backlogsFixing retries with token buckets and circuit breakersLoad shedding, cascading failure, retry budgets, backpressure
1malware scanner dashboardxAI 1Design a malware scanner reporting dashboard.Design an Ad Click AggregatorVirusTotal: How it worksScan-result aggregation pipeline and reporting store
1payment system coffee shopOpenAI 1Payment System / Coffee-Shop Ordering: Design the in-store ordering and card-payment system for a coffee chain.Design a Payment System like StripeStripe's payments APIs: The first 10 yearsCard authorization flow and order/payment state
1analytics dashboard AI chatAnthropic 1Design an analytics dashboard for an AI chat appDesign an Ad Click AggregatorTime Series DatabasesThe Dataflow ModelEvent aggregation, OLAP storage, late events
1livestream chat serviceAnthropic 1 · 1 staff+Design a Livestream Chat ServiceDesign Facebook's Live Comments SystemLivestream chat fan-out
1debugging distributed systemsxAI 1How do you approach debugging complex distributed systems?Google SRE books (Site Reliability Engineering; The Site Reliability Workbook)Dapper, a Large-Scale Distributed Systems Tracing InfrastructureA postmortem of three recent issuesTroubleshooting method, tracing, real incident reasoning

All resources

Everything collected for this topic, newest first. 2026 items are marked green. ★ marks a top pick.

Type
Level
Subtopic

  • 2026
    Hello Interview (Evan King, Stefan Mai) · Oct 2026 · Tutorial · Core · ~1.5 h
    Matchmaking, authoritative game state, move validation, clocks and reconnection for real-time 1v1 games.
    L7L7 depth is server-authoritative clocks with latency compensation and recovering a game when a game server dies; this page gets you the skeleton.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Oct 2026 · Tutorial · Core · ~1 h
    Async job APIs (submit, status, cancel), worker pools, queues and progress reporting: the shape of the image-processing and fine-tuning style prompts.
    L7Baseline; add cancellation semantics, visibility timeouts and backpressure to reach staff depth.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Svix · Oct 2026 · Tutorial · Core · ~1 h
    Fan-out from events to per-endpoint deliveries, per-tenant partitioning, retry schedules, dead-letter queues and rate limiting toward slow receivers.
    L7Gives you the vendor's real design choices; at L7 add numbers (deliveries/s, retry backlog after an outage) and isolation of noisy endpoints.
    Vendor guide; treat specific numbers as Svix's.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Sep 2026 · Reference · Intro · ~1 h
    Anthropic's loop structure and reported design prompts (1:1 chat at scale, prompt playground, design-doc review), with notes on how interviewers probe.
    L7Baseline; use it to pick which Anthropic prompts to mock, not as content.
    Some question details are behind Premium.
  • 2026
    Stanford CS · Sep 2026 · Course · Intro · ~20 h
    TCP/IP, congestion control and transport mechanics; the base for reasoning about WebSockets, long-polling, latency and connection limits in real-time designs.
    L7Baseline; skim if known. Useful when an interviewer asks how many persistent connections one box can hold and why.
    Site shows Fall 2026.
  • 2026
    UC Berkeley EECS · Aug 2026 · Course · Intro · ~30 h · video
    OS fundamentals (processes, threads, scheduling, virtual memory, file systems, I/O) that come up in phone-screen 'OS and backend' questions and in sandbox/devbox deep dives.
    L7Baseline; skim if known. Rewatch scheduling, memory and file-system lectures before a devbox or sandbox round.
    Site shows Fall 2026; playlist term not checked.
  • 2026
    UC Berkeley EECS · Aug 2026 · Course · Core · ~25 h
    Alternative to CMU 15-445 with clear notes on indexing, transactions, recovery and distributed transactions (2PC).
    L7Pick one of 15-445 or CS186; the 2PC and recovery notes support payment-system deep dives.
    Fall 2026 offering.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Jul 2026 · Tutorial · Core · ~1.5 h
    Fan-out to many channels and endpoints with retries, rate limits, preferences and dedup; closest worked problem to webhook delivery.
    L7Baseline; L7 webhook answers add per-endpoint isolation, retry scheduling at billions/day and signing (see Svix and AWS backlog posts).
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Jun 2026 · Tutorial · Core · ~1 h
    Sagas, workflow engines (Temporal) and event sourcing for processes that span services: payments, CI pipelines, tasks with sub-tasks.
    L7Lets you argue durable-execution engines vs hand-rolled state machines and compensation for partial failure.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Michael Lynch · Jun 2026 · Tutorial · Core · ~1 h
    Practical guidance on writing and reviewing design docs, including how to give useful feedback.
    L7Use the feedback chapter to rehearse a design-doc review round: prioritise the two flaws that matter, not ten nits.
    Excerpts free; full book paid.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · May 2026 · Tutorial · Core · ~1.5 h
    LLM chat product: streaming responses, conversation storage, GPU-backed inference queueing and rate limiting; the closest public write-up to 'design the Claude chat service'.
    L7Lets you discuss token streaming, resumable generations and per-tenant quotas; L7 adds cost per request and graceful degradation when GPU capacity is short.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Martin Kleppmann, Chris Riccomini (O'Reilly) · Mar 2026 · Book · Advanced · ~40 h · paid
    The reference for replication, partitioning, transactions, consistency, stream processing and derived data, updated in 2026 for cloud-native storage; every deep-dive question traces back to a chapter here.
    L7Lets you defend a consistency or partitioning choice from first principles and name the failure mode of the alternative, which is the main L7 probe.
    Paid. 2nd edition published March 2026 (O'Reilly page 403s to curl).
  • 2026
    Robert Morris, Frans Kaashoek (MIT PDOS) · Feb 2026 · Course · Advanced · ~80 h · video
    Paper-driven course (GFS, Raft, ZooKeeper, Spanner, Chain Replication, DynamoDB guest talk) with Go labs that build MapReduce, Raft and a sharded fault-tolerant KV store.
    L7Building Raft and a sharded KV store yourself is what lets you answer 'what happens when the leader dies mid-write' without hand-waving.
    Public videos are from Spring 2020; 2026 materials are notes, papers and labs.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~2 h
    1:1 and small-group chat with offline delivery, message inbox per device, WebSocket connection routing and pub/sub between chat servers.
    L7Mid-level answer by itself; at L7 add explicit ordering guarantees, at-least-once plus client dedup, and DB load numbers for 100M DAU.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    High fan-out real-time delivery to many viewers of one stream: SSE vs WebSocket, partitioned pub/sub, and why per-viewer state is avoided.
    L7Use it to argue fan-out cost per message and when to drop or sample; that's the livestream and spectator follow-up.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    Running untrusted user code: job queue, isolated containers, resource limits, and result delivery; a template for code-execution, malware-analysis and CI runner questions.
    L7Mid-level isolation story; L7 goes to microVMs vs gVisor, noisy-neighbour limits and warm pools (see Firecracker and gVisor).
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    Agent → ingestion → Kafka → time-series store → query/alerting, with cardinality and retention trade-offs.
    L7Baseline structure; L7 adds late/out-of-order data handling, downsampling policy and alert evaluation at scale (Monarch, Gorilla, Dataflow).
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    Scheduling, leasing and retrying jobs and DAG steps; the base for CI/CD pipelines and task systems with sub-tasks.
    L7Lets you defend lease-based exactly-once-effect execution and what happens when a worker dies mid-job.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    Presigned uploads, chunking, content hashing for dedup, metadata DB and sync; covers photo storage with SHA-256 dedup and file upload for chat apps.
    L7Lets you handle reference counting on delete and concurrent uploads of the same hash, which is where interviewers push.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    Stream aggregation with Kafka and Flink, idempotent counting, reconciliation with a batch path; maps to analytics dashboards and per-type IoT metrics.
    L7Lets you explain exactly-once aggregation and late data reconciliation, the heart of the IoT and analytics prompts.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1 h
    Polling vs long-polling vs SSE vs WebSockets, plus server-side pub/sub for routing updates to the right connection.
    L7Baseline; at L7 you should quote connection counts per host and explain reconnection storms.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · Feb 2026 · Tutorial · Core · ~1.5 h
    Partitions, consumer groups, ordering, retention and exactly-once semantics as used in interview designs.
    L7Lets you say precisely what ordering and delivery guarantee you get per partition, and when Kafka is the wrong tool.
  • 2026
    Bohan Zhang (OpenAI) · Jan 2026 · Blog post · Advanced · ~1 h
    OpenAI's single-primary Postgres with ~50 read replicas, connection pooling, cache-stampede protection, workload isolation and why they deferred sharding.
    L7A frontier-lab example of choosing what not to build (sharding) and defending it with load numbers; cite it in chat and playground designs.
    openai.com blocks curl; title and content confirmed via search and secondary coverage.
  • 2026
    Donne Martin · 2026 · Practice · Intro · ~8 h
    Free index of building blocks (caching, replication, queues, consistency) with Anki cards and solved exercises; good for filling vocabulary gaps fast.
    L7Baseline; skim if known. Does not reach staff depth on failure handling.
    Ongoing repo; core content is older (2017–2020).
  • 2026
    Mermaid project · 2026 · Tool · Intro · ~1 h
    Text-based diagramming used in AI-assisted, CoderPad-style design rounds; practising flowchart and sequence diagrams avoids fumbling syntax live.
    L7Baseline; one hour of practice so the tool never costs you interview time.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · 2026 · Tutorial · Core · ~1 h
    Token bucket vs sliding window, centralized Redis counters vs local limits, and failure behaviour; also the core of a model-API gateway.
    L7Lets you discuss fail-open vs fail-closed and global vs per-region limits.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · 2026 · Tutorial · Core · ~1 h
    Consistent hashing, replication, eviction and hot keys for a cache or in-memory store; covers 'design Redis' and file-cache prompts.
    L7Lets you handle hot-key and rebalancing follow-ups; L7 adds what consistency the cache promises its clients.
  • 2026
    Hello Interview (Evan King, Stefan Mai) · 2026 · Practice · Core · ~6 h
    Worked answers for the standard screen prompts (video streaming/Netflix, search over billions of documents, Yelp/Foursquare proximity, Twitter feed, web crawler).
    L7Baseline for pre-onsite screens; at L7 practise them only to rehearse leading the discussion and estimating.
    Some pages have a Premium gate part-way.
  • 2026
    Google · 2026 · Reference · Advanced · ~1.5 h
    User-space kernel that intercepts syscalls to sandbox containers; architecture, security model and performance trade-offs.
    L7Lets you explain what happens inside the sandbox when user code runs a syscall, and when to prefer microVMs.
  • 2026
    VirusTotal (Google) · 2026 · Reference · Core · ~0.5 h
    How a production malware-analysis service fans a file out to many scanners and sandboxes, stores reports and serves results.
    L7Use as the reference pipeline for malware-analysis prompts; L7 adds isolation of detonation hosts and backpressure across scanners.
  • 2026
    Kyle Kingsbury (Jepsen) · 2026 · Reference · Advanced · ~2 h
    Clickable map of consistency models (linearizable, sequential, causal, read-your-writes, serializable, snapshot isolation) with precise definitions.
    L7Lets you name exactly which guarantee your design gives and what anomaly a client can see, the core of eventual-consistency screens.
  • 2026
    Anthropic · 2026 · Reference · Core · ~0.5 h
    How a frontier lab exposes models to developers: API keys, workspaces, per-tier request/token limits, streaming and error codes.
    L7Lets you ground a 'design APIs for our models' answer in the real contract (token-based limits, 429 handling) and then argue the gateway behind it.
  • 2026
    OpenTelemetry (CNCF) · 2026 · Reference · Core · ~0.5 h
    Versioned schema URLs and transformations that map renamed attributes and metrics between versions.
    L7Gives a principled answer to 'old clients send different names for the same metric': versioned schemas plus server-side translation.
  • 2026
    Amazon Web Services · 2026 · Reference · Core · ~1 h
    Desired vs reported state per device, versioning and delta messages for devices that are offline or ignore commands.
    L7Lets you design command dispatch with reconciliation for devices that may not receive or execute (grid dispatch, IoT log requests).
  • 2025
    Hello Interview (Evan King, Stefan Mai) · Nov 2025 · Tutorial · Core · ~1 h
    How TSDBs store and compress metrics, handle cardinality and downsample; supports metrics, electricity-monitoring and IoT prompts.
    L7Baseline; go to Gorilla and Monarch for the numbers.
  • 2025
    Will Larson · Oct 2025 · Book · Advanced · ~8 h · paid
    How staff+ engineers write strategy and design guidance: diagnosis, policies, operations, and testing a strategy before rolling it out.
    L7Supplies the org-level judgment L7 rounds look for: scoping an MVP, choosing what not to build, and justifying it to other teams.
    Book (O'Reilly, 2025); essays free.
  • 2025
    Hello Interview (Evan King, Stefan Mai) · Sep 2025 · Reference · Intro · ~1 h
    Round-by-round description of OpenAI's loop with the reported system-design prompts (payments, webhooks, CI/CD, devbox, chess), so you know which designs to drill.
    L7Baseline; read once to calibrate what 'staff signal' looks like in OpenAI's design rounds versus L5.
    Some question details are behind Premium.
  • 2025
    Andy Pavlo (CMU) · Sep 2025 · Course · Core · ~40 h · video
    Full recorded lecture series on storage, indexing, query execution, concurrency control, logging/recovery and distributed databases, plus the BusTub C++ projects.
    L7Watch concurrency control, recovery and distributed DB lectures; they let you reason about isolation levels and write-ahead logs under interviewer pressure.
  • 2025
    Anthropic · Sep 2025 · Blog post · Advanced · ~0.5 h
    Anthropic's write-up of three overlapping production bugs (routing, TPU output corruption, compiler bug) across multiple hardware platforms and why detection was hard.
    L7A real frontier-lab incident to reason from in 'how do you debug complex distributed systems' and design-doc-critique rounds.
  • 2025
    Hello Interview (Evan King, Stefan Mai) · Jul 2025 · Tutorial · Core · ~1.5 h
    Payment intents, idempotency keys, webhook callbacks to merchants, and reconciliation with the external processor.
    L7Mid-level baseline; pair with Stripe's ledger and idempotency posts for holds, settlement batches and double-entry correctness.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2025
    Jordan Epstein · 2025 · Video · Core · ~20 h · video
    Long whiteboard videos that go into storage engines, replication, stream processing and full problem walkthroughs, closer to DDIA depth than most interview channels.
    L7Good for hearing internals argued aloud (e.g. why Flink over a cron job); pick episodes on topics you are weakest in.
    Date is approximate (channel active through 2025).
  • 2025
    GreatFrontEnd (Yangshun Tay) · 2025 · Tutorial · Core · ~6 h · paid
    Frontend-heavy design framework (component architecture, state, API contract, rendering, offline) for full-stack rounds that start from a product spec.
    L7Use only if a loop includes a full-stack/frontend design round; staff signal is the API and data contract between client and server.
    Partly free; full playbook needs a paid plan. Date approximate.
  • 2024
    Christian Weichel, Alejandro de Brito Fontes (Ona, formerly Gitpod) · Oct 2024 · Blog post · Advanced · ~1 h
    Six years of running cloud development environments on Kubernetes: storage, startup latency, resource sharing and security problems, and why they moved off it.
    L7The best public post-mortem on devbox platforms; lets you pre-empt the hard parts (disk state, cold start, noisy neighbours) in a devbox round.
  • 2024
    Hello Interview (Evan King, Stefan Mai) · Jul 2024 · Tutorial · Intro · ~6 h
    Fastest route to the requirements → entities → API → high-level design → deep dives delivery framework that interviewers at OpenAI and Anthropic expect, plus core concepts and numbers to know.
    L7Baseline; skim if known. Use it only to lock in a 45-minute pacing script so the deep dives get the time.
  • 2024
    Hello Interview (Evan King, Stefan Mai) · Jul 2024 · Tutorial · Core · ~1.5 h
    Real-time collaborative editing with OT/CRDTs, document servers, presence and versioning; the core of a collaborative prompt playground.
    L7Use it for the collaboration layer; L7 means choosing OT vs CRDT vs Figma-style last-writer-wins per field and justifying it.
    Free preview; the page has a 'Premium to Keep Reading' gate, so later deep dives may need Hello Interview Premium.
  • 2024
    David Mazières (Stanford) · Apr 2024 · Course · Advanced · ~25 h
    Graduate paper course on consensus (Paxos, Raft, Byzantine), replication, consistency and large-scale storage; reading the papers with the course notes builds argument skill.
    L7Lets you discuss Paxos/Raft variants and linearizability with the precision a senior-staff infra interviewer will test.
    Spring 2024 is the latest offering found.
  • 2024
    Stripe Engineering · Feb 2024 · Blog post · Advanced · ~1 h
    Immutable double-entry ledger with automated balance checks that detect missing or duplicated money movements across systems.
    L7Lets you design holds, captures and settlement as ledger entries and explain how you'd detect drift, which separates staff from mid-level payment answers.
  • 2024
    Andy Pavlo (CMU) · Jan 2024 · Course · Advanced · ~30 h
    Analytical database internals (columnar storage, vectorized execution, query optimization, lakehouse systems) with a reading list of modern papers.
    L7Optional depth for metrics/analytics designs: lets you argue columnar OLAP storage and pre-aggregation trade-offs concretely.
    Course root returned 503 at check time; the Spring 2024 page loads.
  • 2023
    GitHub Engineering · Sep 2023 · Blog post · Core · ~0.5 h
    How a large monorepo's CI runs on hosted larger runners: job fan-out, runner sizing and cost.
    L7Use with the runner-controller docs to describe the dispatch path (job queue → runner long-poll → ephemeral VM) a GitHub Actions design needs.
    GitHub has not published a full hosted-runner architecture; this plus ARC docs is the closest first-party material.
  • 2023
    Slack Engineering · Apr 2023 · Blog post · Advanced · ~1 h
    Slack's channel servers, gateway servers, admin/presence servers and consistent hashing of channels for real-time delivery.
    L7Lets you describe a real production chat topology and its failure handling instead of a generic pub/sub box.
    Date from memory of publication (2023); page lists only recent-post dates.
  • 2023
    Bo Ingram (Discord) · Mar 2023 · Blog post · Advanced · ~1 h
    Migration from Cassandra to ScyllaDB, hot-partition problems, request coalescing in Rust data services and the bucketed (channel, time) partition key.
    L7Lets you defend a message storage schema at 100M DAU and explain hot channels, which is the 'DB load at this scale' follow-up.
  • 2022
    Marc Brooker · Feb 2022 · Blog post · Advanced · ~0.5 h
    Simulation-backed argument for retry budgets over plain backoff when a dependency is overloaded.
    L7Lets you quantify retry amplification during an outage, which is the overload-protection probe.
  • 2022
    Alex Xu (Vol 2 with Sahn Lam) / ByteByteGo · 2022 · Book · Core · ~30 h · paid
    Worked chapters for chat, notification, rate limiter, autocomplete (Vol 1) and payment system, digital wallet, metrics monitoring and alerting (Vol 2); each has numbers, data models and diagrams.
    L7Mid-level depth: use the payment, wallet and metrics chapters as a checklist, then go deeper with the ledger, Gorilla and Monarch sources.
    Vol 1 2020, Vol 2 2022. Paid book or ByteByteGo subscription; newsletter partly free.
  • 2022
    Roberto Vitillo · 2022 · Book · Core · ~12 h · paid
    Compact tour of communication, coordination, scalability, resiliency and maintainability written by an ex-Microsoft/Mozilla engineer; the resiliency part (timeouts, retries, circuit breakers, load shedding) maps directly to interview deep dives.
    L7Bridge book: read the resiliency and operations parts closely; skim the rest if DDIA is done.
    Paid.
  • 2021
    Kenton Varda (Cloudflare) · Aug 2021 · Blog post · Advanced · ~1 h
    Single-threaded per-object actors with co-located storage and output gating; a clean model for one game room, chat room or document per actor.
    L7Lets you propose 'one authoritative actor per room' for chess, typing races or trivia and reason about its consistency and failover.
  • 2020
    Michelle Bu (Stripe) · Dec 2020 · Blog post · Advanced · ~1 h
    How Stripe evolved from Charges to PaymentIntents to handle async authorization, 3DS and many payment methods with a state machine.
    L7Lets you model authorization → hold → capture → settle as an explicit state machine and argue API evolution.
  • 2020
    Martin Kleppmann (University of Cambridge) · Nov 2020 · Course · Core · ~8 h · video
    Eight hours of short videos on clocks, broadcast ordering, replication, quorums, consensus and CRDTs, with written notes.
    L7Fastest way to make logical clocks, quorums and CRDTs feel natural before collaborative-editing or chat-ordering questions.
  • 2020
    Adams et al. (Google), VLDB · Aug 2020 · Paper · Advanced · ~3 h
    Regional zones, push-based ingestion, in-memory storage and a global query layer for Google's monitoring.
    L7Lets you defend availability over consistency for monitoring, and zone-local ingestion, which is the L7 metrics answer.
  • 2020
    Malte Ubl · Jul 2020 · Blog post · Core · ~0.5 h
    Structure of a Google design doc (context, goals and non-goals, design, alternatives considered, cross-cutting concerns) and when not to write one.
    L7Gives you the checklist to critique someone else's doc: missing non-goals, no alternatives, no failure or migration story.
  • 2020
    Agache et al. (AWS), NSDI · Feb 2020 · Paper · Advanced · ~2 h
    MicroVMs with ~125 ms boot and small memory overhead that run AWS Lambda; the isolation layer of choice for devboxes and code sandboxes.
    L7Lets you choose containers vs gVisor vs microVMs for untrusted code with real overhead numbers, the key devbox/sandbox probe.
  • 2020
    Malcolm Featonby (AWS Builders' Library) · 2020 · Blog post · Advanced · ~0.5 h
    Client request tokens, semantic equivalence of retried requests and late-arriving duplicates in AWS APIs.
    L7Lets you handle the 'same key, different payload' and 'retry after success' edge cases interviewers push on.
  • 2020
    David Yanacek (AWS Builders' Library) · 2020 · Blog post · Advanced · ~1 h
    Multi-tenant queue fairness, shuffle sharding, sidelining hot tenants, LIFO during backlog and backpressure.
    L7Lets you design per-endpoint isolation for webhooks and per-tenant fairness for CI queues, a common senior-staff follow-up.
  • 2019
    Evan Wallace (Figma) · Oct 2019 · Blog post · Advanced · ~1 h
    Server-authoritative, per-property last-writer-wins sync inspired by CRDTs, with one process per document.
    L7Lets you argue a simpler-than-OT design for a collaborative prompt playground and say what you give up.
  • 2019
    Alex Petrov (O'Reilly) · 2019 · Book · Advanced · ~25 h · paid
    Storage engines (B-trees, LSM trees) and distributed-system chapters (failure detection, leader election, consensus, anti-entropy) in one book.
    L7Lets you justify Cassandra vs Postgres vs a custom log at the storage-engine level when an interviewer asks 'why this database?'.
    Paid; older but canonical.
  • 2019
    Marc Brooker (AWS Builders' Library) · 2019 · Blog post · Core · ~0.5 h
    How to set timeouts, cap retries, add jitter and avoid retry storms.
    L7Baseline reliability vocabulary; required before the queue-backlog and token-bucket posts.
  • 2017
    Slack Engineering · Dec 2017 · Blog post · Advanced · ~1 h
    Putting Kafka in front of a Redis job queue after Redis memory exhaustion caused an outage; durable enqueue, rate-limited relay and worker scaling.
    L7A concrete failure story you can cite when defending a durable queue in front of workers for webhooks or CI jobs.
    Date from memory (late 2017).
  • 2017
    Brandur Leach (Stripe) · Feb 2017 · Blog post · Advanced · ~0.5 h
    Idempotency keys, safe retries with exponential backoff and how Stripe's API makes charge creation retry-safe.
    L7Lets you specify idempotency key scope, storage and expiry, which every payments and webhook interviewer drills.
  • 2016
    GitHub Engineering · Sep 2016 · Blog post · Advanced · ~0.5 h
    How GitHub replicates Git repositories across three file servers with a three-phase commit for writes.
    L7Lets you discuss the storage layer of 'design GitHub' beyond 'put repos in S3'.
    Date from memory (2016); page shows later update dates.
  • 2016
    Google · 2016 · Book · Core · ~15 h
    Free chapters on overload handling, cascading failures, monitoring, SLO alerting, troubleshooting and release engineering; the vocabulary interviewers use for the 'what breaks' part.
    L7Lets you talk about load shedding, retry budgets and SLO-based alerting with the specifics staff interviewers expect.
    SRE book 2016, Workbook 2018; free online.
  • 2015
    Pelkonen et al. (Facebook), VLDB · Aug 2015 · Paper · Advanced · ~2 h
    Delta-of-delta timestamps and XOR value compression (1.37 bytes/point) for Facebook's monitoring TSDB.
    L7Gives you the storage numbers to size a metrics platform in the interview instead of guessing.
  • 2015
    Akidau et al. (Google), VLDB · Aug 2015 · Paper · Advanced · ~3 h
    Event time vs processing time, windows, watermarks, triggers and accumulation for out-of-order data.
    L7Lets you answer 'logs arrive late from offline devices, how do metrics update?' with watermarks and retractions rather than a vague batch re-run.
  • 2014
    Diego Ongaro, John Ousterhout (Stanford), USENIX ATC · Jun 2014 · Paper · Advanced · ~3 h
    Leader election, log replication and safety in a consensus protocol designed to be teachable; the basis of etcd and most coordination services.
    L7Lets you explain what a coordinator actually guarantees and its failure behaviour, instead of naming 'ZooKeeper' as a black box.
  • 2012
    Corbett et al. (Google), OSDI · Oct 2012 · Paper · Advanced · ~3 h
    TrueTime, Paxos groups and externally consistent transactions across regions.
    L7Lets you say what global strong consistency costs in commit latency, and when a payments ledger needs it.
    Older but canonical.
  • 2011
    Jay Kreps, Neha Narkhede, Jun Rao (LinkedIn), NetDB · Jun 2011 · Paper · Advanced · ~2 h
    Why a partitioned append-only log with consumer-tracked offsets beats traditional brokers for throughput.
    L7Lets you argue log-based messaging vs Redis pub/sub or SQS for chat, webhooks and telemetry with throughput reasoning.
    Mirror PDF of the NetDB'11 paper; Kafka docs are the maintained reference.
  • 2010
    Beaver et al. (Facebook), OSDI · Oct 2010 · Paper · Advanced · ~2 h
    Packing many photos into large volume files to cut metadata I/O, with a directory, cache and store tier.
    L7Lets you argue why object storage plus a metadata DB fails at photo scale and what a custom blob store buys.
  • 2010
    Sigelman et al. (Google) · Apr 2010 · Paper · Advanced · ~2 h
    Sampled distributed tracing with low overhead; the base for answering how you debug a request that crosses many services.
    L7Lets you describe an observability strategy (traces + metrics + logs, sampling) instead of 'add logging'.
    Google technical report.
  • 2010
    Glenn Fiedler (Gaffer On Games) · Feb 2010 · Blog post · Core · ~1 h
    Lockstep vs client-side prediction vs authoritative server, and why latency hiding matters in real-time games.
    L7Lets you answer 'reduce network delay differences between players' in a typing race or trivia round.
    Older but canonical.
  • 2007
    DeCandia et al. (Amazon), SOSP · Oct 2007 · Paper · Advanced · ~3 h
    Consistent hashing, sloppy quorums, hinted handoff, vector clocks and anti-entropy in a production system; the origin of most 'AP' store designs.
    L7Lets you critique leaderless replication: when it loses writes and what the client must do to reconcile.
    Older but canonical.
  • 2006
    Chang et al. (Google), OSDI · Nov 2006 · Paper · Advanced · ~3 h
    Sorted wide-column store on GFS with tablets, SSTables and a Chubby-based master; the model behind HBase and Cassandra's data layout.
    L7Lets you design row keys to avoid hot tablets, a frequent probe in chat and metrics storage.
    Older but canonical.
  • 2006
    Mike Burrows (Google), OSDI · Nov 2006 · Paper · Advanced · ~2 h
    Coarse-grained locks, leases and leader election as a service, with honest notes on how clients misuse it.
    L7Lets you discuss fencing tokens and lease expiry, which is how CI/CD and job platforms avoid double execution.
    Older but canonical.
  • 2004
    Jeffrey Dean, Sanjay Ghemawat (Google), OSDI · Dec 2004 · Paper · Advanced · ~2 h
    Batch processing with re-execution for fault tolerance and straggler backup tasks.
    L7Lets you defend a batch reconciliation path next to a streaming path, and explain backup tasks for stragglers.
    Older but canonical.
Not found or not verified. No public first-party architecture of GitHub-hosted Actions runners exists; covered with ARC docs plus GitHub's own CI post. No Stanley Chiang YouTube channel found (only his book 'Hacking the System Design Interview', not verified with a stable URL, so omitted). Webhook delivery has no large-scale production post-mortem from Stripe/GitHub; Svix's vendor guide is the best public design write-up. MIT 6.5840 public videos are from 2020; the 2026 term has notes and labs only. CMU 15-440 and the 15-721 root returned 503. Will Larson has no dedicated design-doc review essay; his strategy book plus Malte Ubl and Michael Lynch cover writing and critique. Hello Interview payment, chess, metrics, job-scheduler, notification, Google Docs, ChatGPT and pattern pages show a Premium gate part-way. OpenAI's 'Grid' prompt is never described in the reports, so its coverage is framework-level only. Airbnb's 'Avoiding double payments' post (Medium) is Cloudflare-blocked and was left out. Links checked 27 Oct 2026.