Build a real system, one step at a time

Sell seats without ever selling one twice, keep browsing fast for 50,000 readers a second, and survive the moment a big show goes on sale.

• Separate a read-heavy path from a contended write path
• Hold seats safely with a guarded write and an expiry
• Keep a slow third party off the request path with a queue
• Plan for an on-sale spike with caching, scaling and a waiting room

Build a chat service that accepts every message exactly once, delivers it in order to online devices in moments, lets offline phones catch up, and keeps working when a connection server dies.

• Separate long-lived connections from stateless message handling
• Accept messages durably, deduplicate retries and order them per conversation
• Deliver through a queue to online devices and fall back to push for offline ones
• Size a connection tier with N+1 headroom and prove it with a failure test

Serve 50,000 feed loads a second from precomputed timelines, fan posts out through a queue, handle celebrities with millions of followers, and recover when the feed cache goes cold.

• Choose between fan-out on write and fan-out on read, and combine them for celebrities
• Precompute timelines with a queue and workers, and serve them from a cache
• Size a read-heavy system so it holds peak load with headroom
• Explain what happens when the feed cache goes cold, and how to soften it

Accept large uploads straight into object storage, transcode them into adaptive bitrate renditions through a queue, serve playback from a CDN, and keep the origin standing when a video goes viral.

• Keep video bytes out of application servers with presigned, resumable uploads
• Build an asynchronous transcoding pipeline that's safe to retry
• Explain adaptive bitrate streaming: renditions, segments and manifests
• Serve playback from a CDN and size the origin for a viral video

Ingest a stream of driver locations, find nearby drivers with a geo index, send expiring offers and assign each ride to exactly one driver, then hold rush hour and a New Year's Eve spike.

• Keep high-rate location updates in a sharded in-memory geo index, not the primary database
• Absorb location bursts with a log and consumers
• Assign a ride to exactly one driver with conditional writes and expiring offers
• Size the system for peak and for a known spike

Sync files across a user's devices: upload only the chunks that changed, commit versions safely, tell other devices through a change journal, handle conflicts, and catch up when sync workers fall behind.

• Split files into content-addressed chunks so edits upload only what changed
• Separate metadata (database) from bytes (object storage)
• Drive device sync from an ordered change journal with cursors
• Detect and preserve conflicting edits instead of losing data

Accept notifications from every service exactly once, deliver them by email, SMS and push according to user preferences, retry through provider outages, and never send the same message twice.

• Accept requests fast and send asynchronously through a queue and workers
• Make submissions and provider calls idempotent
• Size workers and provider throughput, and survive a provider outage
• Respect preferences, priorities and rate limits per user

Design a high-throughput, low-latency distributed caching tier with consistent hashing, cache-aside reads, thundering herd prevention, and reliable invalidation.

• Partition keys across cache nodes using consistent hashing with virtual nodes
• Prevent cache stampedes (thundering herds) with single-flight request coalescing and TTL jitter
• Implement cache-aside reads with reliable asynchronous invalidation through an outbox and worker
• Size cache capacity and survive cache node failures without cascading database collapse

Schedule a bounded, polite crawl with URL deduplication, per-host rate limits, DNS caching, robots.txt compliance, and resilience to fetcher pool failures.

• Structure an asynchronous crawl pipeline using a URL frontier and worker pool
• Enforce per-host politeness and robots.txt rules across distributed workers
• Deduplicate URLs using seen sets or Bloom filters and cache DNS queries
• Survive fetcher pool failures and safely retry leased URLs

Schedule delayed and recurring background jobs with durable definitions, expiring leases, fencing tokens, leader election, retry policies, and crash resilience.

• Decouple job submission from background execution using databases, schedulers, and queues
• Guarantee at-least-once execution with idempotent workers, expiring leases, and fencing tokens
• Handle worker and scheduler failures without losing or duplicating critical jobs
• Design retry backoff strategies, dead-letter queues, and multi-tenant priority lanes

Let many people edit one document at the same time: real-time sync over WebSockets, one owner per document, merging concurrent edits, a durable operation log with snapshots, and surviving a server crash without losing a keystroke.

• Sync edits in real time through one owner per document over WebSockets
• Explain how operational transformation and CRDTs make concurrent edits converge
• Store small operations in a durable log and serve opens from snapshots
• Survive losing a document server without losing or duplicating edits

Charge customers through external payment providers exactly once: idempotency keys at every boundary, an explicit payment state machine, asynchronous charging, a double-entry ledger, provider failover and daily reconciliation.

• Make payment requests and provider calls idempotent so retries never charge twice
• Model payments as a state machine that treats timeouts as unknown, not failed
• Record money as an append-only, double-entry ledger
• Keep payments flowing through a provider outage and reconcile against provider reports

Count a firehose of views and serve the most-viewed videos per hour, day and month: counting on the write path through a partitioned stream, merging local top-K lists, approximate sketches, edge caching, and absorbing a viral burst.

• Move counting from the read path to the write path with a partitioned stream
• Merge per-partition top-K lists into a global answer
• Choose between exact counts and count-min sketches, and add a batch path for exact numbers
• Serve identical answers from a CDN and cache, and absorb bursts in the stream

Stream any of 100 million tracks to 30 million listeners at once: audio in object storage behind a CDN, a cached metadata path, play events counted off the request path, and a release-day spike.

• Separate large immutable media from small, hot metadata
• Put a CDN in front of audio and a cache in front of the metadata database
• Count play events through a stream so playback never waits for analytics
• Size the request path for a spike and give consumers room to catch up

Answer route and arrival-time queries that follow live traffic: a precomputed road graph, a stream of speed reports aggregated per road segment, a route cache, a rush-hour spike and a lost traffic store.

• Explain why routing on a continent needs a precomputed graph
• Turn millions of GPS pings into per-segment speeds with a stream pipeline
• Cache routes with a key that bounds staleness
• Size an ingest pipeline for rush hour and keep live speeds through a store failure

Receive, store, search and send mail without ever losing a message: a durable queue at the door, scanning workers, mailboxes partitioned by user with attachments in object storage, an asynchronous search index, a newsletter blast and a search outage.

• Accept mail only after a durable write, and process it asynchronously
• Partition mailboxes by user and keep large attachments in object storage
• Feed a per-user search index asynchronously so search can fail without losing mail
• Absorb a burst of inbound mail with a queue and size the stores behind it

Keep a vote-ranked front page fresh while votes pour in: hot rows that break a naive design, a vote log with a batching aggregator, ranking formulas, precomputed lists in a cache and at the edge, a front-page spike and an aggregator outage.

• Recognize a hot-row write pattern and move counting to a log and an aggregator
• Explain the hot and best ranking formulas
• Serve precomputed ranked lists from a cache and a CDN
• Size for catch-up after a consumer outage so recovery doesn't overload the database

Show who is online right now for 100 million connected users: heartbeats into an in-memory store with expiry, the fan-out of each status change to friends, and a gateway zone that dies with a million users on it.

• Choose heartbeats with expiry over connect and disconnect events
• Estimate a heartbeat write rate and size an in-memory presence store
• See how fan-out to friends multiplies the push load, and cut it down
• Spread gateways across zones so one failure doesn't take presence down

Build a store that stays writable when machines die: keys placed on a hash ring, replicated to N nodes, coordinated with tunable W and R quorums, repaired with hinted handoff and Merkle trees, and reconciled with vector clocks.

• Place and replicate keys with consistent hashing and virtual nodes
• Choose W and R for a replication factor N, and show why R + W > N gives overlap
• Watch W = N fail on a single node loss, and W = 2 of 3 survive it
• Explain hinted handoff, read repair, anti-entropy and conflict resolution