What actually drives your S3 bill beyond the per-GB price?

The per-GB-month price on the pricing page is only one of several meters. A bucket's bill is the sum of four, and the cheaper storage classes lower the first while raising the others.

Cost component What triggers it What it scales with
Storage Bytes held per month Total GB × storage class rate
Requests PUT, COPY, LIST, GET, and each lifecycle transition Object count, not size
Retrieval Reading from infrequent-access or archive classes GB read back, plus restore requests
Minimums Deleting or transitioning early, or storing small objects Minimum storage duration and minimum billable size per class

The minimums are where estimates usually go wrong. Standard-IA and One Zone-IA bill each object as at least 128 KB and for at least 30 days. The Glacier classes have longer minimum durations: 90 days for Instant and Flexible Retrieval, and 180 days for Deep Archive. If you delete or overwrite an object before its minimum, you still pay the remaining days.

That is why object size, object count and retention length decide whether tiering saves money:

  • Object size: a million 10 KB objects are a small number of gigabytes. They produce a million transition requests, and in IA they may be billed at the 128 KB minimum.
  • Object count: transition and request charges scale with the number of objects, not with how much data those objects hold.
  • Retention length: data retained for a long time, at volume, is where tiering pays off.

Tiering means moving objects to classes with a lower storage rate and higher access costs. It reduces S3 costs only when the storage savings over each object's lifetime exceed the extra request, retrieval and minimum-duration charges. The later sections compare the two ways to do it: lifecycle rules that you write and Intelligent-Tiering that S3 manages.

How do S3 lifecycle rules work and what savings do teams miss?

A lifecycle rule is a schedule keyed on object age. You declare that objects matching a filter move to another storage class after N days, or expire after M days. S3 evaluates rules asynchronously and never looks at whether anyone read the object. A file fetched every hour on day 31 still moves to Standard-IA if the rule says 30 days, and each of those reads then incurs a retrieval charge. Each transition is billed as a request per object, so moving millions of small objects can cost more in requests than it saves in storage.

Filters scope rules by prefix, object tags, or both. That scoping is also the main operational risk. If a service changes its key layout from logs/2024/... to tenant-id/logs/..., the old prefix rule matches nothing new and nothing warns you. Tag-based rules fail the same way when a writer stops setting the tag. Re-check rule coverage whenever key schemas or upload code change.

Teams commonly miss two kinds of savings:

  • Noncurrent versions. On a versioned bucket, overwrites and deletes keep the old versions at full Standard price indefinitely. Use NoncurrentVersionTransition and NoncurrentVersionExpiration (keyed on days since the version became noncurrent) to cap that storage.
  • Incomplete multipart uploads. Abandoned parts are billed as storage but are not listed as objects. AbortIncompleteMultipartUpload with a few DaysAfterInitiation removes them.

The example that follows applies a Standard → Standard-IA → Glacier rule with both of these clauses using aws s3api put-bucket-lifecycle-configuration. That call replaces the bucket's entire lifecycle configuration, so include any existing rules in the file you apply, or they will be removed.

#!/usr/bin/env bash
set -euo pipefail
BUCKET="example-app-logs"   # placeholder bucket name

# Back up the current config first: put-bucket-lifecycle-configuration REPLACES all rules.
aws s3api get-bucket-lifecycle-configuration --bucket "$BUCKET" > lifecycle-backup.json || true

# Rule 1: age-based tiering for logs/ only. It ignores access patterns entirely.
# Rule 2: empty filter, so stale multipart parts are cleaned up bucket-wide, not just under logs/.
cat > lifecycle.json <<'EOF'
{
  "Rules": [
    {
      "ID": "logs-age-tiering",
      "Status": "Enabled",
      "Filter": { "Prefix": "logs/" },
      "Transitions": [
        { "Days": 30, "StorageClass": "STANDARD_IA" },
        { "Days": 90, "StorageClass": "GLACIER" }
      ],
      "Expiration": { "Days": 365 },
      "NoncurrentVersionTransitions": [
        { "NoncurrentDays": 30, "StorageClass": "GLACIER" }
      ],
      "NoncurrentVersionExpiration": { "NoncurrentDays": 180 }
    },
    {
      "ID": "abort-stale-multipart",
      "Status": "Enabled",
      "Filter": {},
      "AbortIncompleteMultipartUpload": { "DaysAfterInitiation": 7 }
    }
  ]
}
EOF

aws s3api put-bucket-lifecycle-configuration --bucket "$BUCKET" --lifecycle-configuration file://lifecycle.json
# Confirm what S3 actually stored.
aws s3api get-bucket-lifecycle-configuration --bucket "$BUCKET"

A lifecycle config that tiers logs/ by age from Standard to Standard-IA to Glacier, moves and expires noncurrent versions, and aborts stale multipart uploads bucket-wide, applied and verified with the AWS CLI.

How does S3 Intelligent-Tiering work?

Intelligent-Tiering moves each object between access tiers based on observed access, so you don't have to predict access patterns in a lifecycle rule. An object that goes 30 consecutive days without access moves from Frequent Access to Infrequent Access. After 90 days without access it moves to Archive Instant Access. Any GET moves it back to Frequent Access. The automatic tiers charge no retrieval fees, so a surprise re-read costs only the normal request price.

PUT ──► Frequent ──30d idle──► Infrequent ──90d idle──► Archive Instant ──(opt-in)──► Archive Access ──(opt-in)──► Deep Archive (any GET returns the object to Frequent; the opt-in tiers require a restore first)

S3 charges a monthly monitoring fee for each monitored object, priced per 1,000 objects. Objects under 128 KB are not monitored and never tier down. They stay billed at the Frequent Access rate with no monitoring fee, so a bucket of small objects gains nothing from this storage class.

The Archive Access and Deep Archive Access tiers are off by default. You enable them per bucket, or per prefix or tag filter, with an Intelligent-Tiering configuration. After an object lands in one of these tiers, a GET fails with InvalidObjectState until a RestoreObject request completes. A restore takes hours. Any application that assumes synchronous reads will break on these objects. Enable the archive tiers only on prefixes whose readers already handle restores.

The code example that follows uploads an object with --storage-class INTELLIGENT_TIERING. It then enables Archive Access for one prefix using aws s3api put-bucket-intelligent-tiering-configuration.

#!/usr/bin/env bash
set -euo pipefail

BUCKET="example-logs-bucket"

# 1. Upload directly into Intelligent-Tiering. Frequent, Infrequent and
#    Archive Instant tiering happens automatically. No configuration needed.
aws s3 cp ./report-2026-11.parquet \
  "s3://${BUCKET}/reports/report-2026-11.parquet" \
  --storage-class INTELLIGENT_TIERING

# 2. Opt in to Archive Access, scoped to one prefix only. Readers of
#    this prefix must already handle RestoreObject. A GET on an archived
#    object fails with InvalidObjectState until the restore completes.
#    Days counts consecutive days without access. The minimum for
#    ARCHIVE_ACCESS is 90.
aws s3api put-bucket-intelligent-tiering-configuration \
  --bucket "${BUCKET}" \
  --id archive-old-reports \
  --intelligent-tiering-configuration '{
    "Id": "archive-old-reports",
    "Filter": { "Prefix": "reports/" },
    "Status": "Enabled",
    "Tierings": [
      { "Days": 90, "AccessTier": "ARCHIVE_ACCESS" }
    ]
  }'

# 3. Confirm the configuration that was applied.
aws s3api get-bucket-intelligent-tiering-configuration \
  --bucket "${BUCKET}" --id archive-old-reports

# 4. Later, to read an archived object, request a restore first.
#    Archived Intelligent-Tiering objects take no Days value. The object
#    returns to Frequent Access once the restore finishes.
aws s3api restore-object \
  --bucket "${BUCKET}" \
  --key reports/report-2026-11.parquet \
  --restore-request '{}'

Uploads an object into S3 Intelligent-Tiering, enables the opt-in Archive Access tier for the reports/ prefix only, and shows the restore call that must complete before an archived object can be read again.

S3 Intelligent-Tiering vs lifecycle: a worked illustrative estimate

Before turning on either option for a whole bucket, price it against your own inventory. The inputs below are invented to show the arithmetic.

Illustrative estimate (assumed numbers, not a benchmark). Assume 100 TB stored for 12 months and an average object size of 4 MB, which gives about 25 million objects. Assume 10% of the data is re-read after day 30. Every P_* value is a placeholder. Replace each one with current pricing for your region before you trust any total.

The lifecycle rule moves objects to Standard-IA at day 30 and to a Glacier class at day 90. In Intelligent-Tiering, objects that go unread move down through the access tiers on their own.

Line item Standard only Lifecycle (IA → Glacier) Intelligent-Tiering
Storage GB × months × P_std GB-months spent in each class × that class's price GB-months spent in each tier × that tier's price
Transitions none objects × P_trans_ia + objects × P_trans_gl none billed per move
Monitoring none none objects × months × P_mon
Retrieval none re-read GB × P_ret_ia or P_ret_gl, plus restore requests none for the instant-access tiers
Requests GETs × P_get_std GETs × each class's GET price GETs × P_get_std

The object count matters as much as the terabytes. Transition fees and monitoring fees are charged per object, not per GB. At 25 million objects, those lines can be a large share of the total.

To compare two options, calculate:

Net saving = storage delta − (transition + monitoring + retrieval + extra request costs)

Run the formula twice: once at your expected re-read rate and once at double that rate. If the result changes sign between the two runs, the decision depends on access patterns you haven't measured yet. In that case, Intelligent-Tiering is the lower-risk default because it does not charge retrieval fees on its instant-access tiers.

When should you avoid tiering? Small objects, early deletes and re-reads

Tiering costs are charged per object, while savings scale with bytes. A lifecycle transition is billed as a request for each object it moves. Intelligent-Tiering charges a monthly monitoring fee per object. If a bucket holds hundreds of millions of 20 KB log fragments, those per-object charges can exceed the per-GB savings. Intelligent-Tiering does not auto-tier objects under 128 KB, so tiny objects stay in the frequent tier and get no savings. Glacier Flexible Retrieval and Deep Archive also add per-object metadata overhead, and part of it is billed at Standard rates. The usual fix is to compact first: batch small files into larger archives or Parquet files, then tier the result.

Early deletes also cost money. Standard-IA, One Zone-IA and the Glacier classes have minimum storage durations. If you delete an object before that period ends, you pay for the remaining days. An overwrite counts as a delete. The IA classes also bill a minimum object size.

Re-reads can erase a year of savings. Audits, backfills and ML retraining jobs often scan old data in bulk. Every GB they read from IA or Glacier Instant Retrieval incurs retrieval fees. Data in Flexible Retrieval or Deep Archive must be restored before it can be read at all.

Avoid this approach when… Lifecycle rules Intelligent-Tiering
Most objects are tiny Transition requests cost more than they save Objects under 128 KB are never tiered
Objects are short-lived or rewritten Minimum-duration charges apply Monitoring fees are paid for little benefit
Bulk re-reads are likely Retrieval fees spike Archive tiers you opt into still need restores

Which Glacier class should you choose, and what does restore time cost you?

Class First byte Retrieval model Minimum storage duration
Glacier Instant Retrieval Milliseconds Direct GET, per-GB retrieval fee 90 days
Glacier Flexible Retrieval Minutes (expedited) to hours (standard, bulk) Restore request, then GET 90 days
Glacier Deep Archive Hours (up to about 12 standard, 48 bulk) Restore request, then GET 180 days

Instant Retrieval behaves like any other storage class. Your application reads the object directly and pays a per-GB fee. The two restore-based classes don't work that way. A GET on an unrestored object fails until a restore completes, and the restored copy is a temporary object billed at Standard rates for the number of days you request.

Treat restore time as an availability requirement. During an incident, "the logs exist" doesn't help if the investigation has to wait 12 hours to read them. Before you archive anything, ask: what is the longest you can wait for this data while production is down? If the answer is minutes, Deep Archive is the wrong class, however cheap the per-GB price.

The workflow also costs engineering time. With the AWS CLI, aws s3api restore-object takes a bucket, a key, and a restore request that sets the number of days and the retrieval tier. After that you poll head-object until the restore status shows complete. You need tooling for bulk restores, completion tracking, retries, and cleanup when the temporary copies expire.

Illustrative estimate (assumed numbers, not a benchmark). Monthly archive cost = (GB stored × archive rate) + (GB restored × retrieval rate) + (GB restored × Standard rate × restore days ÷ 30) + request fees. Plug in your own region's prices and expected restore volume before you pick a class.

#!/usr/bin/env bash
# Restore one archived object from Glacier Flexible Retrieval or Deep Archive,
# wait until it is readable, then download it.
set -euo pipefail

BUCKET="example-incident-logs"
KEY="app/2024/03/15/api-gateway.log.gz"
DAYS=3            # How long the temporary copy lives (billed at Standard rates)
TIER="Standard"   # Expedited | Standard | Bulk (Deep Archive has no Expedited)

# Start the restore. A repeat request while one is running fails with
# RestoreAlreadyInProgress, so treat a failure here as non-fatal and poll anyway.
aws s3api restore-object \
  --bucket "$BUCKET" \
  --key "$KEY" \
  --restore-request "Days=${DAYS},GlacierJobParameters={Tier=${TIER}}" \
  || echo "restore-object failed (possibly already in progress); polling status"

# Poll the Restore header. ongoing-request="true" means still restoring.
# ongoing-request="false" means the temporary copy is ready to read.
while true; do
  status=$(aws s3api head-object --bucket "$BUCKET" --key "$KEY" \
    --query Restore --output text)
  echo "$(date -u +%H:%M:%S) restore status: $status"
  if [[ "$status" == *'ongoing-request="false"'* ]]; then
    break
  fi
  sleep 300   # Standard-tier restores take hours, so poll sparingly
done

# The object is now readable with a normal GET until the expiry date.
aws s3api get-object --bucket "$BUCKET" --key "$KEY" ./api-gateway.log.gz

A minimal restore workflow for one object using the AWS CLI. It requests a temporary copy with a chosen tier and lifetime, polls head-object until the Restore status shows the copy is ready, and only then reads the object.

How do you choose between lifecycle rules and Intelligent-Tiering, and verify the savings?

Before choosing a policy, measure access per prefix. Bucket-level averages hide the pattern that matters. Storage Class Analysis reports how often objects of a given age are read, and server access logs show which keys are actually fetched. Use the measured access pattern to pick the mechanism:

Access pattern (measured) Mechanism Why
Predictable decay with age (logs, backups) Lifecycle transitions + expiration No per-object monitoring fee; you already know the timing
Unknown or shifting access Intelligent-Tiering It reacts to actual reads instead of a guessed schedule
Active data with a known retention limit Intelligent-Tiering + lifecycle expiration Tiering handles the reads, expiration handles deletion
Small or short-lived objects Stay on Standard Transition and monitoring fees exceed the storage savings

Ownership belongs with the platform team. They should define policies as code and review them alongside bucket configuration, while service teams declare a retention class for each prefix. This replaces the recurring manual cleanup work of listing old objects, scripting deletes and arguing about what is safe to remove. Each rule then runs indefinitely without anyone spending more time on it.

To verify the savings, track three things in your billing data:

  • Storage by class. Bytes should shift out of Standard over the following weeks.
  • Request counts. Expect a spike in transition requests in the first month as the backlog moves. If the spike stays high afterward, a rule is probably catching objects it shouldn't, such as small or short-lived ones.
  • Retrieval charges. These show whether "cold" data is in fact being read.

Finally, recheck rule scoping whenever key layouts change. Renaming a prefix silently takes new objects out of a rule's scope, or puts them into the wrong one.

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 vs lifecycle, 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.