Post
System Design Interview Cheat Sheet
A one-page system design interview cheat sheet: the answer structure with timings, back-of-the-envelope numbers, the building blocks and when to use each, the common trade-offs, and the key point for each classic problem.
By Codemia • November 14, 2026
7 min read
This is the page to read the night before a system design interview. It assumes you already know the material and need it in one place: the structure of an answer, the numbers worth remembering, when to reach for each building block, and the trade-offs interviewers listen for.
Everything here is easy to read and hard to do under a timer while someone asks why. If your interview is more than a few days away, spend the time designing problems yourself. The 4-week plan on the Codemia blog shows how.
The answer structure
| Time (45 min round) | Step | What to say or draw |
| 0 to 5 | Requirements | 3 to 5 functional requirements. Non-functional: scale, latency, consistency, availability. Confirm what is out of scope |
| 5 to 10 | Estimates | Requests per second (peak), storage per year, read to write ratio, bandwidth if media |
| 10 to 15 | API and data model | Main endpoints. Main entities and the key you look each one up by |
| 15 to 30 | High level design | Client, load balancer, services, data stores, cache, queue. Walk one read and one write through it |
| 30 to 45 | Deep dives | The bottleneck, the hardest correctness problem, a failure case. Name trade-offs |
Phrases that help:
- "Before I design anything, can I check the scope?"
- "That gives us roughly X writes per second, so a single database will (or will not) be enough."
- "I will start simple and then fix the bottleneck."
- "The trade-off here is... I would pick... because..."
- "Which of these would you like me to go deeper on?"
Numbers to remember
Time:
- 1 day is about 86,400 seconds, so roughly 100,000 seconds.
- 1 million requests per day is about 12 per second. 100 million per day is about 1,200 per second.
- Peak traffic is commonly 2 to 10 times the average.
Latency, order of magnitude:
| Operation | Rough latency |
| Memory read | 100 ns |
| SSD random read | 100 µs |
| Round trip within a data centre | 0.5 ms |
| Read 1 MB sequentially from SSD | 1 ms |
| Disk seek (spinning disk) | 10 ms |
| Round trip across continents | 100 to 150 ms |
Sizes:
- A character is 1 to 4 bytes; a short text record (a tweet with metadata) is about 1 KB.
- A photo is roughly 100 KB to a few MB; a minute of compressed HD video is tens of MB.
- 1 million records of 1 KB = 1 GB. 1 billion = 1 TB.
Rough capacity of one machine (varies a lot with workload):
- A web or app server: thousands of simple requests per second.
- A relational database: a few thousand to tens of thousands of simple queries per second.
- A Redis instance: around 100,000 simple operations per second.
- A Kafka partition: many MB per second of throughput; a cluster scales by adding partitions.
Building blocks: when to reach for each
| Block | Reach for it when | Watch out for |
| Load balancer | More than one app server; health checks | Sticky sessions break statelessness |
| Cache (Redis, Memcached) | Read-heavy data, expensive queries | Stale data, invalidation, cold start, hot keys |
| CDN | Static files and media to users worldwide | Cache invalidation on updates |
| Relational DB | Relationships, transactions, correctness | Write scaling needs sharding |
| Key-value / wide-column DB | Very high write volume, simple lookups by key | Limited queries, design the key around access patterns |
| Document DB | Flexible, nested records read as a whole | Cross-document transactions |
| Search index (Elasticsearch) | Full text search, filters, facets | It is a derived copy; keep it in sync |
| Message queue (Kafka, SQS, RabbitMQ) | Slow, retriable or spiky work; decoupling services | At-least-once delivery means consumers must be idempotent |
| Object storage (S3) | Files, images, video, backups | Not a database; store metadata elsewhere |
| WebSockets / SSE | Server needs to push to clients (chat, live updates) | Connection state, reconnects, fan-out across servers |
Scaling patterns
- Stateless app servers + load balancer: scale the compute tier horizontally.
- Read replicas: scale reads; accept replication lag.
- Sharding: scale writes and storage; choose a shard key that spreads load and matches the main query.
- Consistent hashing: move only a fraction of keys when nodes join or leave.
- Cache-aside: read cache, on miss read DB and fill cache with a TTL.
- Async processing: accept the request, put a job on a queue, return; workers do the rest.
- Denormalise for reads: precompute what the hot read path needs (feeds, counters, timelines).
- Batch and aggregate: buffer high-volume writes (view counts, clicks) and flush periodically.
Trade-offs interviewers listen for
| Choice | Option A | Option B | Rule of thumb |
| Consistency | Strong: everyone sees the latest write | Eventual: copies converge later | Money, inventory, seats: strong. Likes, feeds, views: eventual |
| Fan-out | On write: push to followers' feeds | On read: build feed when opened | Push for most users, pull for accounts with huge followings |
| Storage | SQL | NoSQL | Start with SQL; move a piece when you can name the problem it solves |
| Processing | Synchronous | Asynchronous via a queue | Anything slow, retriable or spiky goes on a queue |
| Client updates | Polling | Push (WebSockets, SSE) | Push when updates are frequent and latency matters |
| IDs | Database auto-increment | Distributed IDs (Snowflake-style, UUID) | Distributed when you shard or need IDs without coordination |
| Delivery | At most once | At least once + idempotency | At least once, and make consumers idempotent |
Reliability checklist
Before you finish, look at your diagram and ask:
- What happens when each box dies? Is there a replica, a retry, a failover?
- Is any write lost if a server crashes mid-request? Use durable queues and write-ahead logs.
- Can a retry cause a duplicate? Use idempotency keys.
- What happens at ten times the traffic? Which component falls over first?
- How would you know it is broken? Metrics, logs and alerts.
The key point for each classic problem
Every classic problem has one or two things the interviewer is waiting to hear:
| Problem | Key point |
| URL shortener | Generating short unique IDs; a read-heavy cache |
| Rate limiter | Token bucket or sliding window; shared counters across servers |
| Twitter / news feed | Fan-out on write vs read; the celebrity problem |
| Chat (Messenger) | Persistent connections; message ordering and delivery status |
| Ticketmaster | Seat holds with expiry; no double-selling; a traffic spike at on-sale |
| YouTube / Netflix | Upload and transcoding pipeline; CDN and adaptive bitrate |
| Dropbox | Chunking and deduplication; sync and conflicts |
| Google Docs | Operational transforms or CRDTs for concurrent edits |
| Uber | Geospatial index for live driver locations; matching |
| Typeahead | Trie or precomputed prefixes; latency under 100 ms |
| Web crawler | URL frontier, politeness, deduplication |
| Digital wallet | Double-entry ledger; idempotent transfers |
For outlines of ten of these, see how to answer 10 classic system design questions.
Common mistakes
- Drawing boxes in the first minute, before scope is clear.
- Estimates that never change a decision.
- A single database with no plan for when it fills up.
- Adding a cache without saying how it stays fresh.
- Not naming a single trade-off.
- Going silent while thinking. Narrate.
Before the interview
If you have time left, design two or three problems under a timer rather than rereading this page. The Codemia system design catalogue grades each design against that problem's key points, and the AI interviewer lets you rehearse out loud. New to the topic? Start with system design explained: a beginner's guide.