One route through all of system design.

Reuses the LB/scaling you just learned and layers on durable object storage, CDN read path and the outbox/CDC/DLQ trio on a still-easy system.

A fast, self-contained win — token-bucket and sharded counters, the first time state must be shared correctly across servers.

The smallest possible correctness problem — one endpoint plus retries and an idempotency key turns 'charged twice' into 'charged once', the most-reused reliability trick.

A compact, very common interview warm-up whose needs are all met — Snowflake IDs force first contact with clock sync and graceful degradation.

The build track's zero-prereq great-first-problem — storage from first principles (append-only log, hash index, compaction, fsync) that every later database reuses, bridging into Phase 2.

Bitcask taught append-only logs; the B-tree is its read-optimized dual — paged storage, buffer pool, WAL and MVCC underpin every relational engine ahead.

Fuses bitcask's log with btree's pages into the LSM tree, adding bloom filters and leveled compaction that Cassandra/RocksDB/Kafka all demand.

Distribute the LSM engine: the canonical home for quorums, leaderless replication, CAP, gossip and Merkle anti-entropy — one problem that unlocks tunable consistency for the entire design track.

A document store on the B-tree with oplog replication and quorum (all now taught) — adds scatter-gather and the embedding-vs-referencing tradeoff.

A specialized LSM + inverted index for metrics — introduces time-series storage, downsampling and the cardinality trap the observability track reuses.

Needs only hashing + sorted structures; the read-side index that powers every search product later (Elasticsearch, autocomplete, logging, yelp).

The object store other systems treat as a black box, built while replication is fresh — erasure coding, content-addressable chunking and read-after-write consistency the file/media capstones lean on.

Pastebin used a CDN as a black box; open it — anycast, TTL, ETag/conditional GET, stale-while-revalidate and cache-key design (authored anchor for the phase).

url-shortener named load balancing; now build it — L4/L7, health checks, power-of-two-choices and connection draining.

With caching + TTL + hot-key internalized, confront the classic production failure: coordinated expiry and thundering herds.

A short companion to stampede — cache the absence of data behind a bloom filter to kill pointless lookups.

Assemble consistent hashing + TTL + stampede defenses into a Memcached-style fleet; adds rendezvous hashing.

The caching capstone — single-threaded event loop, data-structure encodings, COW snapshots and replication/failover (needs CAP from build-wcs and leader election from pastebin, both now taught).

The hard version of everything above — keeping a global cache fleet coherent with two-generals, leases, write-behind and consistency monitoring; all its needs (pub/sub, cdc, eventual consistency) are now taught.

Build the queue everything else assumes: at-least-once vs exactly-once, leases, dead-letter queues and backpressure (authored anchor).

Extend the queue to one-to-many — fan-out on write, push vs pull and delivery-semantics tradeoffs, seeding fan-out for feeds and chat.

First real use of the queue+idempotency stack — retries with backoff, DLQ and the outbox pattern for reliable external delivery.

Run work exactly once across a fleet using the queue plus a lightweight leader — a gentle first taste of leader election and DAG scheduling.

The canonical fan-out consumer — queues, pub/sub, DLQ, rate limiting, consumer-group rebalancing and provider bulkheads at scale.

Push the fan-out to 100M (build-pubsub already taught fan-out on write) — amplification, dedup, backpressure and DLQ under extreme skew.

Authored presence anchor that introduces WebSockets and sharded presence state at social-graph scale, establishing the primitives the rest of the phase reuses.

The minimal ephemeral case now that presence is understood — TTL-based expiry and debounce with almost no failure modes.

Same presence primitives fanned out to a document's viewers with live cursor broadcast — the on-ramp to collaboration.

First real backpressure problem — a firehose feed where slow clients must not stall fast ones; introduces causal ordering.

Real-time plus correctness — optimistic concurrency, bid ordering, anti-sniping and fairness over WebSockets.

A live counter under extreme hot-key load — edge fan-in, request coalescing and HyperLogLog for approximate concurrency.

High-volume live fan-out introduces load shedding and fail-open-vs-closed under overload.

Broadcast to millions — thundering-herd control on reconnect, last-event-id replay, anycast edge and tiered storage.

The first hot-key write problem — sharded counters, CRDT counters and idempotent dedup on top of the queue + replication you now have.

Fan-out on write meets per-recipient state and exposes the write-amplification tradeoff in miniature.

Introduces the lambda architecture — a speed layer (sharded counters + HLL) reconciled by a batch/stream layer; seeds stream processing for the whole data-intensive tier.

Vote-driven ranking sits right on top of sharded counters, adding a bloom-filter seen-check and feed materialization.

THE feed problem — fan-out on write vs read vs hybrid, push-vs-pull and the celebrity hot key, plus cursor pagination.

Extends the timeline with two-stage retrieval, an online feature store and graceful degradation under deadline pressure.

Real-time chat combining presence (from Phase 5), per-channel fan-out and cell-based architecture — a top-5 interview problem placed the moment its prereqs are ready.

The messaging capstone — per-conversation FIFO, hybrid fan-out and multi-region active-active; needs fan-out on read, which twitter/instagram just taught.

The heart of the course — with replication/WAL/failover in hand, derive consensus: leader election, replicated state machine and linearizability.

Build a correct lock on quorum + leases + fencing tokens and see exactly why clock skew breaks the naive version.

Apply Raft to the smallest useful goal — one active worker — confronting split-brain, lease renewal and fencing grounded in the lock and Raft you just built.

Package Raft + locks + leases into a ZooKeeper/etcd — watches, ephemeral nodes and sessions that later systems depend on.

The conflict-free path to convergence — join-semilattice merge and vector clocks — placed right before the collaborative products that consume CRDTs. (Justified exception: this is the canonical introduction of the vector clocks it nominally needs.)

Build the call layer every service rides — partial failure, deadline/cancellation propagation, streaming and retry budgets that prevent retry storms.

Wrap every RPC call — sidecars, control/data plane, circuit breakers, mTLS and traffic splitting for fleet-wide resilience and identity.

Distributed cron at scale — fencing + leader election + idempotency + batch reconciliation to fire millions of jobs exactly once, applying the whole coordination toolkit.

Solve the dual-write problem at the source — CDC + outbox + schema registry stream DB changes reliably; the backbone of every saga ahead.

First multi-step transaction — reservation/escrow, distributed locks, sagas and 2PC on contended inventory.

Money-grade correctness — double-entry ledger, idempotent sagas, 2PC and batch reconciliation where mistakes cost real dollars.

Generalize sagas into durable execution — deterministic replay, event sourcing, durable timers and workflow versioning (also teaches the event sourcing stock-exchange needs next).

Determinism under contention — single-writer matching, deterministic replay and event sourcing with Raft-backed failover at microsecond scale.

Assemble Raft + MVCC + 2PC into distributed SQL — ranges, leaseholders, serializable (SSI) isolation and hybrid logical clocks.

Strong consistency with physics — TrueTime / bounded clock uncertainty for external consistency over 2PC + Raft.

The messaging/log capstone — a replicated partitioned log with consumer offsets, leader election and exactly-once, unifying the whole async track (needs leader election, now taught).

Formalize the speed layer met in view-count — watermarks, windowing, keyed state and barrier-snapshot checkpointing.

Exactly-once analytics — event-time watermarks and lambda reconciliation for billing-grade click counts over the Kafka log.

Approximate top-k over a stream — count-min sketch, windowing, hysteresis and an abuse gate.

Capstone counter combining HLL, stream processing, sampling and load-shedding to count millions of concurrent viewers.

Rotate storage 90 degrees — columnar layout, compression and vectorized execution for analytical scans (needs HLL from view-count).

A Prometheus-style product ties your TSDB to push-vs-pull scraping and downsampling end-to-end.

An ELK/Loki pipeline — backpressure, cardinality, tiered storage and sampling over the inverted index + object store.

Trace requests across services — context propagation and head-vs-tail sampling on a columnar store, closing the observability loop.

Distribute the inverted index — sharded segments, scatter-gather and distributed top-k for full-text search.

Prefix search product on the inverted index + a trie/FST with prefix sharding.

Per-user history with TTL, privacy/retention and cold-start handling.

Spell correction over the index — edit distance and n-gram indexing on top of the ranking Elasticsearch/autocomplete just taught.

Approximate nearest-neighbor search — HNSW, IVF and product quantization on a sharded index.

A massive distributed graph traversal with bloom-filter dedup, politeness rate-limiting and frontier sharding — it produces the corpus the index consumes and seeds graph traversal for the capstones.

Two-stage candidate-gen + ranking using embeddings + ANN (from build-vectordb) and a lambda feature pipeline.

File-sync capstone on the S3 you built — content-addressable chunking, erasure coding and cursor-based delta sync (authored anchor for the phase).

Media capstone — hot/cold tiering, adaptive bitrate, signed URLs and CDN at massive read scale.

Index-free adjacency and graph partitioning — placed here so its distributed-transactions and pessimistic-locking needs (from Phase 8) and graph traversal (from web-crawler) are actually satisfied.

Geo warm-up for the spatial cluster — geohashing/quadtree over the inverted index.

Geospatial matching capstone — spatial index, gossip dispatch, escrow matching and real-time dispatch in one design.

Routing capstone — contraction hierarchies over a road graph (graph traversal from web-crawler) plus map tiles and ETA.

Real-time collaboration capstone — OT vs CRDT (from build-crdt), causal ordering and single-writer serialization with lease ownership.

The final capstone — durable execution + sandboxing + capability scoping + cost governance stitched over the entire stack.