// The Design Playbook

A playbook for any “design X” question

System Design track · 20 min

By the end of this lesson you can
  • Run the four steps (clarify, estimate, sketch, deep dive) on any design question.
  • Find the one component where the real difficulty of a system lives.
  • Defend each choice as a trade-off: what you gain and what you give up.

'Design Twitter.' Your stomach drops. Not because the question is hard, but because it has no shape. Where do you even start?

This lesson gives the shapeless question a shape: four steps, always the same, that turn panic into a plan.

The problem

Most people react to a vague question by grabbing the marker and drawing boxes at once. Ten minutes later they have built a system for a product nobody asked for, at a scale nobody mentioned.

Picture a doctor who writes a prescription before asking a single question. Even if the medicine is good, you would not trust them.

The four steps
  1. Clarify the requirements. Ask who uses it, what they do and how many there are. Cut the scope hard: 'Twitter' means two or three features, not forty. Finish with two lists: functional requirements (what the system does) and non-functional ones (how fast, how big, how reliable).
  2. Estimate. Do the quick maths from the estimation lesson: requests per second, storage, bandwidth. These numbers decide everything after them: is one database enough or do you need shards, is a cache a nice extra or a must.
  3. Sketch the high-level design. Draw the boxes and arrows: client, load balancer, web servers, database, cache, queue. Say each box's job out loud as you draw it, and check the other person agrees. This is the shared map for the rest of the talk.
  4. Deep dive. Pick the one or two parts where the real difficulty lives and go deep: the data model, the algorithm, what happens when things fail. Defend every choice as a trade-off: what you gained, and what you gave up knowingly.
1Clarify requirementswhat, for whom, at what scale?2EstimateQPS, storage, bandwidth3High-level sketchboxes and arrows: client, API, DB4Deep divezoom into 1–2 parts, defend them
Read it left to right: clarify, estimate, sketch, deep dive. The same four steps fit any design question.
The four steps on a food delivery app

Step 1, clarify. Users order food from restaurants and track the courier on a map. Keep three features: browse restaurants, place an order, live tracking. Non-functional: the courier's position on the map should be at most a few seconds old.

Step 2, estimate. Say 200,000 orders a day. 200,000 ÷ 86,400 ≈ 2.3 orders per second on average. Even if the dinner rush is ten times busier, that is about 25 per second: easy. Now tracking: 20,000 couriers on the road at peak, each sending its location every 5 seconds. 20,000 ÷ 5 = 4,000 location updates per second. That is the real load.

Step 3, sketch. App, load balancer, web servers, a database for orders, a fast store for live positions.

Step 4, deep dive. The numbers already told you where: not orders, but those 4,000 location writes per second. That is where you spend your time.

The idea

The design is the excuse; the conversation about trade-offs is the point. Nobody grades your boxes. They listen for whether you know what each box costs and why you are willing to pay it.

What each step is really testing

Each step puts a different skill under the light.

Step 1: do you define the scope, or dive in blind? Drawing before asking is a red flag straight away. Step 2: do your numbers change your decisions? Estimates that never affect a choice are decoration.

Step 3: do you agree on the map before going deep? The high-level sketch is a contract, and people watch whether you check it with them. Step 4: do you argue trade-offs, or just list tools? Naming a technology is worth little next to saying what it costs and why you pay it.

Reaching for tools first

Jumping to tools gives a beginner away: 'Kafka' before saying what problem it solves, 'Kubernetes' before knowing the load. Name the problem first, such as separating slow work from the request, absorbing spikes or retrying failures. Then let a tool earn its place. A tool looking for a problem is just complexity with a logo.

One way to fail at each step

Step 1: skipping the questions. You design the wrong product, and no brilliance afterwards saves you.

Step 2: numbers with no consequences. You calculate 12,000 reads per second, then build as if you never did.

Step 3: boxes nobody agreed to. You solve your version of the problem, not theirs.

Step 4: going deep on the easy part. You polish the database tables while the hard part, like the feed ranking or the live tracking, stays a grey box.

There is no single correct design

Two excellent engineers will design the same system differently, and both can be right. Every design is a bundle of trade-offs: consistency against speed, simplicity against scale, build against buy.

The famous example is the CAP idea. When the network between machines breaks (a partition), a distributed system must choose: stay consistent and refuse to answer until it is sure, or stay available and answer with what it has, even if it is out of date. At that moment you cannot have both. You can only choose, and explain why.

Test yourself

Someone asks you to 'design a chat app'. What are your first three moves before you draw a single box?

Answer in your head first, then check.

Takeaway

Every design question is the same four steps: clarify, estimate, sketch, deep dive. And remember what you are really being asked for: not the right design, but trade-offs argued well.

Do it this week

Take an app you use daily, such as your bank app or a delivery app, and run steps 1 and 2 on it in a notebook: write the functional and non-functional requirements, then estimate requests per second and storage. Ten minutes, and no drawing allowed.

What you can do now
  • Run the four steps (clarify, estimate, sketch, deep dive) on any design question.
  • Find the one component where the real difficulty of a system lives.
  • Defend each choice as a trade-off: what you gain and what you give up.

The Design Playbook