System Design Interview Cheat Sheet
This is a fast, practical reference for a 45-minute system design interview — the framework, the numbers worth memorizing, the building blocks and when to reach for each, and a per-phase checklist. Skim it before an interview; study the linked deep-dives when you have time.
The 45-minute framework
| Phase | Time | What to do |
|---|---|---|
| Clarify & scope | ~5 min | Ask about users, features, read/write ratio, consistency needs. State what's out of scope. |
| Estimate | ~5 min | Back-of-the-envelope: DAU, requests/sec, storage/year. Let the numbers drive the design. |
| High-level design | ~10 min | Draw the main components and request flow. Keep it clean; mark sync vs async. |
| Deep-dive | ~20 min | Pick 1–2 areas and go deep — data model, hot path, scaling, failure modes. |
| Wrap | ~5 min | Summarize, name bottlenecks, say what you'd revisit. |
The full method (with the reasoning behind each phase) is in our complete prep guide.
Numbers worth memorizing
Latency (order of magnitude):
| Operation | Time |
|---|---|
| Memory reference | ~100 ns |
| Read 1 MB from memory | ~10 μs |
| SSD random read | ~100 μs |
| Round trip within a datacenter | ~500 μs |
| Read 1 MB from SSD | ~1 ms |
| Disk (HDD) seek | ~10 ms |
| Round trip across regions (e.g. US↔EU) | ~100–150 ms |
Takeaway: memory is ~100,000× faster than a cross-region round trip. This is why we cache and keep hot data close.
Powers of 2 (for storage math): 2¹⁰ ≈ 1 thousand (KB), 2²⁰ ≈ 1 million (MB), 2³⁰ ≈ 1 billion (GB), 2⁴⁰ ≈ 1 trillion (TB).
Handy conversions: ~86,400 seconds/day ≈ 100K for quick math; 1 million requests/day ≈ 12 requests/second.
Building blocks: what to use when
| Building block | Reach for it when… |
|---|---|
| Cache (Redis/Memcached) | Reads dominate; you can tolerate slight staleness. See caching strategies. |
| CDN | Serving static or cacheable content to a global audience. |
| Load balancer | Spreading traffic across many stateless servers. |
| SQL database | Relations, joins, multi-record transactions, strong consistency. See SQL vs NoSQL. |
| NoSQL (key-value/wide-column/doc) | Massive scale, a simple/known access pattern, flexible schema. |
| Message queue (Kafka/SQS) | Decoupling producers from consumers; smoothing spikes; async work. |
| Blob/object storage (S3/R2) | Large files — images, video, backups. |
| Consistent hashing | Partitioning across a changing set of nodes. See consistent hashing. |
| Rate limiter | Protecting a service from abuse or overload. See rate limiter. |
Per-phase checklist
Clarify: Who are the users? Which features are in scope? Read-heavy or write-heavy? Strong or eventual consistency? What's the scale? What's explicitly out of scope?
Estimate: Daily active users → requests/second (peak = several× average). Storage per item × items/day × retention. Bandwidth. Does it fit on one machine, or must it shard?
High-level design: Client → load balancer → services → data stores. Where's the cache? What's async (queues)? Draw it clearly and label everything.
Deep-dive: Data model and partitioning key. The hot path (optimize it). Replication and consistency. Failure modes ("what happens when X dies?"). Bottlenecks and how you'd scale past them.
Wrap: Restate the design, call out the biggest bottleneck, and name one thing you'd do with more time.
Green flags vs. red flags
Green flags (do these):
- Clarify requirements before drawing.
- Justify every choice against the requirements ("X because Y, at the cost of Z").
- Go genuinely deep on one area.
- Address failure and scale proactively.
- Keep the whiteboard legible.
Red flags (avoid these):
- Jumping straight to a solution.
- Name-dropping technologies without reasons.
- Staying shallow across everything.
- Ignoring what happens under load or failure.
- A messy, unreadable diagram.
The one-line version
Clarify → estimate → high-level design → deep-dive on what matters → talk trade-offs throughout. Everything else is detail.
The fastest way to make this automatic is to run the framework out loud under questioning. On Whitepad, a senior AI interviewer runs the phased script by voice, watches your whiteboard, and scores you like the real thing — your first mock is free.
Practice this out loud
Reading is the easy part. Sit across from a senior AI interviewer that talks, watches your whiteboard, and scores you like the real thing — your first mock is free.
Start a free mock →