Back to System Design Index

Free Course15 lessonsLive diagramsMukul

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

Diagram: a whiteboard with API and cache boxes joined by an arrow, beside three formulas for capacity, cost and miss rate.
Figure 1. Draw the box, price the arrow, and state the arithmetic out loud. Illustrative course diagram.

What you will be able to do

How interviewers test this course: clarification first, math aloud second, depth with prices third. Lesson 14 rehearses the loop.

Lesson 01 · Opening · Questions before boxes

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.

users set scale set limits set boxes next
  • 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.
Interview room

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 →

Lesson 02 · Diagramming · Structure before depth

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.

client drawn api drawn store drawn arrows priced
  • 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.
Interview room

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 →

Lesson 03 · Estimation · Math out loud

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.

100 users voiced 62 RPS derived 34 bytes sized peaks priced · modeled, not invoices
  • 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.
Interview room

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 →

Lesson 04 · Storage · The right home per access

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.

reads typed writes typed store picked reasons spoken
  • 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.
Interview room

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 →

Lesson 05 · Caching · Hit rates are hired

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.

hot keys TTL set guard set miss priced
  • 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.
Interview room

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 →

Lesson 06 · Async · Fast path versus slow lane

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.

before sync path async lane after budget split reasons ready
  • 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.
Interview room

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 →

Lesson 07 · Partitioning · Keys carry the load

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.

key picked spread even hot split rebalance ready
  • 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.
Interview room

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 →

Lesson 08 · Tradeoffs · Promises with prices

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.

before per workflow price stated after conflict planned reasons ready
  • 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.
Interview room

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 →

Lesson 09 · Resilience · Kill it on the board

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.

zone killed disk slowed storm budgeted verdict kept
  • 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.
Interview room

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 →

Lesson 10 · Closing · Bills beat adjectives

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.

100 per-M priced 62 dearest named 34 lever offered offer neared · modeled, not invoices
  • 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.
Interview room

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 →

Lesson 11 · API Round · Contracts under pressure

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.

verbs set keys issued limits mathed version planned
  • 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.
Interview room

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 →

Lesson 12 · Deep Dive · One system, fully owned

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.

box picked metal reached bets priced owned aloud
  • 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.
Interview room

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 →

Lesson 13 · Behavioral · Stories with receipts

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.

incident owned conflict solved result measured receipts ready
  • 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.
Interview room

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 →

Lesson 14 · Rehearsal · The loop before the loop

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.

mock booked tape reviewed top fixed loop repeated
  • 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.
Interview room

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 →

Lesson 15 · Capstone · Offer week shipped

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.

drills daily mocks weekly log kept offers compared
  • 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.
Interview room

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 →