The honest 80/20. This repo is a full course — 16 parts, ~450k words — built for genuine understanding and lifelong reference. But you do not need to read all of it to crack an interview. This page is the fast path: the minimum set of chapters that actually get tested, in the order to do them, with a time-boxed plan. Follow only this to prepare efficiently; use the rest of the repo to go deeper later.
🚨 The core truth: interviews reward fluency on a small set — the framework, ~15 building blocks, ~10 case studies, estimation, and trade-off talk, done smoothly out loud — not exhaustive knowledge. A candidate who fluently designs Twitter beats one who has read every chapter but freezes. Practice the essentials until automatic; skim or skip the rest.
| They heavily test | They rarely test (skip/skim for interviews) |
|---|---|
| The design framework (clarify → estimate → design → deep-dive → trade-offs) | Consensus internals (Paxos/Raft proofs) |
| Estimation (QPS, storage, bandwidth) | CDC, data warehouses/lakes, zero-downtime migration details |
| Core building blocks (cache, DB, queue, LB, shard, CDN…) | Service mesh, BFF, multi-region specifics |
| ~10 flagship case studies and their patterns | Most niche case studies (stock exchange, CI/CD, feature flags) |
| Trade-off reasoning, out loud | Deep security/observability theory |
| Estimation + “why this, not that” | Exhaustive protocol details (TLS handshake steps) |
🚨 The right-column topics are valuable to understand and great differentiators — but they’re reference, not cram material. Don’t let them slow your interview prep.
Do these, roughly in order. Everything here already exists in the repo — this is a curated path through it, not new content.
🚨 If you do nothing else, internalize the framework. It’s what stops you freezing and hits every grading dimension.
You’ll reach for these in almost every design:
That’s it. ~30 focused chapters, not 207.
🚨 Don’t do all 36. These 10–12 cover essentially every reusable pattern; the rest are variations you’ll be able to derive once you know these. Do each cold first (45-min timer, out loud), then read.
| # | Case study | The pattern it teaches |
|---|---|---|
| 1 | URL Shortener ⭐ | The template; read-heavy; cache; ID generation |
| 2 | Rate Limiter | Algorithms; atomic distributed counting |
| 3 | Twitter ⭐ | Fan-out write vs read; the celebrity hybrid |
| 4 | Chat / WhatsApp ⭐ | WebSockets; delivery guarantees; offline sync |
| 5 | Media pipeline; CDN; object storage | |
| 6 | Ride-Hailing / Uber ⭐ | Geospatial indexing; matching |
| 7 | Typeahead | Trie; precompute; batch+stream |
| 8 | News Feed | Candidate generation → ranking |
| 9 | Key-Value Store ⭐ | Distributed-systems synthesis (hashing, quorums, conflicts) |
| 10 | E-Commerce | Scoping; inventory; strong-vs-eventual consistency |
| 11 | Payment System ⭐ | Correctness; idempotency; ledger (do if targeting fintech) |
| 12 | Web Crawler | Queues; Bloom filters; producer/consumer |
🚨 Then use the 12 recurring patterns to see how every other design is a remix of these. That’s how you handle a question you didn’t study.
Reading the above makes you understand; only practice makes you pass. Non-negotiable:
🚨 Attempt every case study cold before reading it. The gap between your attempt and the write-up is your study list. Passive reading builds almost nothing.
| Day | Do | | — | — | | 1 | Framework + requirements + estimation; estimation drills | | 2 | Building blocks §2 (cache, DB, sharding, queue, CDN, consistent hashing) — skim, note when to use each | | 3 | Case studies 1–3 (URL shortener, rate limiter, Twitter) — cold attempt, then read | | 4 | Case studies 4–6 (chat, Instagram, ride-hailing) — cold attempt, then read | | 5 | Case studies 7–9 (typeahead, feed, KV store); trade-off drills | | 6 | Two full mocks (out loud, timed); self-grade; add LLD if Amazon/local | | 7 | Cheat sheets; redo your weakest mock; rest |
For anything longer, use the full ROADMAP.
🚨 The essential set shifts a little by company — see Company Guides:
Genuinely valuable, but not cram material — come back after you have an offer:
🚨 “Skip for now” ≠ “not important.” These make you a genuinely better engineer and stronger in senior rounds. But if the interview is soon, focus wins.
Master the framework, memorize the estimation anchors, learn ~15 building blocks well enough to say when and why you’d use each, do ~10 case studies cold-then-read until you can derive the rest from the recurring patterns, and practice out loud until it’s automatic — grading yourself honestly. Add LLD for Amazon/local and behavioral/STAR everywhere. That’s ~30 chapters and a couple of weeks of focused work, not the whole repo. The rest is for becoming a great engineer, which you’ll want after you get the job.
Start here: The Framework → then How to Practice.