Why it matters
Filesystems offer rename, append and partial read; object storage offers put, get and list, and that difference shapes what applications can do. It is the right place for documents, model weights, logs and artefacts because durability and capacity are the provider's problem, but code written as if it were a local disk hits the missing operations: no atomic rename, no locking, expensive listing at scale.
Mental model
It is a coat room with numbered tickets: you hand over a coat and get a ticket, and you never edit a coat in place. The analogy breaks because a ticket can be shared as a time-limited link, which a physical coat check cannot do.
How it works
Step · 1 of 9
Eight objects, one class
Eight ten-GB blocks occupy the standard class: 80 of a 100 GB budget, with twenty GB free. Every read is a fast GET and every stored GB is billed at the highest rate. The grid is a byte budget, not an object count.
Next: Day 30 moves four blocks to cold
- Used (GB)
- 80
- Standard (GB)
- 80
- Cold (GB)
- 0
- Archive (GB)
- 0
- Versions (GB)
- 0
- Incomplete (GB)
- 0
Figure. A 100 GB storage budget drawn as ten 10 GB slots. Each slot's class is its owner: standard, cold, archive, a noncurrent version, or an incomplete multipart part. Lifecycle rules move the same bytes between classes; versioning adds bytes; expiry is the only thing that removes them. Sizes are synthetic; provider prices and retrieval times are not shown, and the budget is a planning cap rather than the bucket's limit.
What to notice. A transition changes the class and the price, never the byte total: steps 2 and 3 keep the budget at eighty GB while the grid changes owner four and then three times. The budget first exceeds its live size at step 4, when versioning retains two old 10 GB copies, and it stays full through the thirty-day noncurrent window because a delete marker is not a reclaim. Expiry (step 6) is what returns capacity. The last three steps separate a prefix rule from an upload that never finished: incomplete parts are billed, are invisible to LIST, and are only removed by an abort rule.
Text version
A 10-slot storage budget, one slot per 10 GB. Step 1: eight standard slots, 80 GB used. Step 2: four slots move from standard to cold, still 80 GB. Step 3: two standard and one cold slot become archive; 20 standard, 30 cold, 30 archive. Step 4: two overwritten objects keep two noncurrent versions; 100 GB used. Step 5: the versions stay inside the 30-day window; still 100 GB. Step 6: noncurrent expiry removes both versions; 80 GB. Step 7: a prefix rule expires one cold and one archive slot; 60 GB. Step 8: an aborted multipart upload leaves 10 GB of parts; 70 GB used, 10 GB incomplete. Step 9: abort-incomplete removes the parts; 60 GB. Counters show used 80, 80, 80, 100, 100, 80, 60, 70, 60; standard 80, 40, 20, 20, 20, 20, 20, 20, 20; cold 0, 40, 30, 30, 30, 30, 20, 20, 20; archive 0, 0, 30, 30, 30, 30, 20, 20, 20; versions 0, 0, 0, 20, 20, 0, 0, 0, 0; incomplete 0 until step 8 then 10 and 0.
- Design keys as a hierarchy by prefix so listing and lifecycle rules can operate on a group.
- Write objects once and treat them as immutable; for updates, write a new key and switch a pointer.
- Use conditional writes or a separate lock record when two writers can produce the same key.
- Serve private objects with presigned URLs that expire quickly and grant only the needed operation.
- Set lifecycle rules for expiry and transition, and account for retrieval latency from cold classes.
- Use multipart upload for large objects and clean up incomplete uploads, which otherwise accrue cost.
Trade-offs
| Choice | Good for | Cost | Fails when |
|---|---|---|---|
| Standard class | Low latency for frequent access | Highest storage cost | The data is rarely read |
| Cold or archive class | Much lower storage cost | Retrieval latency and minimum duration charges | The data is needed interactively |
| Public bucket | Simple serving of static assets | Anyone can read and enumerate | The content is private |
| Presigned URL | Delegated access without credentials | Anyone with the URL has access until expiry | The URL is logged or shared |
Good for
Low latency for frequent access
Cost
Highest storage cost
Fails when
The data is rarely read
- The data is rarely read
- The data is needed interactively
- The content is private
- The URL is logged or shared
Figure. Each choice with what it buys, what it costs, and the case where it loses.
What to notice. The fourth column is the decision: if the losing case describes your situation, the choice is wrong.
Text version
Four trade-offs: Standard class is good for Low latency for frequent access, costs Highest storage cost, and fails when The data is rarely read. Cold or archive class is good for Much lower storage cost, costs Retrieval latency and minimum duration charges, and fails when The data is needed interactively. Public bucket is good for Simple serving of static assets, costs Anyone can read and enumerate, and fails when The content is private. Presigned URL is good for Delegated access without credentials, costs Anyone with the URL has access until expiry, and fails when The URL is logged or shared
Failure modes
- Silent overwrite. Two writers put the same key and one result disappears. Debug: enable versioning or conditional writes and check the object's version history for the key.
- Runaway listing cost. A prefix with millions of keys is listed on every request and latency and cost climb. Debug: measure list calls per request and check the prefix cardinality.
- Expired presigned URL. Links stop working after a short window and users report broken downloads. Debug: compare the URL's expiry parameter with the time of the failing request.
In production
Track request rate by operation, egress volume and the age of incomplete multipart uploads. Set lifecycle rules to expire temporary objects, and alert on a bucket policy change, since a public grant is a one-line mistake.
Common misconceptions
People think: Object storage is a filesystem in the cloud.
Actually: It has no directories, no append and no rename; prefixes are a naming convention over a flat key space.
People think: Versioning is only for backups.
Actually: It is also the mechanism that makes concurrent overwrites recoverable, which is why it belongs in the write design.
Interview angle
Name the operations that do not exist and how the design compensates: conditional writes, version keys, presigned access. Cover lifecycle cost. Describing it as a disk with an HTTP interface misses the model.
Sources
- Amazon S3, User Guide — keys, versioning, presigned URLs and lifecycle rules.
- Google Cloud Storage documentation — storage classes, consistency and access control.