Post

Tech Education

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.

A cheat sheet is not preparation

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)StepWhat to say or draw
0 to 5Requirements3 to 5 functional requirements. Non-functional: scale, latency, consistency, availability. Confirm what is out of scope
5 to 10EstimatesRequests per second (peak), storage per year, read to write ratio, bandwidth if media
10 to 15API and data modelMain endpoints. Main entities and the key you look each one up by
15 to 30High level designClient, load balancer, services, data stores, cache, queue. Walk one read and one write through it
30 to 45Deep divesThe 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:

OperationRough latency
Memory read100 ns
SSD random read100 µs
Round trip within a data centre0.5 ms
Read 1 MB sequentially from SSD1 ms
Disk seek (spinning disk)10 ms
Round trip across continents100 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

BlockReach for it whenWatch out for
Load balancerMore than one app server; health checksSticky sessions break statelessness
Cache (Redis, Memcached)Read-heavy data, expensive queriesStale data, invalidation, cold start, hot keys
CDNStatic files and media to users worldwideCache invalidation on updates
Relational DBRelationships, transactions, correctnessWrite scaling needs sharding
Key-value / wide-column DBVery high write volume, simple lookups by keyLimited queries, design the key around access patterns
Document DBFlexible, nested records read as a wholeCross-document transactions
Search index (Elasticsearch)Full text search, filters, facetsIt is a derived copy; keep it in sync
Message queue (Kafka, SQS, RabbitMQ)Slow, retriable or spiky work; decoupling servicesAt-least-once delivery means consumers must be idempotent
Object storage (S3)Files, images, video, backupsNot a database; store metadata elsewhere
WebSockets / SSEServer 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

ChoiceOption AOption BRule of thumb
ConsistencyStrong: everyone sees the latest writeEventual: copies converge laterMoney, inventory, seats: strong. Likes, feeds, views: eventual
Fan-outOn write: push to followers' feedsOn read: build feed when openedPush for most users, pull for accounts with huge followings
StorageSQLNoSQLStart with SQL; move a piece when you can name the problem it solves
ProcessingSynchronousAsynchronous via a queueAnything slow, retriable or spiky goes on a queue
Client updatesPollingPush (WebSockets, SSE)Push when updates are frequent and latency matters
IDsDatabase auto-incrementDistributed IDs (Snowflake-style, UUID)Distributed when you shard or need IDs without coordination
DeliveryAt most onceAt least once + idempotencyAt 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:

ProblemKey point
URL shortenerGenerating short unique IDs; a read-heavy cache
Rate limiterToken bucket or sliding window; shared counters across servers
Twitter / news feedFan-out on write vs read; the celebrity problem
Chat (Messenger)Persistent connections; message ordering and delivery status
TicketmasterSeat holds with expiry; no double-selling; a traffic spike at on-sale
YouTube / NetflixUpload and transcoding pipeline; CDN and adaptive bitrate
DropboxChunking and deduplication; sync and conflicts
Google DocsOperational transforms or CRDTs for concurrent edits
UberGeospatial index for live driver locations; matching
TypeaheadTrie or precomputed prefixes; latency under 100 ms
Web crawlerURL frontier, politeness, deduplication
Digital walletDouble-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.