System Design Crash Course — 3-Week Prep

Exported from the Claude Doc version of this guide. Vol 1 chapter numbers are checked against the book; Vol 2 chapter numbers are from memory, so check them against your copy.

Contents

1. How to use this guide
2. The interview framework
3. Core principles
4. Common design patterns
5. Most frequently asked problems
6. LLD quick reference
7. Day-by-day reading map

1. How to use this guide

Read one section of this guide alongside each HLD day in the tracker (plan Day 1 = Wed 21 Oct), then do the matching Alex Xu chapter for depth. The guide gives you the 80% that interviews test; the book gives the worked walkthroughs.

• Vol 1 = System Design Interview – An Insider’s Guide (Alex Xu, 2020). Every “Vol 1 ch. N” link opens that chapter from your private copy. Vol 2 = the follow-up with Sahn Lam (2022).
• At 5.5 years of experience you are graded as a near-senior: you drive the conversation, state trade-offs before the interviewer asks, and go deep on one or two components.
• For each design, practise out loud with a 45-minute timer, then compare against the book chapter and write down what you missed.
• Skip in the book: anything you already do at work daily. Spend the saved time on deep dives (section 5).

2. The interview framework (Vol 1, ch. 3)

Use the same seven steps in every design round; most candidates fail on time management, not knowledge.

1. Clarify requirements (5 min). Functional: the 3–4 core features only. Non-functional: scale (DAU, QPS), latency, availability vs consistency, durability. Say what is out of scope.
2. Estimate (3–5 min). QPS (average and peak ≈ 2–3× average), storage per year, bandwidth, read:write ratio. Round aggressively; the point is which component becomes the bottleneck.
3. API (3 min). 3–5 endpoints with request and response fields. Mention pagination, idempotency keys and auth.
4. Data model (5 min). Entities, key fields, access patterns, then the store that fits those access patterns (SQL vs NoSQL) and the partition key.
5. High-level design (10 min). Client → CDN → load balancer → stateless services → cache → database, plus queues and workers for async work. Walk one request end to end.
6. Deep dives (10–15 min). Pick the 1–2 hardest parts (hot keys, fan-out, consistency, ordering) or follow the interviewer’s lead. This is where seniority is scored.
7. Wrap up (3 min). Bottlenecks, failure modes, monitoring and alerting, and what you would build next at 10× scale.

What seniors are graded on: naming trade-offs unprompted (“I’ll pick X because Y; the cost is Z”), handling failure cases, keeping the design simple until the numbers force complexity, and steering the 45 minutes yourself.

Numbers worth memorising: 1 day ≈ 86,400 s (use 10^5); 1M requests/day ≈ 12 QPS; memory read ≈ 100 ns; SSD read ≈ 100 µs; same-datacenter round trip ≈ 0.5 ms; cross-continent round trip ≈ 150 ms; one commodity server handles roughly 1–10k simple QPS.

3. Core principles

These thirteen building blocks appear in almost every design; know each one’s main trade-off well enough to state it in one sentence.

Two more you will be asked about: fault tolerance (replicas, health checks, failover, multi-AZ deployment) and observability (metrics, logs, traces, alerts on latency and error rate).

4. Common design patterns

Naming the right pattern, and the problem it solves, is the fastest way to sound senior in a deep dive.

Reliability

Data

Communication

Specialised structures

5. Most frequently asked problems

The 16 designs below cover the large majority of SDE2–SDE3 design rounds; the first 13 are in the plan, and the last 3 are stretch reading if you finish early.

Other Vol 2 chapters worth skimming if a target company is in that domain: proximity service (Yelp), metrics and alerting, ad click aggregation, distributed message queue, S3-like storage, digital wallet and stock exchange.

6. LLD quick reference

In machine-coding rounds you are scored on clean, extensible, working code; eight patterns cover nearly every problem in the plan.

SOLID in one line each: single responsibility (one reason to change); open–closed (extend with new classes, don’t edit old ones); Liskov substitution (subclasses must work anywhere the parent does); interface segregation (small, focused interfaces); dependency inversion (depend on interfaces, inject implementations).

Machine-coding checklist: clarify requirements and list entities first (5 min); define interfaces before classes; keep models, services and storage in separate layers; use in-memory maps for storage; handle concurrency where it matters (seat booking, parking spot allocation) with locks or atomic operations; write a small driver or tests that demo the main flows; leave 10 minutes to walk through extensibility.

7. Day-by-day reading map

This map follows the HLD and LLD rows in the tracker, so each day’s reading matches what you practise.

Final-day checklist

• I can run the 7-step framework from memory with time checkpoints
• I can state the main trade-off for every row in Core principles
• I can do a back-of-envelope estimate in under 5 minutes
• I have drawn all 13 planned designs at least once out loud
• I can explain 2 deep dives for each of those designs
• I have coded 4 LLD problems end to end
• I have 2 work projects ready to discuss at design depth