SpeakUp SD

Object Storage

Design an S3-like object storage service that stores billions of immutable blobs durably and cheaply.

00

Practice checkpoints

The requirements are open as a taste. From the numbers onward, the full guide opens in the app.

  1. 01
    Clarify scope
  2. 02
    Requirements + scale
  3. 03
    API + data modelUnlocks in the app
  4. 04
    Draw architectureUnlocks in the app
  5. 05
    Deep diveUnlocks in the app
  6. 06
    Trade-off decisionUnlocks in the app
01

Requirements that shape the design

Do not only state requirements. Ask for them. Each card pairs the design constraint with a clarification question you can say out loud before drawing the architecture.

Functional requirements

01Is this a filesystem — can clients rename, append, edit in place?

No: a flat namespace of immutable blobs — PUT, GET, DELETE, LIST by bucket and key; an overwrite is a whole new object under the same key, never an edit in place.

02How big can a single object be?

From a single byte to 5 TB; anything large uploads as multipart — independent, retryable parts assembled by one final commit, so a dropped connection never restarts from zero.

03A client PUTs and immediately GETs — what do they see?

The new bytes, always: strong read-after-write consistency — once the PUT is acknowledged, every GET and LIST reflects it, with no eventually-consistent window to program around.

04Keys are flat — how do clients browse billions of them?

LIST returns keys in lexicographic order, filtered by prefix and paginated by continuation token — prefixes are what make a flat namespace feel like folders.

05Does every object sit on the same class of storage forever?

No: lifecycle policies move objects through hot, cold, and archive tiers by age and access pattern — the API stays identical while the bytes get cheaper to keep.

06What integrity guarantee does a reader actually get?

Every object carries an end-to-end checksum computed at upload; a GET returns exactly the bytes that were PUT or a clean error — silent corruption is never served.

Out of scopeSync clients, sharing UX, collaboration — consumer file-sync products are built ON a store like this · Query or analytics over stored bytes (that is a data-lake engine layered on top) · Cross-region active-active replication — single-region durability is the core problem here

Non-functional requirements

01What do 11 nines of durability actually mean?

99.999999999% annual durability: store 10 billion objects and expect to lose roughly one per decade — a number engineered from redundancy plus repair speed, never asserted.

02Is availability the same promise as durability?

No: target 99.99% availability for requests alongside 11 nines for bytes — a region can be unreachable for minutes and still lose nothing, so the two get separate machinery.

03How big does the namespace get?

Trillions of objects across exabytes — and they grow on different axes, so the metadata service scales by key count while storage nodes scale by raw bytes.

04What does a stored byte cost at this scale?

Bulk-tier overhead near 1.5× raw via erasure coding, not 3× via replication — at exabyte scale the redundancy scheme is a difference of hundreds of PB of disks.

05How fast must a GET start, and how fast must it flow?

Hot-tier time-to-first-byte in tens of milliseconds, with throughput that scales by reading large objects in parallel stripes, not one long stream.

Keep asking — the interview is a conversation

Real interviews probe far more than a tidy list. These are the scope questions that separate candidates who interrogate the problem from those who recite it.

  • What is the object size distribution — billions of KB thumbnails, or thousands of TB backups? The whole design flips on this.
  • Is strong read-after-write required, or may LIST lag a fresh PUT by seconds?
  • What durability and availability targets — and are they allowed to differ?
  • How much of the data goes cold after 30 days — is lifecycle tiering core or a later add-on?
  • Do we need versioning and delete protection, or is latest-wins acceptable?
01

Unlock the full playbook for Object Storage

Numbers, architecture diagram, API and data model, deep dives, expected topics, self-check, whiteboard starter, and common mistakes unlock inside the app.

02

Numbers that force architecture decisions

Locked in the app

03

Architecture path

Locked in the app

04

API and data model

Locked in the app

05

Deep dive directions

Locked in the app

Practice this in the app →Browse pattern series
+Series

Practice the related series

Storage, media & content delivery19 questions