Three Cloud Storage Tiers Compared: The 8 KB Request That Broke the Budget
Archi4 min read
Contents
The Detail Nobody Puts on the Pricing Page#
A team I spoke with runs a document pipeline: about 40 million small objects, most under 4 KB. They priced three cloud storage options in a spreadsheet, picked the cheapest per gigabyte, and moved on. Six weeks later the invoice was 2.3 times the estimate. The culprit was not storage. It was the number of requests, and specifically how each provider counted them.
The comparison below is a good-faith one across Amazon S3 (Standard, Standard-IA and Intelligent-Tiering), Azure Blob Storage (Hot, Cool and Archive) and Google Cloud Storage (Standard, Nearline and Coldline). Prices change, so treat dollar figures as illustrative. The structure of the charges is the part that holds.
What each tier actually charges for#
All three providers charge for three things: bytes stored, operations (PUT, GET, LIST), and getting data out. The headline per-gigabyte rates get the attention. The operations line is where small-object workloads live or die.
For small objects, the per-request cost can exceed the storage cost of the object itself. A 3 KB object stored on a cheap tier for a month might cost a fraction of a cent in storage. Reading it once can cost more than keeping it for a year. That inversion is the whole story.
The 8 KB request#
Here is the specific moment that decided the migration. Their pipeline ran a list operation on a prefix holding roughly 2 million keys, every 15 minutes, to pick up new files. That is 96,000 list calls a day, and each one returns a lot of keys. On one provider, the list call itself is cheap but the returned-key charges add up. On a second, list calls are priced flat but throttled under load, which caused retries, and retries are billable. On the third, the call was cheap and fast but the client library quietly paginated at 1,000 keys, turning each list into 2,000 calls instead of one.
That last detail is the one that mattered: the default page size in the SDK. Nothing in the pricing documentation mentions it. Nothing in the architecture review catches it. The team had estimated list cost assuming one call per sweep. The library did 2,000.
Tier by tier, on the parts that bite#
Amazon S3. Standard is the most expensive to store and the cheapest to read. Intelligent-Tiering adds a small monitoring charge per object, and that charge is where small-object fleets get hurt, because it applies per object per month regardless of size. With 40 million objects, the monitoring line alone is real money. Standard-IA has a minimum billable object size (128 KB in practice), so a 3 KB file gets charged as if it were larger.
Azure Blob Storage. Hot tier pricing is competitive, and the cool tier has a minimum storage duration of 30 days. Early deletion fees apply. The operational surprise here was the transaction meter: reads, writes and list operations are billed separately, and a workload that does a lot of listing sees it clearly. Azure's flat namespace list is predictable, which is a genuine advantage for the sweep pattern above.
Google Cloud Storage. Standard, Nearline and Coldline have a 30-day minimum for Nearline and 90 for Coldline, with early-delete charges. The pagination behavior of the client library was the deciding detail in this case. GCS also charges for class A and class B operations at different rates, and list falls into a category that is cheap per call but not free.
What the numbers looked like#
On the original estimate, the team projected roughly $1,100 a month across storage and operations. The first real bill was $2,540. Breaking it down: storage was about $310, close to forecast. Get and put operations were around $400. List operations and the retries they triggered came to about $1,700. The remaining $130 was egress from a reporting job nobody had flagged.
The fix was unglamorous. They replaced the prefix sweep with an event notification on object creation, which removed the list traffic entirely. They set the pagination size explicitly in the client config. They moved objects they rarely read to a colder tier but only after checking the minimum-duration math on each file's lifecycle. The bill settled near $780.
How to choose between them#
The tier comparison is less useful than a request-count comparison. Before picking, count three things for your workload: the number of objects, the number of operations per object per month, and the average object size. If the average size is under 16 KB, per-object fees (monitoring, minimum billable size, minimum duration) will dominate the bill. If operations per object are above about 20 per month, the read price matters more than the storage price.
All three providers can be the right answer. The decision hinges on whether your code does many small reads or a few large ones, and whether any of your calls trigger retries or pagination you did not plan for. Check the SDK defaults before the architecture diagram. The 8 KB request decided this migration, and it never appeared in a single pricing table.
A short checklist before you sign#
, Read the minimum billable object size and minimum storage duration for every tier you plan to use., Check the default page size and retry policy in each SDK you will actually call., Model request counts, not just gigabytes, for list-heavy and metadata-heavy jobs., Treat per-object monitoring or management fees as a separate line item in the estimate., Run a one-week pilot with real traffic and compare the invoice to the model line by line.
More articles