Skip to main content
S3 Cost Traps: Storage Classes, Requests, and the Surprise Bill

S3 Cost Traps: Storage Classes, Requests, and the Surprise Bill

KU
· Founder & Chief Editor
• 8 min read•Updated •

Our S3 bill tripled in a month with no growth in stored data. The storage line was flat. The cost was in requests and a storage-class choice quietly shredding money.

Key takeaways

  • When an S3 bill jumps but stored bytes are flat, the cause is usually request charges or a storage-class mistake.
  • Group Cost Explorer by usage type first.
  • Batch tiny objects to cut PUT costs, and never put objects under 128 KB in Standard-IA or Glacier Instant Retrieval, which bill each one as 128 KB.

If your S3 bill jumped while stored bytes stayed flat, the cost is in requests or storage-class minimums, not storage. Run Cost Explorer grouped by USAGE_TYPE to find the line. The usual culprits: millions of tiny PUTs at $0.005 per 1,000, and small objects in Standard-IA billed as 128 KB each. Batch the writes and keep small objects in Standard.

Verified against

Amazon S3 US East (N. Virginia) list prices (AWS price list published 2026-10-15), against the AWS S3 pricing page and the S3 User Guide storage-class and lifecycle-transition pages. Checked October 2026.

Here is the pattern, as an illustrative scenario. Finance forwards the AWS bill with one word: "explain." S3 spend has nearly tripled in a month. The first instinct is that you stored a lot more data, so you check the storage metric. Flat. The extra money isn't storage at all. It was everything around storage, the part of the S3 pricing model nobody reads until it bites.

S3 charges you on at least four axes: how much you store, which class it's in, how many requests you make, and how much data leaves. People optimize the first and get blindsided by the other three.

Requests, not bytes, ate the budget

Cost Explorer, grouped by usage type, told the story in one chart. The Requests-Tier1 line (PUT, COPY, POST, LIST) had exploded. A new data pipeline was writing millions of tiny objects, a few KB each, one PUT per object.

The math is brutal for small objects. PUT, COPY, POST and LIST requests on S3 Standard cost $0.005 per 1,000 in US East as of October 2026. That sounds like nothing until you're doing 400 million PUTs a month:

code
400,000,000 PUTs / 1,000 * $0.005 = $2,000

Two grand, just to write files, before storing a single byte of them long-term. The fix wasn't S3 config, it was the pipeline: batch the tiny records into larger objects. Aggregating into Parquet files of a few hundred MB, written every few minutes instead of one object per record, cuts request count by orders of magnitude, and that line item nearly vanishes.

The same trap hits reads, though more gently: GET and other Tier2 requests are $0.0004 per 1,000. A LIST-heavy job still bills at the Tier1 rate, because LIST is priced like PUT. A common offender is a service calling head_object before every get_object as a defensive existence check, doubling the request count for no real benefit.

The storage class that cost money instead of saving it

Someone had decided the pipeline output was "cold after write" and set the upload storage class to S3 Standard-IA. Reasonable on paper. The problem was the objects. Standard-IA has costs that Standard doesn't: a 128 KB minimum billable object size, a 30-day minimum storage duration, per-GB retrieval fees, and PUTs at $0.01 per 1,000, double the Standard rate. The data was millions of 4KB objects.

So every 4KB object was billed as if it were 128KB, 32x the storage we used, at a request rate twice as high, and anything deleted inside 30 days still billed for the full 30. The setting meant to save money was losing it on every axis.

Lifecycle rules have a version of the same trap. Since September 2024, S3 Lifecycle by default does not transition objects smaller than 128 KB to any storage class, because each transition is a billed request ($0.01 per 1,000 into Standard-IA, $0.02 into Glacier Instant Retrieval). Rules created before that date keep the old behavior until you edit them, and an explicit ObjectSizeLessThan or low ObjectSizeGreaterThan filter overrides the default. Write the size floor into every transition rule so the intent survives any edit:

JSON
{
  "Rules": [{
    "ID": "archive-large-cold-logs",
    "Status": "Enabled",
    "Filter": { "And": {
        "Prefix": "logs/archive/",
        "ObjectSizeGreaterThan": 131072
    }},
    "Transitions": [{
        "Days": 90,
        "StorageClass": "GLACIER_IR"
    }]
  }]
}

The ObjectSizeGreaterThan: 131072 filter transitions only objects above 128KB, so you never pay the small-object minimum. We also pushed the transition to 90 days and went to Glacier Instant Retrieval for data that's truly cold but occasionally needed; it has its own 90-day minimum, so don't send anything there you might delete sooner.

What each class actually charges

US East (N. Virginia) list prices as of October 2026:

ClassStorage per GB-monthPUT per 1,000Transition in per 1,000Min billable sizeMin duration
Standard$0.023 (first 50 TB)$0.005n/aNoneNone
Standard-IA$0.0125$0.01$0.01128 KB30 days
Intelligent-Tiering$0.023 frequent, $0.0125 infrequent$0.005$0.01NoneNone
Glacier Instant Retrieval$0.004$0.02$0.02128 KB90 days

Read the last two columns before the first one. The cheap storage rates only pay off for objects that are large and stay put.

Intelligent-Tiering is the safer default

For access patterns you can't predict, S3 Intelligent-Tiering moves objects between tiers automatically based on actual access, with no retrieval fees and no minimum storage duration. It charges a monitoring and automation fee of $0.0025 per 1,000 objects per month. Objects under 128 KB are not monitored and never move: they stay in the Frequent Access tier at Standard prices, with no monitoring fee, so it doesn't punish small objects but doesn't help them either. For a bucket of medium-to-large files with unknown access it removes the guesswork. We moved our user-upload bucket to it and stopped trying to hand-tune lifecycle rules for data whose access pattern we didn't actually understand.

Turn on the tooling that finds this

Two things we should have had from the start. S3 Storage Lens shows request patterns, object size distribution, and cost per bucket, and its object-size histogram would have flagged the millions-of-tiny-objects problem months earlier. And Cost Explorer grouped by usage type is the single query that separates storage cost from request cost from transfer cost:

Bash
aws ce get-cost-and-usage \
    --time-period Start=2026-06-01,End=2026-07-01 \
    --granularity MONTHLY \
    --metrics UnblendedCost \
    --group-by Type=DIMENSION,Key=USAGE_TYPE

That grouping is what showed us the cost was Requests-Tier1, not storage, in about thirty seconds. Without it we'd have spent a day guessing. If you want a bill spike to page someone instead of waiting for finance, AWS Cost Anomaly Detection catches this class of jump, and our S3 buckets and permissions tutorial covers the bucket basics if you're setting one up fresh.

Questions people ask

Why is my S3 bill high when storage didn't grow?

Because S3 bills requests, storage-class minimums, retrievals and data transfer separately from bytes stored. Group Cost Explorer by usage type and look for Requests-Tier1, Requests-Tier2, retrieval or DataTransfer-Out lines. A pipeline writing millions of small objects, or a service doing HEAD before every GET, can cost more than the storage itself at $0.005 per 1,000 PUTs.

Is S3 Standard-IA cheaper than Standard for small files?

No. Standard-IA bills every object under 128 KB as 128 KB, charges a 30-day minimum, doubles the PUT price to $0.01 per 1,000, and adds a per-GB retrieval fee. For a 4 KB object that is 32x the billed storage. Standard-IA only wins for objects well above 128 KB that you keep at least a month and rarely read.

Does S3 Intelligent-Tiering charge for small objects?

Objects smaller than 128 KB are not monitored, so they pay no monitoring fee, but they also never move out of the Frequent Access tier and bill at Standard rates. Larger objects pay $0.0025 per 1,000 objects per month (US East, October 2026) and move to cheaper tiers after 30 and 90 days without access.

The call we'd make

When an S3 bill jumps, do not assume it's storage. Open Cost Explorer grouped by usage type first, because the surprise is almost always requests or a storage-class minimum, not bytes stored. Fix request cost at the source by batching small objects rather than reaching for a fancy storage class. Only move data to IA or Glacier when objects are large and genuinely cold, and write ObjectSizeGreaterThan into every transition rule so you dodge the 128KB minimum even after someone edits the rule. For unpredictable access, let Intelligent-Tiering do the work instead of hand-tuning rules that, as we learned the expensive way, can cost more than they save.

Sources

Explore topics:AWSCloud
React
Share this post
Cite this article
Plain text

Kiril Urbonas (2026). S3 Cost Traps: Storage Classes, Requests, and the Surprise Bill. DevOpsNess. Updated 2026-10-31. https://www.devopsness.com/blog/s3-cost-traps-storage-classes-requests

Markdown

[S3 Cost Traps: Storage Classes, Requests, and the Surprise Bill](https://www.devopsness.com/blog/s3-cost-traps-storage-classes-requests) (Kiril Urbonas, DevOpsNess, updated 2026-10-31)

KU

Kiril Urbonas

Founder & Chief Editor

608 articles
View all articles by Kiril Urbonas

You might have missed

Evergreen posts worth revisiting.