System Design Interview Bootcamp: 15 Rounds From the Whiteboard
A strong system-design answer makes its reasoning visible: clarify first, draw second, size the workload, test failure, and defend the cost. Each round uses published postmortems or clearly labeled scenarios with arithmetic readers can rerun.
TL;DR: Fifteen practice rounds with diagrams, from clarification and RPS math to failure drills and cost estimates. Published incident findings and modeled inputs are identified separately.
By Mukul Kumar Mishra · Interview course · Updated October 23, 2026
What you will be able to do
- Clarify the prompt, diagram the happy path, and estimate RPS, storage and bandwidth aloud.
- Choose storage, caching and queues with reasons; shard hot keys, state consistency trade-offs and test failure cases.
- Close with a per-million cost model, explain one subsystem in depth and support behavioral examples with verifiable details.
- Practice mock interviews, record the results and follow a two-week preparation schedule.
- Present the design, its estimates and the trade-offs in a clear order.
How interviewers test this course: clarification first, math aloud second, depth with prices third. Lesson 14 rehearses the loop.
Clarify First
A common design risk is solving the wrong problem. Clarify users, scale and constraints before drawing. Ask about the read-write ratio, latency objective, consistency needs and budget. Write down assumptions as you go.
- Repeat the prompt back with numbers attached. Misheard scale wastes thirty minutes.
- Name the non-goals aloud. Scope cuts earn more points than extra boxes.
- Deep dive: NATS Flight-Data Incident, the distinction between restriction time and passenger recovery.
Q1. Design a URL shortener for 100M links a month. What do you ask first?
Q2. The latency target is under 200ms p99. What constraint follows?
Scope set. Now draw. Lesson 02: Boxes →
Boxes Before Arrows
Draw the happy path end to end in four boxes before a deep dive. A client, API, service and store make a useful starting point. Label each arrow with its protocol and payload size so the diagram records the main assumptions.
- Timebox the overview to ten minutes. Detail belongs in rounds, not the opener.
- State uncertain parts aloud and mark them. Hidden guesses are hard to review.
- Deep dive: Figma Multiplayer, fan-out drawn before depth.
Q1. Sketch TinyURL end to end in under ten minutes. What are the four boxes?
Q2. Where do you mark uncertainty on the board?
Map drawn. Now speak numbers. Lesson 03: Math →
Numbers Out Loud
Interview math is narration as well as arithmetic. State users, actions per user and peak factor, then derive RPS, storage and bandwidth in round numbers. Correct powers of ten matter more than false precision. Explain each step.
- Round aggressively: 86,400 seconds becomes 100K. Speed signals fluency.
- Estimate storage for five years and bandwidth per second. Both fit on the same board.
- Deep dive: Discord Messages Scale, trillions priced per row.
Q1. Price storage for 10K photos a day at 2MB each over five years.
Q2. Peak factor hits 5x average. What breaks first in your sketch?
Math spoken. Now pick storage. Lesson 04: Storage →
Storage Choices
Match the store to the access pattern, not fashion. Relational stores suit transactions and joins; wide-column and key-value stores suit large-scale, simple reads. Object storage suits blobs, often with a CDN in front. Give a reason for each choice.
- Separate hot reads from cold archives. Tiers decide cost more than engines.
- Name the index per hot query. Unindexed hot paths fail the deep dive.
- Deep dive: Supabase Postgres Scale, 44M+ databases managed behind one promise.
Q1. Chat history for 50M users. SQL or wide-column? Defend the choice.
Q2. When does object storage with a CDN beat a database?
Store picked. Now cache it. Lesson 05: Cache →
Cache Math
Caches turn repeated reads into memory hits. State the expected hit rate, TTL, eviction policy and stampede guard. A cache without an invalidation plan is a bug with a hit ratio. Price the miss path first.
- Size cache from hot working set, not total data. Ten percent of keys serve ninety percent of reads.
- Add request coalescing for thundering reads. One fill serves the crowd.
- Deep dive: ShareChat Assignment, 95 percent hits by fat rows.
Q1. Celebrity posts spike reads 100x. What guards the cache?
Q2. TTL expires during peak. What prevents the stampede?
Hits priced. Now split sync from async. Lesson 06: Queues →
Queue Versus Sync
Synchronous calls suit reads that need an immediate answer. Queues can absorb bursts and retries. Draw the synchronous path for latency and the asynchronous lane for durability. Use latency budgets to explain the split.
- Queue depth equals burst rate times drain time. Little Law answers sizing live.
- Name dead-letter handling and replay. Queues without a replay path can leave data unprocessed.
- Deep dive: a modeled Kafka rebalance cascade, with 40,000 partitions and an assumed pause duration.
Q1. Payments need receipts now and settlement later. Which leg is synchronous, and which uses a queue?
Q2. Queue depth triples at noon. What drains it safely?
Lanes split. Now shard the heat. Lesson 07: Sharding →
Sharding Keys
Sharding distributes rows and queries across nodes by key. Hash keys can balance load; range keys preserve order but may create hot spots. Hot keys may need splitting or caching. Analyze the access pattern before choosing a key.
- Estimate rows per shard at five-year scale. Past ten million per shard, split sooner.
- Plan resharding before launch. Static shard counts expire with growth.
- Deep dive: Stripe's Idempotency and Modeled Scale Teardown, with documented key-retention behavior.
Q1. User handles cluster by geography. Hash or range? Defend the choice.
Q2. One celebrity owns 5 percent of rows. What saves the shard?
Heat spread. Now trade consistency. Lesson 08: Consistency →
Consistency Tradeoffs
Strong consistency can simplify reasoning but may cost latency or availability during a partition. Eventual consistency shifts work to conflict handling. State the choice for each workflow and explain why.
- Count cross-region round trips per write. Each adds latency and another failure mode.
- Design idempotency for retried writes. At-least-once without keys double-charges.
- Deep dive: Doltgres Data Loss, where missing metadata led to data deletion.
Q1. Compare a likes counter with a wallet balance. What consistency does each need?
Q2. Two regions diverge during a partition. What reconciles them?
Trades priced. Now break it live. Lesson 09: Failure →
Failure Drills
Test the design against failures such as a lost zone, slow storage, retry amplification and a faulty deployment. For each case, explain the health check, failover path and capacity budget.
- Budget retries from measured arrival rates, configured attempt limits, and fan-out across dependent services; explain the arithmetic aloud.
- Pin control away from sick zones. Shared brains spread single-zone pain.
- Deep dive: GCP us-central1, incompatible transceivers isolated capacity in parts of two zones.
Q1. Your primary zone goes dark mid-demo. What serves traffic?
Q2. A deploy poisons 10 percent of hosts. What rolls it back?
Deaths survived. Now close with cost. Lesson 10: Cost →
Cost Close
End with a cost sketch. Estimate steady-state cost per million requests, identify the largest component and describe one plausible optimization. State the assumptions behind the estimate.
- Attribute cost per request per tier. Unattributed totals sound invented.
- Offer the tradeoff explicitly: cheaper with slower tail, or faster with fatter invoice.
- Deep dive: LLM Inference Cost, per-task math that closes.
Q1. Price your URL shortener per million links. What dominates?
Q2. Cut the design bill 40 percent. What goes first?
Closed with bills. Now the API round. Lesson 11: API →
API Round
A useful API design covers resource contracts, idempotency, limits and versioning. Start with resources and verbs, then explain idempotency keys, rate limits and webhook retries. Include an error model.
- Size rate limits from capacity: RPS per client times clients and headroom.
- Replay webhooks inside windows with signatures. Unsigned retries invite forgery.
- Deep dive: API Design Course, fifteen gateway lessons.
Q1. Design checkout APIs that survive double-clicks. What prevents a double charge?
Q2. Version 2 breaks mobile clients. What ships instead?
Contracts signed. Now go deep. Lesson 12: Deep Dive →
Deep Dive Round
Choose one subsystem and explain its schema, indexes, queries, failure modes and cost. Show the assumptions behind the choices and how you would test them.
- Write two queries with execution plans and index shapes.
- Close with the subsystem's cost and failure-recovery plan.
- Deep dive: Razorpay Kafka, 3,000 connections too many.
Q1. Design the feed-ranking store end to end, including schema, indexes and cost.
Q2. Your chosen component doubles traffic overnight. What breaks first?
Depth owned. Now prove character. Lesson 13: Behavioral →
Behavioral With Receipts
Prepare three examples with verifiable details: an incident response, a conflict you resolved and a deadline you renegotiated. Structure each around the situation, your actions and the measured result.
- Quantify everything: minutes saved, errors cut, revenue protected. Estimates labeled honestly.
- Name what you would redo. Growth without regret reads rehearsed.
- Deep dive: MoEngage Millisecond, owned hardware, owned numbers.
Q1. Describe an outage you owned. What was the timeline, who was involved, and what changed?
Q2. Describe a disagreement with your manager about architecture. What happened?
Character proven. Now rehearse fully. Lesson 14: Mocks →
Mock Loop
Run two full mock interviews before an onsite: one supportive and one challenging. Record yourself, note filler words, long pauses and unpriced estimates, then work on the three largest issues.
- Review each round for clarification, workload math, technical depth and a clear conclusion. Spend practice time on the weakest area.
- Rehearse the cost close until it fits ninety seconds. Closers get remembered.
- Deep dive: System Design Course, fifteen lessons of material.
Q1. Your practice interviews stall at estimation. What exercise will help?
Q2. The interviewer challenges each component. How do you keep the design moving?
Rehearsed. Now ship the week. Lesson 15: Offer →
Offer Week
Capstone: build a two-week preparation plan. Use the first week for estimation and focused technical study; use the second for mock interviews and applications to suitable roles. Track practice results and follow-up decisions.
- Course practice target: complete three mocks, explain a cost estimate in under ninety seconds and maintain a decision log.
- Compare offers on growth, scope and compensation. A title alone does not describe the work.
- Deep dive: Postgres Course, depth material for dive rounds.
Q1. Plan a two-week interview preparation schedule.
Q2. Two offers differ in scope and pay. What factors decide?
Bootcamp complete. Start the companion. System Design Course →

