What does S3 storage actually cost beyond per-GB-month?

A per-GB-month price is the line item engineers usually compare. For backups it rarely decides the bill. Backup buckets hold many objects, change on a schedule, and are read rarely but urgently. Those traits put weight on the per-object and per-event charges.

Cost component What triggers it Why it matters for backups
Storage per GB-month Bytes stored, by storage class The headline rate, and often not the deciding one
Intelligent-Tiering monitoring and automation Each monitored object, every month Scales with object count, not size
Lifecycle transition requests Each object moved to another class A one-time charge per object, paid on every transition
Retrieval fees Per GB, and per request in Glacier classes Arrives during a restore, when you can't defer it
Minimum storage duration Deleting or transitioning an object before the class minimum Short retention windows pay for days they never used
Minimum billable object size and per-object overhead Small objects in IA and Glacier classes Small files get billed as if they were larger

A rough monthly model is:

total ≈ (GB stored × storage rate) + (object count × per-object fees) + (objects transitioned × request rate) + (GB restored × retrieval rate) + early-deletion charges

Every term except the first depends on object count, object size distribution, retention period or restore frequency. Two buckets of the same size can therefore produce very different bills. Get these four inputs from your own inventory before you compare storage classes.

Prices vary by region and change over time. Take current figures from the S3 pricing page for your region, not from this or any other article.

How does it work? Two ways S3 moves backup data between storage classes

Every S3 object has a storage class, and the class sets its per-GB rate, retrieval behavior, minimum duration and per-object charges. Changing the class of existing objects is what reduces the storage bill. S3 offers two mechanisms for doing that automatically, and they decide when to move an object in different ways.

  • Intelligent-Tiering is a storage class. You write objects into it, either directly or through a lifecycle transition. Inside that class, S3 tracks when each object was last accessed and moves it between internal access tiers. Decisions are based on observed reads. You pay a monthly monitoring fee per object for the tracking.
  • Lifecycle rules are a bucket configuration. You attach rules that match objects by prefix, tag or size. Each rule states the object age at which a transition to another class happens, or at which the object expires. S3 evaluates the rules in the background and does not track reads. Decisions are based on age alone. You pay a request charge each time an object is transitioned.

Both mechanisms work on the same cost terms from the model above, but they put the cost in different places. Intelligent-Tiering adds a recurring per-object fee and charges no retrieval fees in its automatic tiers. Lifecycle rules into Glacier classes add a one-time per-object fee, then cut the per-GB rate further, and charge for restores. The two can be combined: a lifecycle rule can transition objects into Intelligent-Tiering, or expire objects that live in it.

The sections below cover each mechanism in detail, then compare the costs for backup data.

How does S3 Intelligent-Tiering work, and who is it for?

Intelligent-Tiering is a storage class that moves each object between access tiers based on how often it is actually read. Every object starts in the Frequent Access tier. If it goes 30 consecutive days without being accessed, S3 moves it to Infrequent Access. After 90 days without access it moves to Archive Instant Access, which still serves reads in milliseconds. When an object in either of the lower tiers is read, it moves back to Frequent Access. You don't configure any of these thresholds.

Two further tiers, Archive Access and Deep Archive Access, are opt-in. You enable them in a configuration on the bucket or on a prefix or tag filter, and you set how many days without access must pass before objects move there. Objects in these tiers can't be read directly. A GET fails until you issue a restore and wait for it to finish, which can take hours.

What you pay for

Objects smaller than 128 KB are not monitored and are never moved out of Frequent Access, so they get no savings from tiering. Larger objects carry a monitoring and automation fee, charged per 1,000 objects per month. That fee depends on object count, not size.

Why teams choose it

The automatic tiers charge no retrieval fees and need no tuning. That suits data with unpredictable access patterns. If a dataset is suddenly read heavily, the bill doesn't spike. Engineers also don't have to study access logs to write transition rules.

Enabling the archive tiers weakens that benefit. Applications have to handle failed reads and restore latency again, so the "no surprises" property is gone.

How do S3 lifecycle rules move backups into Glacier?

Lifecycle rules take the opposite approach. You tell S3 the age at which objects change class and the age at which they are deleted. S3 applies those rules on a schedule and does not look at access patterns. For backups this works well, because you already know the access pattern: a backup is written once and almost never read.

A rule's filter can match a key prefix such as db/nightly/, an object tag, or both. Use separate prefixes or tags for daily, weekly and monthly backups so each set can have its own retention. A rule can also include a size filter, which lets you skip tiny manifest files that would cost more in per-object transition fees than they save in storage.

A typical rotation schedule:

Age Action Reason
Day 30 Standard-IA Recent restores are still fast
Day 90 Glacier Flexible Retrieval Restores become rare and can wait hours
Day 180 Glacier Deep Archive Kept only for compliance
Day 365 Expire Retention period ends

Path of an object:

Upload (Standard) → 30d → Standard-IA → 90d → Glacier Flexible Retrieval → 180d → Deep Archive → 365d → deleted

Each class has a minimum storage duration. If you delete or transition an object before that duration ends, S3 still charges for the remaining days. Set the gaps between steps to at least those minimums.

In versioned buckets, expiring the current version only adds a delete marker. The old data remains as a noncurrent version and keeps incurring charges. Add noncurrent-version transitions and a noncurrent-version expiration, which can keep a fixed number of recent versions. Also remove expired delete markers so they don't accumulate.

cat > lifecycle.json <<'EOF'
{
  "Rules": [
    {
      "ID": "nightly-db-rotation",
      "Status": "Enabled",
      "Filter": { "And": { "Prefix": "db/nightly/", "ObjectSizeGreaterThan": 131072 } },
      "Transitions": [
        { "Days": 30,  "StorageClass": "STANDARD_IA" },
        { "Days": 90,  "StorageClass": "GLACIER" },
        { "Days": 180, "StorageClass": "DEEP_ARCHIVE" }
      ],
      "Expiration": { "Days": 365 },
      "NoncurrentVersionTransitions": [
        { "NoncurrentDays": 30, "StorageClass": "GLACIER" }
      ],
      "NoncurrentVersionExpiration": { "NoncurrentDays": 120, "NewerNoncurrentVersions": 3 }
    },
    {
      "ID": "nightly-db-delete-markers",
      "Status": "Enabled",
      "Filter": { "Prefix": "db/nightly/" },
      "Expiration": { "ExpiredObjectDeleteMarker": true },
      "AbortIncompleteMultipartUpload": { "DaysAfterInitiation": 7 }
    }
  ]
}
EOF

aws s3api put-bucket-lifecycle-configuration \
  --bucket example-backup-bucket \
  --lifecycle-configuration file://lifecycle.json

A lifecycle policy for db/nightly/ that skips files of 128 KB or less and moves backups through Standard-IA, Glacier Flexible Retrieval (GLACIER) and Deep Archive. It expires them at 365 days, prunes noncurrent versions and cleans up expired delete markers.

Why are backups a poor fit for Intelligent-Tiering?

Intelligent-Tiering is useful when you can't predict how objects will be accessed. Backups are the opposite case. You write them once, rarely read them, and delete them on a fixed retention schedule. On the day an object is uploaded, you already know it will sit untouched until a restore drill or an incident. Intelligent-Tiering charges a per-object monitoring fee every month to learn that pattern. A lifecycle rule states it up front for free, and it can move objects straight to a colder class on day one instead of waiting through the access-tracking period.

Object count drives the bill

Total size is only part of the cost. Monitoring fees are billed per object, lifecycle transition requests are billed per thousand objects, and each object moved to a Glacier class carries fixed metadata overhead that is billed regardless of how small the object is. Consider a backup job that writes a million 50 KB files instead of fifty 1 GB archives. Storage costs are roughly the same, but every per-object charge is twenty thousand times higher.

Intelligent-Tiering does not tier objects under 128 KB at all, so small files stay at the frequent-access rate. For tiny objects, a Glacier lifecycle transition plus the metadata overhead can cost more than leaving them in Standard for their whole retention period.

The fix is to bundle backups into large archives before uploading them. Use tar or your backup tool's native format, compress the data, and aim for objects in the hundreds of megabytes or larger. This keeps per-object charges negligible, so the per-GB rate becomes the number that actually determines your bill.

Illustrative estimate: total cost of ownership for a backup bucket

Illustrative estimate (assumed numbers, not a benchmark). Assume 10 TB of backups retained for 365 days, restored at 1% of data per month. Compare two layouts: 10,000,000 objects of 1 MB, or 10,000 bundled objects of 1 GB. Replace each placeholder (P_*) with the current price for your region.

Component Intelligent-Tiering Lifecycle to Flexible Retrieval / Deep Archive
Storage Σ(GB in tier × P_tier) GB × P_glacier + per-object metadata overhead
Per-object (objects ÷ 1,000) × P_monitor × months (objects ÷ 1,000) × P_transition, paid once
Retrieval None for the instant-access tiers GB restored × P_retr_GB + (requests ÷ 1,000) × P_retr_req
Early deletion Not applicable Remaining days of the minimum duration (90 / 180) × daily rate

With small objects, monitoring is 10,000 units × 12 months, or 120,000 × P_monitor per year. The lifecycle path pays 10,000 × P_transition once, and Glacier also adds per-object metadata overhead to 10 million objects. After bundling, the same terms drop to 120 and 10 units. That leaves storage rate as the main cost, and Glacier's lower per-GB price wins.

Now raise restores to 30% of data per month. The Glacier retrieval term scales linearly with restored GB, while Intelligent-Tiering charges nothing for retrieval from its instant-access tiers. At some restore rate the lines cross. To find it, solve for the restored GB where P_retr_GB × GB equals the storage savings. Deletion timing also matters. If backups expire before 90 or 180 days, the early-deletion term cancels the Glacier discount.

import json, sys

P = json.load(open(sys.argv[1]))  # keys are read below; all values are USD
GB_TOTAL, MONTHS, RETENTION_DAYS = 10_000, 12, 365
MIN_DAYS = 90  # 90 for Flexible Retrieval, 180 for Deep Archive

def annual_cost(objects, restore_frac):
    k = objects / 1000
    obj_gb = GB_TOTAL / objects
    # Intelligent-Tiering: a blended per-GB rate stands in for the tier mix, plus a monthly monitoring fee.
    # Restores from the instant-access tiers have no retrieval fee.
    it = (GB_TOTAL * P["it_blended_gb_month"] + k * P["it_monitor_per_1k_month"]) * MONTHS
    # Glacier: each object adds about 32 KB billed at the Glacier rate and 8 KB at the Standard rate.
    ovh_gl, ovh_std = objects * 32 / 1024**2, objects * 8 / 1024**2
    storage = ((GB_TOTAL + ovh_gl) * P["glacier_gb_month"] + ovh_std * P["standard_gb_month"]) * MONTHS
    transition = k * P["transition_per_1k"]  # charged once, when the lifecycle rule moves each object
    restored_gb = GB_TOTAL * restore_frac * MONTHS
    retrieval = (restored_gb * P["retr_per_gb"]
                 + restored_gb / obj_gb / 1000 * P["retr_per_1k_req"])
    # Ignored here: the temporary copy that a restore keeps in Standard storage.
    early = max(0, MIN_DAYS - RETENTION_DAYS) / 30 * GB_TOTAL * P["glacier_gb_month"]
    return it, storage + transition + retrieval + early

for objects in (10_000_000, 10_000):          # 1 MB objects vs 1 GB bundles
    for restore_frac in (0.01, 0.30):         # share of the data restored each month
        it, gl = annual_cost(objects, restore_frac)
        winner = "Intelligent-Tiering" if it < gl else "Lifecycle/Glacier"
        print(f"{objects:>10,} objs, {restore_frac:.0%}/mo: IT={it:,.2f}  Glacier={gl:,.2f}  -> {winner}")

savings = GB_TOTAL * (P["it_blended_gb_month"] - P["glacier_gb_month"]) * MONTHS
print(f"Break-even restored GB/year (ignoring request fees): {savings / P['retr_per_gb']:,.0f}")

This script applies the section's formulas (storage, monitoring, transitions, per-object Glacier overhead, retrievals and early deletion) to 1 MB versus 1 GB objects at restore rates of 1% and 30%. You supply placeholder prices for your region in a JSON file.

When should you avoid Glacier lifecycle rules for backups?

That cancellation only holds if the rule matches how backups are actually rotated, and lifecycle rules quietly assume a lot.

When restores are routine

A rule that moves backups to Glacier assumes they will rarely be read. Audits, environment migrations and debugging sessions that pull old snapshots break that assumption. Each restore pays retrieval and request fees, and teams often restore more than they need because they cannot easily tell which archive holds the data. If restores happen every month, the per-GB retrieval term can outgrow the storage savings, and Intelligent-Tiering, which charges no retrieval fees in its frequent and infrequent tiers, may cost less.

When the RTO is tight

Flexible Retrieval and Deep Archive restores are asynchronous. They take hours, and Deep Archive can take up to a day or two. If your recovery time objective is measured in minutes, archived backups cannot meet it, no matter how cheap they are to store.

When rotation and minimums don't line up

Objects deleted or overwritten before the minimum storage duration are billed for the full period. If a weekly full backup replaces the previous one, transitioning it to Deep Archive locks in 180 days of charges for data you keep for seven.

Versioned buckets have a related problem. Overwrites create noncurrent versions, and without a noncurrent-version expiration rule those versions keep accumulating storage charges indefinitely.

When rules are unreviewed

A wrong prefix filter, overlapping rules or an expiration set to days instead of weeks can silently delete backups. Treat lifecycle configuration as code. Review it, test it against a non-production bucket, and run scheduled restore drills. Those drills are the only way to confirm both the retrieval costs in your model and the RTO you have promised.

What are the alternatives to Intelligent-Tiering and Glacier lifecycle rules?

Intelligent-Tiering and lifecycle transitions are not the only options. Several simpler setups fit particular backup patterns better.

Upload directly to the target storage class

If you already know a backup belongs in a cold class, write it there at upload time instead of letting a lifecycle rule move it later. The CLI accepts a storage class on upload:

aws s3 cp backup-2026-11-10.tar.zst \
  s3://example-backup-bucket/db/monthly/backup-2026-11-10.tar.zst \
  --storage-class DEEP_ARCHIVE

This skips the transition request charge and the time spent in more expensive classes. The minimum storage duration starts at upload, and restores are just as slow as for transitioned objects. PUT requests into Glacier classes are priced differently from Standard PUTs, so check the request line items for your region. Many teams combine this with a lifecycle rule that only handles expiration.

Glacier Instant Retrieval

S3 Glacier Instant Retrieval (GLACIER_IR) has a lower per-GB rate than Standard-IA and serves reads in milliseconds, like Standard. It charges a per-GB retrieval fee and has a 90-day minimum storage duration. It suits backups that must be restorable within a tight RTO but are kept for months and rarely read. You can use it as a lifecycle target or upload into it directly.

Standard-IA or One Zone-IA with expiration only

For short retention, such as backups kept for a few weeks, Glacier minimums often cancel the discount. A single rule that transitions to Standard-IA (30-day minimum) or simply expires objects in Standard may cost less and needs no restore process. One Zone-IA stores data in a single Availability Zone. Use it only for copies you can regenerate or that already exist elsewhere, because losing that zone means losing the data.

Reduce what you store

The cheapest byte is the one you never upload. Incremental or deduplicating backup formats, compression and retention policies that keep fewer old full backups cut the GB term for every storage class. Bundling small files into larger archives, covered above, cuts the per-object terms. These changes stack with any tiering choice.

Keep everything in Standard

For small buckets, a bucket with Standard storage and an expiration rule can be the right answer. The difference between classes on a few hundred gigabytes may be smaller than the cost of designing, reviewing and testing a multi-step rotation.

How can this save engineering time?

Storage cost is only part of the total cost. The time engineers spend designing, reviewing and debugging storage configuration also counts, and both mechanisms can reduce it if you set them up deliberately.

  • Use Intelligent-Tiering where nobody owns the access pattern. For shared datasets, user uploads or logs that several teams read unpredictably, Intelligent-Tiering removes the need to analyze access logs, choose transition days and revisit them when usage changes. Leave the archive tiers off unless every reader can handle restores. Otherwise you swap analysis work for restore-handling work.
  • Write one lifecycle template per retention class, not per job. Standardize key prefixes or tags (for example daily, weekly, monthly) across all backup jobs. A new job then inherits the correct rotation by writing to the right prefix, and nobody has to write or review a new rule.
  • Keep lifecycle configuration in version control. Store the JSON next to the infrastructure code and apply it with aws s3api put-bucket-lifecycle-configuration from a reviewed pipeline. To detect manual changes, compare the live configuration from aws s3api get-bucket-lifecycle-configuration with the committed file. This turns a silent data-loss risk into an ordinary code review.
  • Bundle before upload. Fewer, larger objects make costs predictable enough that you rarely need to model per-object fees or filter out small files. Restores also become simpler, because you track one archive per backup run instead of millions of keys.
  • Automate restore drills. A scheduled job that restores a known backup, verifies it and records the elapsed time checks both RTO and retrieval cost without anyone doing it by hand. It also catches broken rules before an incident does.
  • Stop optimizing when the savings are small. Estimate the possible savings with the cost model above using your own inputs, and compare them with the hours needed to implement and test the change. If the difference is a rounding error on your bill, the simplest configuration that meets retention and RTO is the better use of time.

Which should you choose: lifecycle rules, Intelligent-Tiering, or both?

Base the decision on how predictable the access pattern is. A scheduled backup has a known access pattern: it is written once, rarely read, and deleted on a fixed retention date. A lifecycle rule can encode that schedule directly, with no monitoring fee. Intelligent-Tiering is useful when you cannot predict the access pattern, because it adjusts to observed reads instead of relying on your guesses.

Data Recommended approach Why
Scheduled database or volume backups Lifecycle rules (transition to Glacier, then expire) Age-based access pattern is known; no per-object monitoring fee
User uploads, shared datasets Intelligent-Tiering Access is unpredictable, and Intelligent-Tiering has no retrieval fees in its automatic tiers
Large, long-lived objects with unclear access Intelligent-Tiering Monitoring fee is small relative to each object's storage cost
Unknown-access data with a retention policy Write to Intelligent-Tiering, expire with a lifecycle rule Tiering handles access, and the lifecycle rule handles deletion

Also count engineering time. On a small bucket, hand-tuning transition days can cost more in review and restore testing than it saves in storage.

Check your choice against your own bill:

  • Storage class analysis shows how often objects are accessed as they age. Use it to set transition days from observed data.
  • S3 Storage Lens shows bytes and object counts by storage class. These numbers reveal small-object buckets, where per-object charges add up.
  • Cost and Usage Report data breaks spend into storage, requests, transitions, monitoring, and retrieval line items.

Repeat this review periodically. Prices and tier behavior change over time and vary by region, so a configuration that was optimal last year may no longer be.

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to s3 intelligent tiering cost, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • Changing a shared variable is one edit and one review instead of editing every service's .env by hand.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • A wrong or stale value is caught at review time by the services it affects, not by a failed deploy.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.