Skip to content

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.

On this page

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.

HopWhat to say as you pass itWhy 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 designWhat it sounds likeWhen it's the right choiceWhat 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

POSTinsertSender clientMessage serviceStore

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.

How to say it in an interview

The common mistake

Quiz

Walking a send, you say: the service writes the row, puts an event on the delivery queue, and the sender gets a 200. The interviewer asks whether the sender sees success before or after Ben receives the message. What has the question exposed?
You've traced “send” and “read history”. Your requirements list also has “search messages”, and no box on the board serves it. What's the right next move?
The interviewer asks: “what if the delivery worker is down?” Which answer uses the walk well?
The prompt is a web-scale search engine. What granularity should the request walk use?

Questions that use this

Related

Sources

  1. Preparing for your software engineering interview at Meta (Meta Careers)
  2. A Framework For System Design Interviews (ByteByteGo)
  3. How to Structure a System Design Interview (Natively)
Sign in to report a mistake