AWSAmazon ElastiCacheDatabase

`aws_elasticache_serverless_cache` cost estimation

A serverless Redis or Valkey cache that scales automatically. Priced per GB-hour of data stored plus per million ElastiCache Processing Units (ECPUs).

An aws_elasticache_serverless_cache removes node management entirely: it scales capacity up and down with demand and bills only for what you use. That makes its cost model completely different from node-based ElastiCache, two usage meters instead of node-hours.

The first meter is data stored, billed per GB-hour at roughly $0.125/GB-hour, with a 1 GB minimum. The second is ElastiCache Processing Units (ECPUs), a normalized unit covering reads and writes, billed at roughly $0.0034 per million ECPUs. A simple GET on a small item is about 1 ECPU; larger items and writes cost more. There are no nodes, shards, or replicas to size.

c3x prices serverless ElastiCache from the stored-GB and ECPU figures you supply in c3x-usage.yml, applying the 1 GB storage minimum. The break-even against node-based clusters is roughly 70% utilization: below that, serverless is usually cheaper because you're not paying for idle node capacity; above it, provisioned nodes win.

Terraform example

A minimal but realistic configuration that C3X can estimate.

resource "aws_elasticache_serverless_cache" "sessions" {
  engine = "redis"
  name   = "sessions"

  cache_usage_limits {
    data_storage {
      maximum = 10
      unit    = "GB"
    }
    ecpu_per_second {
      maximum = 5000
    }
  }
}

Pricing dimensions

What you actually pay for when you provision aws_elasticache_serverless_cache.

Dimension	Unit	What's being charged
Data stored	per GB-hour	Average data stored, billed hourly with a 1 GB minimum. c3x assumes 730 hours/month. Usage-based. $0.125/GB-hour
ECPUs	per million ECPUs	Normalized read/write processing units. A small GET is ~1 ECPU; writes and larger items cost more. Usage-based. $0.0034 per million ECPUs

Sample C3X output

Example output from c3x estimate (5 GB stored, 2B ECPUs/month):

aws_elasticache_serverless_cache.sessions
├─ Data stored (5 GB)       3,650  GB-hours       $456.25
└─ ECPUs                     2,000  M-ECPUs          $6.80

OVERALL TOTAL                                     $463.05

Optimization tips

Common ways to reduce aws_elasticache_serverless_cache cost without changing the workload.

Use serverless below ~70% utilization

Idle capacity vs nodes

Serverless avoids paying for idle node capacity, so it's usually cheaper for spiky or low-average workloads. Above sustained ~70% utilization, provisioned nodes (aws_elasticache_replication_group) cost less.

Set data-storage limits to cap spend

Tail-risk control

The cache_usage_limits block bounds maximum stored GB and ECPU/sec. Setting realistic ceilings prevents a runaway workload from scaling the bill unexpectedly.

Reduce ECPUs with larger, fewer operations

ECPU volume

ECPU cost scales with operation count and item size. Pipelining and fetching batches instead of many small GETs lowers the ECPU meter for chatty workloads.

FAQ

How does c3x estimate serverless ElastiCache cost?

It prices the data-stored GB-hours (with a 1 GB minimum) and the ECPU meter from the figures you supply in c3x-usage.yml. There are no nodes to size, so the estimate is purely the two usage dimensions.

When is serverless cheaper than provisioned nodes?

Below roughly 70% sustained utilization. Serverless bills only for stored data and ECPUs used, so for spiky or low-average traffic you avoid paying for idle node capacity. For steady high load, provisioned nodes are cheaper.

What is an ECPU?

An ElastiCache Processing Unit, a normalized measure of read/write work. A small GET is about 1 ECPU; larger items and writes consume more. You're billed per million ECPUs.