Nguyen Le Phong

The First Five Minutes of a System Design Interview

Before you draw a box: the questions that change a design, a one-minute scale estimate, how to say assumptions out loud and where the gaps between boxes hide.

You've barely uncapped the marker when the interviewer finishes the prompt: "Design an image storage system." It would take you about a minute to draw the usual three boxes: object storage for the files, a database for metadata, a CDN in front.

An engineer stands next to a blank whiteboard with a marker in hand, asking the interviewer a question before drawing anything.
Sometimes the best first design move is leaving the whiteboard blank for one more minute.

None of those boxes is wrong. The timing is. You'd be answering before the question has enough shape to hold an answer, and that's what this post is about: the first few minutes of a system design interview, which questions are worth asking, how to put a number on scale fast, and how to say an assumption out loud so the interviewer can fix it.

One prompt, four different systems

"Image storage" could mean avatars for an internal tool, private family backups, a public social feed or millions of product photos for a shop. They all store images. Each one makes a different promise. A backup service cares about never losing a file and getting it back, and a few seconds of display latency is fine. A public feed cares about read traffic, thumbnails, moderation, a photo going viral overnight and serving users in several regions. Change what the product means and the architecture changes with it.

That's why the ByteByteGo framework, from Alex Xu's System Design Interview, makes "understand the problem and establish design scope" step one and gives it 3 to 10 minutes of a 45-minute session. The book is blunt about skipping it: "Answering without a thorough understanding of the requirements is a huge red flag as the interview is not a trivia contest" (A Framework for System Design Interviews).

Ask the questions that change the design

You don't have time for a checklist of thirty questions, and you don't need one. A question earns its place if a different answer would give you a different diagram. For the image system, these do:

QuestionWhat changes with the answer
Who uploads, who views, and are images public or private?Whether a CDN can cache freely, how access checks work, what happens when access is revoked
Does the first version only upload and show, or also edit, share, search and delete?How many flows you design and how much state you track per image
Do we resize, compress, scan or strip metadata?Whether you need a processing pipeline and a queue
Must the thumbnail be ready in the upload response?Sync processing on the request path, or async with a "processing" state
"Search" by file name, by tags or by what's in the picture?A database index, a search engine or an ML pipeline. Three very different systems
How long do we keep images, and what does delete mean?Lifecycle rules, storage tiers, cleanup jobs

Then the non-functional side: what latency is acceptable, how much availability and durability you need, and how much data you can lose if a region goes down. Consistency isn't one switch for the whole system either. A view counter can be eventually consistent. Access control and the ready flag on an image usually can't.

Put a number on scale in one minute

"We have ten million registered users" tells you very little. Active users, uploads per day, average size, read-to-write ratio, where users are and how long you keep data tell you a lot. Do the math out loud with round numbers:

uploads per day     2,000,000
average size        4 MB
new originals/day   2,000,000 x 4 MB  = 8 TB
new originals/year  8 TB x 365        = about 2.9 PB
average write rate  2,000,000 / 86,400 = about 23 uploads/s

This isn't a forecast. It's a quick way to find the next questions. Nearly 3 PB a year of originals, before thumbnails and replicas, means compression, image variants and lifecycle rules suddenly matter. Twenty-three uploads a second on average is modest, so the upload path probably isn't the hard part. The read path, at whatever read-to-write ratio the interviewer gives you, likely is.

Say your assumptions out loud

The interviewer won't always give you numbers, sometimes on purpose. That's not a dead end. The ByteByteGo framework says to write your assumptions on the whiteboard, because "you might need them later". Then keep going:

Something like

"I'll assume a public, read-heavy photo-sharing app with a million daily active users, thumbnails, and most users in Southeast Asia. If that scope works for you, I'll design the upload path and the read path first, and leave search and editing out."

A spoken assumption can be corrected in five seconds. A silent one can steer the whole hour toward the wrong system. Saying what's out of scope matters just as much: it tells the interviewer you saw those features and chose to park them.

Now the familiar boxes earn their place

With requirements on the board, each component has a reason you can say in one line:

  • Object storage for large blobs that need high durability.
  • A metadata database for owner, object key, access rules and processing state.
  • Direct uploads with presigned URLs, so big files skip your app servers. S3 lets someone upload with a presigned URL without having AWS credentials of their own, limited to what the URL's creator is allowed to do (Amazon S3 docs).
  • A queue between "upload accepted" and resizing or scanning.
  • A CDN for a public, read-heavy workload.

Same boxes as minute one. The difference is that each one now answers a requirement you named.

Then look at the gaps between them

The questions that show judgment usually sit between the boxes:

  • The object upload succeeds but the metadata write fails. Who finds the orphaned file, and when? A lifecycle rule or a cleanup job (S3 lifecycle) is a fine answer, as long as you say it.
  • A worker retries and makes the same thumbnail twice. Is that safe? It is if the output key is derived from the input, so the second write just replaces the first.
  • Can metadata say ready before every variant exists? Yes, unless flipping that flag is the very last step.
  • A user deletes a private photo. How does it leave the CDN? CloudFront can invalidate a file, but its own docs note that users may keep seeing the old version from a local or corporate cache until it expires (CloudFront invalidation). If revocation must be instant, private images probably shouldn't sit in a long-lived shared cache at all.

Thinking through one or two of these says more than adding another service to the diagram.

Practice this before your next interview

  • Take one classic prompt and write the four products it could mean.
  • For each question you plan to ask, write what would change in the design if the answer flipped. Drop the ones where nothing changes.
  • Do one back-of-the-envelope calculation out loud, with round numbers, in under a minute.
  • Practice your scope sentence: what you assume, what you'll design first, what you're leaving out.
  • Before drawing, say: "Before I propose an architecture, I'd like to check the main use case and the constraints that could change the design."
What did you think?

Frequently asked questions

How long should I spend clarifying requirements in a system design interview?
A few minutes. The framework in Alex Xu's System Design Interview gives this step 3 to 10 minutes of a 45-minute session. Ask the questions that could change the design, state your assumptions, summarize the scope and move on to the high-level design.
What questions should I ask at the start of a system design interview?
Ask who the users are and what they do, which features are in the first version, rough scale (active users, requests or uploads per day, data size, read-to-write ratio), latency and availability needs, and what can be eventually consistent. Keep a question only if a different answer would change your diagram.
What if the interviewer won't give me numbers?
Make an assumption, say it out loud and write it down, then continue. For example: a public, read-heavy app with a million daily active users. The interviewer can correct a spoken assumption right away; a silent one can lead the whole interview toward the wrong system.