How to practice the follow up questions when your day job has never needed a million requests a second.
You can ship useful software for years and still feel weirdly underqualified when an interviewer adds another zero to the traffic estimate.
Yesterday’s work involved fixing an endpoint, untangling a migration, or making a customer’s report finish before lunch. Suddenly, you’re expected to explain what happens when an entire country opens the app together.
Honestly, that gap can make preparation feel like applying for a job you need to already have.
An engineer raised exactly this concern in a recent discussion about system design preparation (given below). They had studied the concepts, but detailed questions about scaling an existing system exposed gaps that more reading hadn’t resolved.
I think there’s a useful way to practice here, especially if collecting another architecture diagram is starting to feel suspiciously like progress.
Keep one system on the page, change one assumption, and explain which decision stops making sense.
You won’t manufacture years of operational experience in an evening. You can, however, practice the reasoning that connects a requirement to a bottleneck, a trade-off, and a test. Let’s make that concrete.
Stop giving the system a bigger number without giving it a workload
Start with a small news feed. People follow topics, and the app combines recent articles from those topics into a personal feed.
For this exercise, assume each topic already has a cached list of recent article IDs. Your service retrieves those lists, merges them, removes duplicate IDs, and returns the newest 20 eligible articles.
That is enough of a system to begin. Leave the enormous architecture diagram for later, please.
Now write down what one request actually does. Suppose a user follows 20 topics and the first version takes 50 recent IDs from each topic. It considers up to 1,000 candidate IDs before deduplication and selection.
Those 50 IDs are a starting batch, not a guarantee of a full page. Overlap, removals, or filters may force another fetch. Already, there’s a useful follow-up hiding inside a very ordinary endpoint.
For the first workload, assume 100 feed reads per second. Then change only one variable at a time.
- Increase feed reads to 1,000 per second while keeping topic counts unchanged.
- Return to 100 reads per second, but increase followed topics from 20 to 200.
- Keep total traffic unchanged, but concentrate 60% of reads on one topic.
These are invented practice workloads, not measured limits or claims about a particular company.
Notice how the second scenario can create trouble without adding a single user. More work inside each request can be just as interesting as more requests arriving.
If you want a concrete prompt to keep beside your notebook, use this topic based feed design exercise. Sketch only its read path first, then change the number of topics each user follows before looking at the guidance. The workloads in this article are my practice extensions to that prompt.
Follow the work before you choose the technology
With 200 followed topics, that initial batch becomes 10,000 candidate IDs for a response that still contains just 20 articles.
At 100 requests per second, that is up to one million candidate IDs considered per second instead of 100,000. This is a rough work estimate, not a prediction of CPU usage or a count of network calls. Batching, overlap, data structures, and early stopping all affect actual cost.
Still, the arithmetic gives you somewhere sensible to look.
Does time disappear fetching topic lists? Waiting for connections? Merging candidates? Hydrating article details? Filtering items that should no longer be shown?
Google’s SRE chapter on handling overload makes a related point. Requests can consume very different amounts of resources, so request rate alone can be a poor description of capacity.
For our practice system, record request duration alongside dependency calls, candidate counts, CPU time where available, and errors. Look at slow requests as well as the average. A healthy-looking average can hide an unpleasant experience for users following many topics.
My favorite question at this stage is whether the proposed fix reduces the work, moves the work, or merely gives the same work more machines.
All three can be reasonable. They just need different explanations.
Compare two answers that could both be right
Suppose measurement suggests feed assembly is expensive. More application instances might help if the work is CPU-bound and the dependencies have headroom. They might also multiply pressure on a shared store that is already struggling.
Now compare read-time merging with precomputed feeds.
Read-time merging keeps composition close to the current topic lists and user preferences. Its cost grows with the work needed to gather and combine candidates for each request.
Precomputation moves some assembly away from the request. A background process can prepare candidate feeds for users or cohorts, so the serving path does less work. But new articles now create update work, and users may see a freshness delay while that work catches up.
An article associated with a very popular topic makes the trade off especially visible. Copying its ID into every follower’s feed may create a large burst of writes. Cohort feeds can share some work, but they do not eliminate personalization and membership questions.
This is where a hybrid becomes worth discussing. The system precomputes a base feed while merging some fresh or unusually popular content at read time. That buys flexibility and also creates more paths to test and operate.
You don’t need to crown a winner before establishing the requirements. You need to say which workload makes each option attractive, what it costs, and what evidence could change your mind.
For example, precomputation becomes easier to defend when repeated reads dominate and the product accepts some freshness delay. It becomes harder to defend when frequent preference changes and fanout updates consume most of the savings.
That explanation contains more engineering than a lonely box labeled cache.
Add one requirement that ruins your comfortable answer
Okay, now the product team needs an incorrect article removed quickly.
If you precomputed feeds, deleting the article from primary storage does not explain what happens to its ID in saved feeds, cached responses, or requests already being served.
Define the promise first. Does removal mean new feed requests stop returning the article within a specified interval? Does it also require removing content already displayed on a phone? Those are different jobs.
For this exercise, choose the first promise and write down a hypothetical removal deadline. Then trace every place that can return the article.
One possible design keeps an authoritative visibility status and checks candidate articles before serving them, while cleanup removes stale references in the background.
But if that visibility check uses a stale cache or replica, your deadline needs to account for that too. Calling something authoritative on a diagram doesn’t make every read current.
Now the trade off has become wonderfully uncomfortable. Faster feed reads introduced stored results, and stored results created another correctness obligation.
This is the practice move worth repeating. Whenever you add an optimization, give it one inconvenient requirement and see whether your explanation survives.
Use your laptop to investigate a mechanism, not imitate Google
You don’t need a million requests per second to explore the difference between merging 20 lists and merging 200 lists.
Build the smallest version of the read path with synthetic topic lists and repeatable data. Keep hardware and test conditions the same, change one workload variable, and record what happens. Include duplicate IDs, skewed topic popularity, and a removal case so the benchmark doesn’t reward incorrect results.
Compare the original implementation with one alternative. Check the returned feed as well as the timings, because an implementation that quietly drops articles can look impressively fast.
A local experiment can reveal how this implementation behaves under those conditions. It cannot establish production capacity, cross region behavior, or the cost of operating a distributed service. Keep that boundary visible in your notes.
When implementation time is limited, a paper exercise still helps. Estimate the work, trace one failure, and write the measurement that could disprove your assumption. Just label it as a prediction rather than a result.
Give tonight’s practice a finish line
Try one 70 minute session with the same system rather than opening five unrelated solutions.
- Spend 15 minutes drawing the baseline and recording its workload and correctness promise.
- Spend 20 minutes changing one variable and predicting the first likely bottleneck. Identify the measurements you need.
- Spend 20 minutes comparing two responses, including the new work and failure modes each introduces.
- Spend 15 minutes explaining the decision aloud and separating what you measured, what you expect, and what you still don’t know.
Finish with a short decision note that another engineer could challenge. Include the workload, the evidence, your chosen change, its downside, and the condition that would make you reconsider it.
Tomorrow, keep the system and change a different assumption. You’ll have to adapt yesterday’s reasoning instead of recognizing yesterday’s diagram, which is exactly why the exercise is useful.
Your day job may never give you Google’s traffic. It can still give you real examples of slow dependencies, expensive queries, messy requirements, and decisions with consequences.
Bring those observations into your preparation, be honest about the limits of your experience, and practice extending the reasoning. You have more to work with than your company’s user count suggests.
~ Emily






Top comments (0)