On November 17, 2026, AWS announced general availability of DynamoDB caching, a new feature of Amazon ElastiCache Serverless for Valkey. It places a managed write-through cache in front of DynamoDB tables, so frequently read items can come back in under a millisecond without the team building its own caching layer.
The interesting part is how little code changes. Applications keep calling the normal DynamoDB APIs through the AWS SDK, and a small integration client decides which calls go to the cache. For teams that have been hand-writing cache-aside logic around DynamoDB, or running a separate accelerator, this is a new option worth a close look.
What AWS Released
DynamoDB caching is switched on when you create an ElastiCache Serverless cache running Valkey 9 or later. Your application then loads the ElastiCache integration client library, tells it which tables to cache and how long entries should live, and carries on calling DynamoDB as before.
According to the announcement and the ElastiCache user guide, the main points are:
- Sub-millisecond reads for cached items, plus fewer throttled requests when a handful of hot keys receive most of the read traffic.
- Write-through behavior: writes go to DynamoDB first, and cached copies of the item are refreshed after DynamoDB accepts the change.
- Serverless scaling with no nodes to size or patch.
- Access through the application's own IAM credentials, so existing DynamoDB permissions keep applying.
- Availability in all commercial AWS Regions and the AWS GovCloud (US) Regions.
- No separate charge for the feature itself; you pay for the ElastiCache Serverless and DynamoDB usage it creates.
How DynamoDB Caching Works
The integration client sits inside the SDK client. When a request hits a cache-enabled table through one of the covered operations, it is sent to the serverless cache. Anything else goes straight to DynamoDB as usual.
Ten DynamoDB APIs are supported: GetItem, BatchGetItem, PutItem, UpdateItem, DeleteItem, BatchWriteItem, Query, Scan, TransactGetItems and TransactWriteItems. On a hit the cached result is returned; on a miss the cache reads from DynamoDB, hands the result back and stores it with the configured time-to-live.
The cache keeps three kinds of entries. Item entries are keyed by table and primary key, and each distinct projection expression is stored as its own field. Query and scan results are stored as one entry per unique request.
Several behaviors matter for correctness:
- Writes refresh item entries, but they do not touch cached Query or Scan results. Setting ConsistentRead to true forces a fresh read from the table and updates the cache.
- Only eventually consistent reads are answered from the cache. Strongly consistent reads always pass through to DynamoDB.
- Results from transaction APIs are cached as separate items, without transactional guarantees across them.
- The default TTL is five minutes and can range from one second to one day. Lookups for missing items are cached too (negative caching) for 60 seconds by default, and this can be turned off per table.
- If the cache is unreachable or times out, the client falls back to DynamoDB and returns to the cache once it is healthy again.
Security and Cost Details
Connections use TLS, and the cache accepts only IAM authentication, not passwords. Besides the usual DynamoDB read and write actions, the calling identity must also be allowed the elasticache:Connect action for that serverless cache.
The documentation carries one warning that deserves attention. Any principal that can read from the cache can read data that other requests cached, even if it has no rights on the source table. AWS points to role-based access control in ElastiCache as the way to narrow this.
On billing, a cache hit uses ECPUs roughly equal to the entry size in kilobytes plus overhead, while a miss costs about double. Writes are charged for the write and for every cached entry they refresh, and each cached projection takes its own storage. Items read with many different projections therefore cost more to keep fresh.
What It Means for Developers
For read-heavy DynamoDB workloads such as product catalogs, user profiles or session lookups, this removes a lot of glue code. You no longer need to write invalidation logic by hand, and the caching rules live in one configuration block at startup instead of being spread through the data access layer.
It is not a fit for every workload. Code that needs strongly consistent or transactional reads gets no benefit, and pages built from Query or Scan results can show stale data until the TTL runs out. Pick TTL values per table based on how old a value your users can tolerate.
Plan ahead: the feature has to be chosen at the moment the serverless cache is built, cannot be added to an existing cache, cannot be switched off later, and is not available on node-based ElastiCache clusters.
Keep projection expressions consistent across your code, because each variant becomes a separate entry with its own storage and refresh cost.
If you already use ElastiCache Serverless for Valkey, see our earlier story on search aggregations in ElastiCache Serverless for Valkey. Teams loading large datasets may also find our report on DynamoDB bulk imports from S3 useful.
How to Get Started
Create a new Valkey serverless cache with engine version 9 or later, either in the ElastiCache console under the Integrations section or with the AWS CLI create-serverless-cache command and the DYNAMODB integration type. Then add the integration client for your language, which AWS publishes on GitHub, to your application.
Grant the application's role the elasticache:Connect permission and review who else can read the cache. Start with a single hot table, watch hit rates and ECPU use, and widen the setup once the numbers look right.
Conclusion
DynamoDB caching gives AWS developers a managed, write-through cache that needs almost no code changes and bills only for the resources it uses. It suits read-heavy tables with eventually consistent access, as long as teams plan for stale query results, the shared-read permission model and the fact that the setting is fixed when the cache is created.
Sources
- AWS What's New: Amazon DynamoDB caching is now available with Amazon ElastiCache Serverless for Valkey
- Amazon ElastiCache User Guide: DynamoDB caching
- Amazon ElastiCache User Guide: How DynamoDB caching works
- Amazon ElastiCache User Guide: Getting started with DynamoDB caching
- Amazon ElastiCache User Guide: Security in DynamoDB caching
- Amazon ElastiCache User Guide: Billing for DynamoDB caching
See my articles more often when you search Google.
