For years, S3 tutorials opened with "eventual consistency on overwrite and delete." In 2020 AWS announced strong read-after-write consistency for new puts, overwrites, and deletes in all regions — a GET after a successful PUT of the same key should see that write. That change retired a class of "retry until the object appears" hacks. It did not retire key design, listing semantics, or the fact that your application's multi-key workflow is still not a transaction.
What "strong" covers, and what it does not
Strong consistency is per key, for the object store's own operations. It does not make two keys atomic. Uploading manifest.json and data/0001.parquet as two PUTs can still be observed in-between: a reader can see the new manifest and miss a part, or the reverse, unless you publish the manifest last and treat it as the commit record.
List operations are the remaining source of surprise. A LIST may lag or include keys you just deleted depending on prefix and timing. Build workflows that do not require LIST as a linearizable transaction log. Prefer a DynamoDB or Postgres index of keys you care about, or a single commit object that names the set.
Good: put parts → put manifest (immutable versioned key)
Bad: put parts → expect LIST(prefix) to be the source of truth immediatelyIdempotent keys beat clever retries
PUT is idempotent for the same body; multipart upload is not if you mix upload IDs. Use deterministic object keys from a content hash or a business id plus a version. Retries after a timeout should reuse the same key, not mint file-copy-2. Otherwise you leak objects and you cannot tell which one the database row points at.
Conditional writes (If-None-Match: * on a create, or etag-based updates where supported) are how you prevent two workers from clobbering a non-versioned key. If the object is the system of record, enable versioning or you will not have a forensic trail.
Request patterns that keep bills and latency sane
Small random GETs of huge objects are the anti-pattern; use range GETs or chunk the file. Tiny objects (kilobytes of JSON at millions per day) often belong in a database, with S3 used for blobs. Cross-region replication is asynchronous: do not pretend a PUT in us-east-1 is already readable in ap-south-1 for a user request.
The 2020 consistency upgrade is real and worth deleting old comments about "wait 2 seconds after PUT." Replace those comments with the actual invariant you need: single-key read-your-writes, or a multi-object commit protocol you designed on purpose.
A worked manifest commit
Upload parts to runs/2026-09-16/job-9f3c/parts/0001.parquet … 000N. Only after all parts succeed, PUT runs/2026-09-16/job-9f3c/manifest.json listing every part key and checksum. Readers take a manifest key from a database row (or a current.json you overwrite last). They never LIST the prefix to decide completeness. A retry of part 0001 uses the same key and the same bytes (or a new versioned key if you must replace).
Multipart: reuse one upload ID per part set; abort abandoned uploads on a timer or you pay for incomplete parts.
Failure modes
LIST as transaction log. Clients see a partial prefix and process it.
Timeout then new key. Orphan objects and a DB pointer at the old name.
Cross-region read-your-write. Replication lag is not the 2020 strong-consistency guarantee.
Overwrite without versioning on a system-of-record object. No forensic trail.
Tiny JSON at millions of PUTs/day. Request overhead dominates; those rows wanted a database.
When not to treat S3 as a database
Secondary indexes, multi-key transactions, query-by-attribute, and low-latency conditional logic. Conditional PUTs help for a single key; they do not replace DynamoDB for a work queue. Also skip S3 for the source of truth of a lock unless you fully understand TTL and fencing; people rebuild ZooKeeper badly with objects.
Review checklist
- Multi-object workflows have an explicit commit object; LIST is not the commit.
- Keys are deterministic; retries do not mint copies.
- Versioning or immutability on objects that are the system of record.
- Cross-region is called out as async; range GET for large blobs.
A worked failure mode
A pipeline writes latest.json then immediately reads it from another region. Intermittently the reader sees yesterday. Another job lists a prefix to find new objects during a flood of writes and misses keys; it never recovers because there is no inventory or event. Overwrites of the same key hide poison data with no versioning. The failure is using object storage like a POSIX filesystem. Prefer unique keys, listings via inventory or notifications, and read-after-write only on the patterns the provider actually guarantees.
When this is the wrong tool
Object storage is the wrong tool for a high-rate compare-and-swap lock, for POSIX semantics, and for tiny chatty files as a database. Do not implement a queue with list-and-delete on a hot prefix. Use a database for mutable rows and S3 for immutable blobs with explicit versions. If you need POSIX, use a file system.
When this pattern is stretched past its assumptions, the first outage looks like a mysterious performance cliff instead of a design limit. "Object Storage Consistency and the Request Patterns That Survive It" fails that way when traffic mix, data shape, or team skill does not match the blog that sold the approach. Keep a kill switch: feature flag, smaller blast radius, or an older path that still works. Measure the thing the idea claims to improve, not a vanity graph. If you cannot name a workload where you would refuse to use it, you have not finished the design.