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.
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:
| Question | What 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:
"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
readybefore 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."