How Amazon S3 works
An effectively infinite hard drive on the internet, with eleven nines of durability.
Amazon S3 is object storage: you store files ('objects') identified by a key inside a bucket, and read and write them over a simple HTTP API (PUT and GET). Behind the scenes S3 redundantly replicates every object across multiple data centres so it can promise 99.999999999% durability. Storage classes, versioning and lifecycle rules let you trade cost against access speed and retention.
Buckets, objects and keys
Everything in S3 lives in a bucket, a container with a globally-unique name. Inside it, each file is an object — the data plus metadata — addressed by a key, which is just a string like reports/2026/q1.pdf. It looks like folders, but S3 is actually a flat key-value store: the slashes are only a naming convention, so there are no real directories underneath.
PUT and GET over HTTP
You interact with S3 entirely through an HTTP REST API, usually via the AWS SDK. A PUT request uploads an object to a key, a GET retrieves it, and a DELETE removes it. Because it's just authenticated HTTP, any language or tool can read and write objects without running a database or a file server of your own.
Durability by replication
When you PUT an object, S3 doesn't keep a single copy — it synchronously replicates the data across multiple devices in at least three Availability Zones (physically separate data centres) before acknowledging the write. This redundancy is what backs the famous 99.999999999% (eleven nines) durability figure. Losing a disk, a rack, or an entire data centre doesn't lose your data.
Strong consistency
S3 offers strong read-after-write consistency: the instant a PUT succeeds, any subsequent GET is guaranteed to return the new data, and a list operation reflects the change too. Earlier S3 was only eventually consistent, so apps had to code around brief staleness. Now a successful write is immediately visible everywhere, which removes a whole class of subtle bugs.
Storage classes
Not all data is accessed equally, so S3 offers classes at different price-performance points. Standard is for hot, frequently-read data; Standard-IA is cheaper for infrequent access with a retrieval fee; Glacier and Glacier Deep Archive are very cheap for archives you rarely touch, with retrieval taking minutes to hours. Choosing the right class is the main lever on your storage bill.
Versioning and lifecycle
With versioning enabled, S3 keeps every version of an object instead of overwriting, so a bad write or accidental delete is recoverable. Lifecycle rules then automate the economics: transition objects to cheaper classes after N days and expire or delete old versions automatically. Together they protect data and control cost without any manual housekeeping.
What S3 is and why it changed everything
Amazon S3 (Simple Storage Service) was AWS's first public service and remains one of the most important pieces of infrastructure on the internet. It is object storage: a service for storing and retrieving arbitrarily large amounts of unstructured data — images, videos, backups, logs, static websites, data-lake files — over the network. The pitch is deceptively simple: an effectively infinite hard drive you access over HTTP, where you pay only for what you store and transfer, and never think about disks, RAID, capacity planning or hardware failure.
What made it revolutionary was removing storage as a scaling concern entirely. Before S3, storing a growing pile of user uploads meant provisioning servers, attaching disks, worrying about them filling up, and building your own replication so a failed drive didn't lose data. S3 turned all of that into an API call. You PUT a file and it's durably stored across multiple data centres; you GET it back later. That single abstraction underpins a huge fraction of the modern web, including data lakes, which use S3 as their raw storage layer.
Buckets, objects and keys
S3's data model has just three concepts:
- A bucket is a top-level container with a name that must be globally unique across all of AWS (because it can form part of a public URL). A bucket lives in a specific region.
- An object is a single stored item: the data blob itself, plus metadata (content type, size, custom tags) and a unique identifier.
- A key is that identifier — a string like
images/2026/logo.pngthat names the object within its bucket.
The crucial mental correction is that S3 is not a filesystem. It is a flat key-value store: the bucket maps keys directly to objects, and there are no real directories underneath. The slashes in a key are pure convention — the console *renders* images/2026/ as nested folders for your convenience, but under the hood images/2026/logo.png is simply one flat key. This is why S3 scales so well: there's no directory tree to traverse or lock, just a massive distributed hash of keys to objects.
The API: reading and writing over HTTP
You never mount S3 or open a socket to a storage daemon. Everything happens through a REST API over HTTPS, almost always via the AWS SDK for your language or the CLI. The core verbs mirror HTTP:
- `PUT` uploads an object to a given key (creating or overwriting it).
- `GET` downloads the object at a key.
- `DELETE` removes it, and `LIST` enumerates keys under a prefix.
Every request is authenticated and authorised — with IAM policies, bucket policies and signed URLs controlling who can do what — and large uploads can be split into a multipart upload so a failure only retries one part. Because it's just authenticated HTTP, any client anywhere can read and write objects without you running a single server, and you can even hand a temporary pre-signed URL to a browser so it uploads directly to S3, bypassing your backend entirely. That serverless, language-agnostic access model is a big part of S3's ubiquity.
Durability, availability and consistency
S3's headline promise is 99.999999999% durability — eleven nines. That means if you store ten million objects, you'd statistically expect to lose one roughly once every ten thousand years. This isn't magic; it's redundancy. When you PUT an object, S3 synchronously writes it across multiple devices in at least three separate Availability Zones — physically distinct data centres with independent power and networking — before it acknowledges the write. An entire data centre can burn down and your data survives because identical copies exist elsewhere.
Durability (not losing data) is distinct from availability (being able to reach it right now), which S3 Standard targets at a still-high but lower figure like 99.99%. It's also worth separating both from consistency: S3 now provides strong read-after-write consistency, meaning the moment a PUT or DELETE returns success, every subsequent GET and LIST reflects it. This wasn't always true — S3 used to be only eventually consistent, forcing applications to tolerate brief staleness — and the switch to strong consistency quietly eliminated a whole category of hard-to-reproduce bugs.
Storage classes, versioning and lifecycle
Because different data has wildly different access patterns, S3 exposes storage classes that trade retrieval speed against cost:
- S3 Standard — hot data accessed often; lowest latency, highest per-GB price.
- S3 Standard-IA (Infrequent Access) — cheaper storage for data you rarely read, with a per-retrieval fee.
- S3 Glacier / Glacier Deep Archive — very cheap archival storage where retrieval can take minutes to hours; ideal for compliance backups you hope never to read.
- S3 Intelligent-Tiering — lets S3 move objects between tiers automatically based on observed access.
Two more features round out real-world use. Versioning, when enabled, keeps every version of an object rather than overwriting it, so an accidental delete or a bad write is recoverable — deletes just add a "delete marker" you can remove. Lifecycle rules then automate the economics: you write a policy like "move objects to Standard-IA after 30 days, to Glacier after 90, and expire non-current versions after a year," and S3 enforces it with no manual effort. Together, these turn S3 from a dumb bucket into a cost-managed, self-protecting store — which is exactly why it sits at the foundation of so many systems, from static websites and backups to the raw layer of petabyte-scale data lakes.
S3 stores objects (a blob plus metadata) identified by a key, grouped into globally-named buckets.
It's a flat key-value store, not a filesystem — 'folders' are just prefixes in the key string.
You read and write over an HTTP REST API: PUT to upload, GET to download, DELETE to remove.
Every object is replicated across multiple Availability Zones, giving 99.999999999% (11 nines) durability.
Storage classes (Standard, Standard-IA, Glacier) trade retrieval speed and cost against access frequency.
Strong read-after-write consistency, versioning, and lifecycle rules manage correctness, history and cost.
Quick quiz
How is S3 best described structurally?
What does S3's '11 nines' figure refer to?
How data lake architecture works
One place to land any data now and decide what it means later.
Which database should I use on AWS
Seven managed engines, one rule — match the database to the shape of your data and access pattern.
Comparing key-value stores
Four stores that all map keys to values — and almost nothing else in common.
A crash course on scalability
How one box on a laptop becomes a system that serves millions.