System Design Curriculum

Foundations: clients, servers, persistence, scaling out, caching.

• SHT 01 / 15

  01
  Hello, ServerNEW · 📖

  Connect a single client to a single server so requests can be received. Your first system: a request, a response, and the wire between them.
  📖
• SHT 02 / 15

  02
  Persistence LayerNEW · 📖

  Servers are stateless. Add a database behind your server so writes survive a restart. The client should still only talk to the server.
  📖
• SHT 03 / 15

  03
  Scale OutNEW · 📖

  One server can't keep up. Place a load balancer in front of two servers so traffic is spread across them. The database is shared.
  📖
• SHT 04 / 15

  04
  Cache the Hot PathNEW · 📖

  Database reads are expensive. Put a cache between your servers and the database. Tune the hit rate on the cache edge.
  📖

Handle bursts, decouple producers from consumers, partition by key.

Complete any level in Basics to unlock.

• SHT 05 / 15

  05
  Smooth the BurstNEW · 📖

  Traffic isn't uniform — bursts will overload a synchronous service. Spread the work across multiple servers behind a load balancer, and place a queue between them and the database so spikes are absorbed instead of dropped.
  📖
• SHT 06 / 15

  06
  Async WritesNEW · 📖

  Writes don't need a synchronous round-trip to the database — load-balance multiple servers, accept the request, queue the work, and let the database drain at its own pace. Acknowledge fast, persist eventually.
  📖
• SHT 07 / 15

  07
  Shard the DatabaseNEW · 📖

  One database can't keep up. Add a load balancer in front of multiple servers, then a shard router that deterministically partitions writes across multiple databases by key. More shards = more aggregate throughput.
  📖

Combine patterns into real-world topologies. No single right answer.

Complete any level in Scaling to unlock.

• SHT 08 / 15

  08
  Read + Write SplitNEW · 📖

  Real systems mix reads and writes. Load-balance multiple servers, put a cache on the hot read path, and a queue in front of the database to absorb write bursts. Two patterns, one diagram.
  📖
• SHT 09 / 15

  09
  Open EndedNEW · 📖

  Big traffic, full toolbox. There's no single right answer — combine load balancers, caches, queues, and shards however you like. The simulation is the only judge.
  📖

Survive failures: replicas, rate limits, circuit breakers, dead-letter queues.

Complete any level in Composition to unlock.

• SHT 10 / 15

  10
  Replicate & FailoverNEW · 📖

  Mid-run, the database fails for a while. A single DB topology will lose every request during that window. Replicate the database so reads survive the outage.
  📖
• SHT 11 / 15

  11
  Tame the SpikeNEW · 📖

  Bursty traffic overwhelms the downstream server. Insert a rate limiter to throttle arrivals at a sustainable rate; the limiter drops the excess so the server stays healthy.
  📖
• SHT 12 / 15

  12
  Trip the BreakerNEW · 📖

  The database goes flaky for a window. Without a circuit breaker, the server's connection pool fills with hung requests. Insert a breaker so failures fast-fail and the server stays responsive.
  📖
• SHT 13 / 15

  13
  Letters that Wouldn't SendNEW · 📖

  Heavy write load to a slow consumer overflows the queue and you can't tell what was lost. Wire a dead-letter queue from the queue's overflow path to a database for later inspection.
  📖

Move work closer to users: CDNs, regional caching, the speed-of-light tax.

Complete any level in Reliability to unlock.

• SHT 14 / 15

  14
  Cache the WorldNEW · 📖

  Read-heavy traffic is overwhelming a single origin server. Insert a CDN between client and origin so most reads terminate at the edge and never reach your backend.
  📖
• SHT 15 / 15

  15
  Two ContinentsNEW · 📖

  Your client lives in EU-West; your origin is in US-East. Every cross-Atlantic round-trip costs ~80ms. Place an edge CDN in EU-West so most reads terminate locally and your p95 stays inside SLA.
  📖