Walking one request through the design
Narrating one concrete request hop by hop across your diagram, from the client to the last store it touches and back. It shows whether the boxes and arrows serve the requirements, and where the design has gaps.
What it is
Walking a request means choosing one action a user takes, then following it through the design you've drawn, one component at a time: what each component receives, what it decides or stores, and what it hands to the next one. Prep guides for the design round place it inside the high-level design step: draw the simplest design that meets the requirements, trace one request through it, then trace the other main request. Alex Xu's framework chapter makes a similar move with use cases: running a few concrete ones through the blueprint helps frame the high-level design and tends to turn up edge cases you hadn't thought about.
The two hops that hide the most design are the response and the hand-off. The response: at which point does the client hear back, and what does the answer contain? If the service replies before the fan-out has happened, delivery is asynchronous, and the client's view has to be explained. The hand-off: where does work leave the request path, what carries it (a queue, a scheduled job), and what happens to it if the consumer is down? A news feed, for instance, is drawn as two flows, publishing a post and building a reader's feed, each with its own diagram.
| Hop | What to say as you pass it | Why it matters |
|---|---|---|
Client | Which API call, with what fields, and what the client already knows (a generated ID, a cursor) | Ties the walk to the API you defined |
Gateway or load balancer | What it checks (auth, rate limit) and how it picks a server | Where a bad request gets rejected |
Service | What it validates, what it writes, and what it returns | The decision point of the request |
Store | Which table or key, and what index or partition serves the lookup | Confirms the data model supports this access |
Queue or job | What the message holds, who consumes it, and what happens if nobody does for a minute | Shows you know the request isn't finished at the response |
Response | What the client sees and when | Fixes the consistency the user experiences |
Meta's preparation page for its design interview asks candidates to say which components they'd use and how they fit together, and to move between the goals, the high-level approach and the precise details. Our advice: a request walk is a natural way to do both on one diagram. Each hop is a chance to drop one level (“this write needs a client-generated ID, because the app retries on a bad connection”) and climb back to the next hop.
When to use it
Right after the first draft of the high-level diagram and before the deep dives. The ByteByteGo framework budgets roughly 10 to 15 minutes of a 45-minute round for the high-level design, so a two-minute walk for each of the two main flows fits inside it, with time left to agree with the interviewer on what to go deep on.
Each time you add a component. A cache, a queue or a replica earns its place when you can name the requirement or number that needs it; walking the request through the new box is how you show that it does something, rather than decorating the board.
When the interviewer asks “what happens if…”. A question like “what if this service is slow?” is usually an invitation to talk about exactly that part. Pick up the request at the client, carry it to that hop, and say what holds it, what times out and what the user sees.
When you've lost the thread. Returning to a concrete request (“so where were we: the message has been stored, and the sender has their confirmation”) is a cheap way to find your place and bring the interviewer back with you.
When not to
Don't walk each request at the same depth. Two flows in full, usually the main write and the main read, and the rest in a sentence each. The ByteByteGo framework warns against going deep on one piece at the beginning: give the high-level design first, then drill down.
Don't let the walk turn into the deep dive. Meta's page says there isn't time for all the details, and that the interesting hard problems are where to focus the discussion. Our advice: trace at the component level, mark the hard hops as you pass them (“fan-out to large groups is the problem here; I'll come back to it”), and keep moving.
Match the granularity to the problem. For very large prompts, such as designing a web search engine, API endpoints and a schema are too low level for the high-level pass. The walk still works, but the hops are subsystems (crawler, indexer, serving) rather than endpoints and tables.
When the interviewer has asked for something else. If they want the estimate, the trade-off or the schema, give them that; a trace they didn't ask for reads as avoiding the question. Likewise, a requirement you've agreed is out of scope, or one whose path reuses hops you've already traced, gets a sentence, not a walk.
Compared
| Way of presenting the design | What it sounds like | When it's the right choice | What it costs |
|---|---|---|---|
Component tour | “Here's the load balancer, here's the service, here's the database.” | The interviewer asks what a box is, or the design has three boxes and one obvious path | The arrows aren't followed, so nothing shows that a requirement is met |
One request walked end to end | “Ana taps send; the app calls POST /messages; the service…” | The default after drawing: the main write, then the main read | A couple of minutes per flow, and you have to pick requests that represent the rest |
All requests walked in detail | Each endpoint traced from client to store | Systems whose scope you've narrowed to a couple of operations, such as a URL shortener reduced to create and redirect | In a larger system it spends the time the deep dives need |
Hop-by-hop trace with a failure at each step | “If the worker dies here, the queue holds the message for…” | A deep dive on the hardest path, or an interviewer's “what if this fails?” | Too slow for the high-level pass; save it for the part you chose to go deep on |
In a picture
Step 1 of 3
Draw the simplest path
Start with the fewest boxes that could serve the request: the sender's client, a service and a store. Name the API call on the first arrow and the write on the second. Nothing else goes on the board yet.