Whiteboarding a System Design: How to Draw So the Interviewer Can Follow
When you open a whiteboard in a system design interview, the first thing the interviewer does is scan the layout. A clean board tells the interviewer where to look, what you consider important, and how you think about scaling. Below is a step-by-step way to structure the board so the conversation stays on track.
1. Start with the High-Level View
1.1 Place the client side on the left
Begin by drawing the entry points – browsers, mobile apps, or external APIs – on the left margin. Use simple rectangles labeled "Web UI", "iOS", "Android", or "Third-party API". If the problem mentions multiple client types, keep them side by side, but do not crowd the edge. The left-most position mirrors the direction of a request flowing from the user toward the backend.
1.2 Put the data side on the right
On the far right, sketch the persistent stores – relational DB, NoSQL, object storage, cache layers. Align them vertically so you can draw vertical arrows that cut across the board. This spatial separation makes the request path a left-to-right line that the interviewer can follow with their eyes.
2. Add the Core Services in the Middle
2.1 Layered approach
Between the client and data layers, place the services that process the request. Typical layers are:
- Load balancer / DNS – a small cloud icon.
- API gateway – a rectangle labeled "API GW".
- Application servers – a group of boxes labeled "App" or "Service".
- Message queue – a cylinder labeled "SQS" or "Kafka".
- Worker pool – a set of smaller boxes.
Arrange them in the order they are invoked. If the design calls for a microservice architecture, draw each service as a separate box, but keep the overall flow linear.
2.2 Keep symbols simple
Avoid fancy shapes. Stick to rectangles for compute, cylinders for storage, and arrows for flow. The interviewer does not need artistic flair; they need clarity.
3. Trace One Request Path at a Time
3.1 Pick the primary use case
Ask the interviewer which scenario to start with – e.g., "Create a post" or "Read a timeline". Then walk through that path from left to right, highlighting each component as you go.
3.2 Expand the diagram incrementally
Do not draw the entire system before you speak. Start with the client and the first hop (load balancer), then add the next component as you describe it. This incremental build mirrors the way you think and lets the interviewer verify each step before you move on.
3.3 Use numbered arrows
Label each arrow with a step number (1, 2, 3…) and a brief metric. For example:
- 1.
HTTPS request → API GW– latency ~ 50 ms, 5 k QPS. - 2.
API GW → App– internal latency ~ 10 ms, request size 2 KB. - 3.
App → DB– read-write latency ~ 5 ms, row size 1 KB.
These numbers give the interviewer a sense of scale and open a discussion about bottlenecks.
4. Label Capacity and Scaling Assumptions
4.1 Show rough traffic numbers
Convert the problem statement into per-second rates. If the prompt says "1 million users per day", calculate:
1,000,000 users × 1 request each / 86,400 seconds ≈ 12 requests per secondWrite the result near the load balancer: "≈12 RPS average". If the design must handle spikes, note a factor (e.g., "×2 for peak traffic").
4.2 Indicate replication and sharding
When you add a database, annotate it with replication factor and shard count if you plan to scale horizontally. Example: "MySQL (3 replicas, 4 shards)". This signals that you have thought about data distribution.
4.3 Mention latency budgets
State the overall latency goal (e.g., "<200 ms end-to-end"). Then break it down: "API GW 50 ms, app 30 ms, DB 5 ms, network 20 ms". The interviewer can then ask you to adjust components if the budget is tight.
5. Common Drawing Mistakes and How to Avoid Them
| Mistake | Why It Hurts | Fix |
|---|---|---|
| Crowding the board – too many boxes in one area | The eye can’t follow the flow; details get lost | Keep a clear margin on each side. Use vertical spacing to separate layers. |
| Missing arrows – unclear direction of data | Interviewer may guess your intention, leading to confusion | Every interaction needs an arrow. Even internal calls should be shown. |
| No numbers – purely qualitative diagram | Leaves you without a way to discuss scaling or bottlenecks | Add rough QPS, latency, and size next to each arrow. |
| Over-labeling – writing full sentences inside boxes | Clutters the visual; the board becomes a paragraph | Keep box labels short (one-word or two). Use side notes for explanations. |
| Drawing everything at once – full architecture before talking | Gives the impression you’re reciting a memorized diagram | Build the diagram as you speak. Pause after each step for questions. |
6. Using the Board to Guide the Conversation
6.1 Anchor the discussion on the diagram
When the interviewer asks about a trade-off, point to the relevant arrow or component. For example, "If we increase write traffic to 10 k RPS, the DB write latency will dominate, so we might need to shard further."
6.2 Transition to alternatives smoothly
If you need to propose a different approach, draw a new arrow in a contrasting color (or a dashed line) and label it "Alternative". This visual cue signals a shift without erasing the original design.
6.3 Summarize with a final overview
After you have walked through all major paths, step back and trace the full flow from left to right, reciting the key numbers. This reinforces that the board tells a coherent story.
7. How to Practice This
- Pick a common interview question – e.g., design a URL shortener or a chat service. Write the brief on a piece of paper.
- Use a digital canvas such as the one offered by System Design AI to draw the board step by step. The tool lets you add arrows, labels, and metrics, then review a coach’s feedback.
- Record yourself explaining the diagram. Play it back and check if the flow is clear, the numbers are present, and no step is skipped. Iterate until the board can be followed without extra narration.
Questions people ask
What’s the best way to show scaling on a whiteboard?
Add replication factors and shard counts next to storage boxes, and write traffic numbers (requests per second) at the load balancer. Those numbers give the interviewer an instant sense of the scale you’re targeting.
Should I write full sentences inside boxes?
No. Keep box labels to one or two words. Use side notes or numbered arrows for explanations, latency budgets, and size metrics.
How many request paths should I draw?
Begin with the primary use case and walk through it step by step. If you have extra time, add a secondary path (read vs write) to demonstrate breadth, but avoid drawing every possible interaction.
What if I run out of space on the board?
Collapse less-critical components into a single box labeled with an ellipsis (e.g., "Other services…") and mention their role verbally. Focus the visual space on the components that drive the main conversation.