DynamoDB caching on ElastiCache: what changes vs DAX
AWS made DynamoDB caching with ElastiCache Serverless for Valkey generally available on November 17, 2026. What it does, its limits and how to trial it.
On November 17, 2026, AWS announced DynamoDB caching with Amazon ElastiCache Serverless for Valkey as generally available. AWS describes it as a serverless alternative to DynamoDB Accelerator (DAX): a write-through cache for sub-millisecond reads of hot DynamoDB data, with no cache nodes to manage. If a few hot keys or read-heavy tables drive your DynamoDB bill or throttling, it is worth a trial. If your reads are already cheap, or you depend on strongly consistent reads, you can skip it.
What was announced, and what is different?
AWS says the feature is available in all commercial AWS Regions and AWS GovCloud (US) Regions, and that it is offered at no additional cost: you pay for the ElastiCache Serverless and DynamoDB resources you use.
The ElastiCache documentation explains the mechanism. You do not change your DynamoDB calls. You install the ElastiCache integration client in your application, and it routes cacheable requests to a serverless Valkey cache. Requests for tables you did not configure, or for unsupported APIs, go straight to DynamoDB.
- 1SDK call
- 2Integration client
- 3Valkey cache
- 4DynamoDB on a miss
Based on the ElastiCache documentation, November 2026. A hit returns from the cache; a miss reads DynamoDB and stores the result.
AWS positions this as the serverless alternative to DAX. What the announcement states is that the cache scales with demand and has no cache nodes to provision or manage, and the documentation says the application change is a client library configured at startup, not new cache logic. We do not compare it with DAX feature by feature or on price here: check AWS's DAX documentation and pricing for your Region.
How does it behave?
As of November 2026, the documentation says:
- Supported APIs: GetItem, BatchGetItem, Query, Scan, PutItem, UpdateItem, DeleteItem, BatchWriteItem, TransactGetItems and TransactWriteItems.
- Consistency: cached results are returned for eventually consistent reads. A request with
ConsistentReadset to true goes through to DynamoDB, and the result refreshes the cache. Transaction results are stored as individual item entries, with no transactional consistency guarantee. - Freshness: entries expire after a TTL. The default is 5 minutes, and you can set 1 to 86,400 seconds.
- Writes: writes go to DynamoDB first, then cached projections of the item are updated or invalidated, depending on the API.
- Fallback: if the cache is unavailable or times out, the client falls back to DynamoDB. The configuration page lists a 5-second request timeout and a 2-second reconnect timeout as defaults, and says a
fallback_durationof zero disables fallback. - Negative caching: a lookup for a missing item is cached for 60 seconds by default.
The catch is in query and scan entries. The documentation says updates to item data are not automatically reflected in cached query or scan results. To get the latest data, run that query with ConsistentRead set to true.
Who should care, and who can ignore it?
Care if:
- A small set of hot items causes read throttling. The overview page says caching can help reduce the impact of throttling from high read activity on hot keys.
- The same items are read far more often than they change, and a few minutes of staleness is acceptable.
- You wanted a cache but did not want to run DAX nodes or write cache-aside code.
Ignore it if:
- Your reads must be strongly consistent. They are always read from DynamoDB, not served from the cache.
- Your read traffic is spread across millions of keys with little repetition. The hit rate will be low.
- Your DynamoDB spend is small. The cache adds its own cost.
What does it cost, and what are the limits?
There is no extra charge for the feature, but the cache is not free. The billing page says you pay for the memory that holds cached projections, queries and scans, including overhead, and for ElastiCache Processing Units (ECPUs). One ECPU is used for each 1 KB of processed data.
| Request | ECPUs used |
|---|---|
| Cache hit | 1 × (entry size in KB + overhead) |
| Cache miss | 2 × (entry size in KB + overhead) |
| Write | 1 × (write size in KB + overhead) + sum(updated entry sizes in KB + overhead) |
Each distinct projection of an item is its own cache entry. So an item cached with several projections costs more memory, and more ECPUs on writes that refresh the cache.
The ElastiCache pricing page uses, in its us-east-1 Valkey example as of November 2026, $0.084 per GB-hour of data storage and $0.0023 per million ECPUs. Check your own Region before you estimate.
Documented limits, as of November 2026:
- It needs ElastiCache Serverless for Valkey version 9 or later. Node-based clusters are not supported.
- You must enable it when you create the serverless cache. You cannot enable it on an existing cache.
- You cannot disable it on a cache that has it. The getting started page says you would create a new cache from a backup.
How would a team try it safely this week?
- Pick one read-heavy table with a clear hot-key pattern. Use your DynamoDB metrics to find it.
- Create a new serverless Valkey 9 cache with the DynamoDB integration. The getting started page's CLI example passes
--integrations IntegrationType=DYNAMODB. - Install the integration client in one service, in staging, and configure only that table with a short TTL.
- Replay realistic traffic. Compare hit rate, latency and ECPU use against the DynamoDB read cost you avoided.
- Test the failure path. Make the cache unreachable and confirm the fallback behaves as you expect.
What would we check first?
We start with the questions the feature cannot answer for you:
- Staleness: which screens or API calls can show data that is minutes old, and which cannot?
- Query and scan entries: do you rely on cached queries? If so, how do you force a refresh after a write?
- Hit rate: a cache that rarely hits adds ECPU and storage cost on top of the DynamoDB read you still pay for.
- Fallback load: if the cache fails, can DynamoDB take the full read traffic without throttling?
- Irreversibility: you cannot turn the feature off on a cache, so use a dedicated cache for the trial.
If you want help weighing this against your AWS bill, see our services.
This article is general information, not financial or architecture advice. Prices and limits change, so confirm them in AWS's current documentation before you decide.