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

URL: https://www.devopsness.com/blog/s3-cost-traps-storage-classes-requests
Author: Kiril Urbonas
Published: 2026-07-03
Updated: 2026-10-31
Categories: Cloud
Tags: AWS, S3, Cost Optimization, Storage

Summary: 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.

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

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]
> 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:

```
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:

| Class | Storage per GB-month | PUT per 1,000 | Transition in per 1,000 | Min billable size | Min duration |
|---|---|---|---|---|---|
| Standard | $0.023 (first 50 TB) | $0.005 | n/a | None | None |
| Standard-IA | $0.0125 | $0.01 | $0.01 | 128 KB | 30 days |
| Intelligent-Tiering | $0.023 frequent, $0.0125 infrequent | $0.005 | $0.01 | None | None |
| Glacier Instant Retrieval | $0.004 | $0.02 | $0.02 | 128 KB | 90 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](/blog/aws-cost-anomaly-detection) catches this class of jump, and our [S3 buckets and permissions tutorial](/blog/aws-s3-tutorial-buckets-permissions) 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

- [Amazon S3 pricing](https://aws.amazon.com/s3/pricing/)
- [Amazon S3 User Guide: Understanding and managing storage classes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html)
- [Amazon S3 User Guide: Transitioning objects using S3 Lifecycle](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-transition-general-considerations.html)

