DynamoDB Change Data Capture (CDC): Which Option Should You Use?

Written by Rafal Wilinski
Published: November 20th, 2026
DynamoDB change data capture (CDC) gives downstream systems a way to react to item inserts, updates, and deletes. Start with DynamoDB Streams for near-real-time events, add EventBridge Pipes for managed filtering and routing, or choose Kinesis Data Streams for longer replay and independent consumers. Use zero-ETL to keep a supported search index or analytics target in sync, and incremental S3 exports when your pipeline can process batches of changes. AWS streaming CDC comparison · Pipes with DynamoDB · AWS export documentation
Compare DynamoDB CDC options
Start with what the destination needs to recover after an outage. A product index can be rebuilt from current state. A billing event or audit trail may need each individual change and a way to replay it. For export-based options, DynamoDB point-in-time recovery (PITR) determines how far back you can request source data. AWS PITR documentation
| Option | Retention or replay | Ordering and duplicates | Consumers or target | Latency | Pricing model | Delete and TTL visibility |
|---|---|---|---|---|---|---|
| DynamoDB Streams | 24 hours | Source records appear once and are ordered per item. Lambda can redeliver. | Lambda, Pipes, Flink, custom readers | Near real time | Stream GetRecords requests where billable, plus consumer costs. Lambda trigger reads are exempt outside Lambda Managed Instances. | REMOVE for deletes. TTL service identity is visible in the Region that performs the deletion. |
| Kinesis Data Streams for DynamoDB | 24 hours by default, configurable up to 365 days | DynamoDB changes can arrive out of order or more than once. | Lambda, Pipes, Amazon Data Firehose, Flink, custom readers | Near real time | DynamoDB CDC units per 1 KB of the larger item image, plus mode-specific Kinesis charges. | Delete records include the old item. TTL service deletes are also captured. |
| EventBridge Pipes | Inherits the source's retention | Preserves source ordering when sending records to its target. Design for retries and duplicates. | One target per pipe, such as SQS or an EventBridge event bus | Polling and optional batching, plus target time | Requests after filtering, billed in 64 KB payload chunks, plus applicable source and target costs. | Forwards matching deletes and any TTL metadata supplied by the source. |
| OpenSearch Service zero-ETL | The live feed uses the 24-hour DynamoDB stream. Search documents live in the target. | Managed index updates by document ID and version | OpenSearch Service domain or OpenSearch Serverless collection | Within seconds in AWS's launch description | OpenSearch Ingestion compute, destination charges, and applicable Streams and snapshot costs | Source deletes become index deletes, including physical TTL removals. |
| Redshift zero-ETL | Managed replication from PITR exports. Query the target tables. | Batched state replication | Amazon Redshift | Incremental replication every 15 to 30 minutes | DynamoDB PITR and exports, plus Redshift compute and storage | Replicates deletes. Redshift history mode can retain inactive target versions. |
| SageMaker Lakehouse zero-ETL, including S3 Tables via AWS Glue | Managed replication from PITR exports. Query the target tables. | Batched state replication | Lakehouse tables for analytics and ML | Typically 15 to 30 minutes. AWS Glue refresh interval is configurable. | DynamoDB PITR and exports, plus target storage and processing charges | Applies net deletes in the refresh. Export records carry no TTL service marker. |
| Incremental export to S3 | Request windows within configured PITR history. Keep S3 files for as long as your retention policy allows. | One compacted result per changed key per window. Make reprocessing safe. | Glue, Athena, or a custom batch loader | Windows of 15 minutes to 24 hours, plus asynchronous export and load time | PITR, export volume processed with a 10 MB minimum per incremental export, and S3 charges | A net delete contains keys, optionally with an old image. There is no TTL service marker in the export format. |
Pricing and record details are documented separately. DynamoDB pricing · Kinesis retention · Kinesis pricing · EventBridge pricing · DynamoDB Streams TTL records · Kinesis TTL records · Redshift history mode · AWS Glue pricing
Choose a stream or a managed consumer for DynamoDB events
DynamoDB Streams is the simplest starting point for application reactions. Choose KEYS_ONLY for key-based invalidation, NEW_IMAGE for the resulting item, OLD_IMAGE for the previous item, or NEW_AND_OLD_IMAGES to compare both. If the event lacks an image you expect, see missing stream fields. Ordering applies to changes to the same full primary key, so an order item and its separate outbox item can arrive independently. See the DynamoDB Streams setup guide and Lambda triggers for setup. AWS stream views and ordering · Transaction propagation
Kinesis Data Streams for DynamoDB is a better fit when consumers need their own read positions and the ability to catch up more than a day later. Set the retention period explicitly and include a per-item version in your data when an older update arriving late could overwrite newer state. DynamoDB sends changes to a Kinesis stream in the same account and Region, and you can enable both native streaming options on the same table. See the DynamoDB Streams vs. Kinesis comparison. Kinesis destination behavior · AWS streaming CDC comparison
EventBridge Pipes is a consumer of either stream. Use a pipe to filter records, shape or enrich the payload, and forward it to a single target. For example, route outbox records to an event bus when several services need their own rules, or to an SQS queue when one service needs to process them. Use TRIM_HORIZON if a new DynamoDB pipe needs all available records. AWS warns that polling can take time to start, so LATEST can miss events during creation or updates. DynamoDB source settings · Kinesis source settings · Pipes targets
Which DynamoDB zero-ETL targets are generally available?
As of November 2026, AWS offers these generally available DynamoDB integrations. Check the AWS launch and setup documentation for availability in your target Region.
- Amazon OpenSearch Service. Use OpenSearch Ingestion for full-text search or filtering on an indexed copy. Enable PITR for the initial S3 snapshot and DynamoDB Streams for ongoing replication. If you only need new changes, the pipeline can start without a snapshot. Budget enough ingestion capacity for the initial load to finish before source changes expire. GA announcement · Pipeline setup and limitations
- Amazon Redshift. Use the DynamoDB integration for SQL analytics and joins with warehouse data. It starts with a full export and applies periodic incremental exports, so enable PITR on the source table. Redshift history mode can track versions that make it to the warehouse. Multiple changes compacted within an export window can still collapse into one result. GA announcement · Redshift replication · Incremental export semantics · Redshift cost breakdown
- Amazon SageMaker Lakehouse, including Amazon S3 Tables via AWS Glue. Use the Lakehouse integration to make DynamoDB data available to analytics and ML tools. Storage options include a general-purpose S3 bucket, S3 Tables for managed Apache Iceberg tables, and Redshift Managed Storage. Check the configured refresh interval against your freshness requirements. Lakehouse launch · S3 Tables launch · Glue target setup · Glue refresh behavior
Use incremental export to S3 for batch synchronization
For an hourly reporting copy, seed the destination with a full export, then request contiguous incremental windows. The start is inclusive and the end is exclusive, so the window after 10:00–11:00 starts at 11:00. Use the completed job's file manifest to select inputs. Upsert rows that have a new image and remove rows that have keys without a new image. Advance the completed window in your loader only after the destination writes succeed, and make reapplying a window safe. Requesting an export · Export manifests and record shapes
If a product changes price three times in a window, the export keeps the final result for that key. An item inserted and deleted within the same window produces no row. Use export for a replica or batch reconciliation, and capture stream records separately if each intermediate change matters. See the DynamoDB-to-S3 export walkthrough. AWS incremental export examples
Five CDC patterns with examples
Search indexing
For a product catalog, use OpenSearch Ingestion and map the full DynamoDB primary key to a stable document ID. A price update replaces the same search document, and deleting the product removes it from search. For a custom search consumer, make document writes conditional on the source version and keep version information for deletions so a late update cannot recreate a removed product. AWS OpenSearch document actions and versioning
Transactional outbox and event publishing
When an order is paid, use TransactWriteItems to update the order and create an immutable outbox item carrying OrderPaid, a stable event ID, and the order ID. Have a pipe match the outbox item type in dynamodb.NewImage and forward it to an event bus, or have Lambda publish it if the envelope needs custom logic. Consumers deduplicate on the outbox event ID. Keep outbox items long enough for a separate republisher to recover missed events by querying them. AWS transactional outbox pattern · Pipes filter syntax
Audit history
To retain every account status change, capture both item images and write the stream events to S3 with the item key, operation, and event ID. Add actor and reason fields to an explicit audit event when the business needs that context. For a TTL-only archive, filter REMOVE records where userIdentity.type is Service and userIdentity.principalId is dynamodb.amazonaws.com. DynamoDB Streams adds that identity in the Region that performed the deletion. A deleted item's fields require an old image. AWS audit trail example · TTL archive filtering
Cache invalidation
For a cache keyed by product ID, have Lambda evict product:123 on an item change. The next cache miss reloads from DynamoDB. Repeating an eviction is safe, but a read that started before the change can refill the cache after the eviction. Use a short cache TTL to bound stale entries and use version-aware fills or direct table reads where the application requires stricter freshness. AWS DynamoDB and ElastiCache patterns · DynamoDB read consistency
Cross-Region replication
Use DynamoDB global tables when applications in two Regions need replicas of the same operational table. For a different data model, such as a customer summary table in another Region, use a CDC consumer to write a one-way projection with idempotent upserts and delete handling. If consuming streams from several global table replicas, account for replicated writes and use a shared application event ID for side effects. MREC replicas can coalesce changes, so one replica's stream may differ from another's. AWS global tables behavior · Replica stream records
Production pitfalls
Make writes and side effects idempotent
Lambda stream delivery is at least once, even though a record appears once in DynamoDB Streams. For a native stream retry, use its eventID as an identity. For events that can be republished, use the application event ID that travels with the payload. Where possible, commit the deduplication entry and the state change together. For an external side effect such as a payment request, pass the same idempotency key on every retry. A deduplication marker written before an unprotected side effect can cause a retry to skip work that never finished. Lambda delivery semantics · Stream record fields · AWS outbox guidance
Isolate poison records and retain failed payloads
A permanently invalid record can hold up an affected shard while the consumer retries. For Lambda stream processing errors, enable BisectBatchOnFunctionError to split batches that throw, and use ReportBatchItemFailures to return the sequence number of failed records. Lambda uses the lowest reported failure as the retry checkpoint. Set retry and record-age bounds and select an on-failure destination. Choose S3 if you need the full failed invocation payload for replay after stream expiry. With Pipes, configure source retries, AUTOMATIC_BISECT where appropriate, and a dead-letter queue with a maximum record age below source retention. Lambda partial batch responses · Lambda failure destinations · Pipes retry handling · Pipes batch bisection
Monitor iterator age and plan for the 24-hour gap
Alarm on Lambda's IteratorAge and track errors and throttling alongside it. Use maximum age to surface a slow batch that an average could hide. For Kinesis, monitor GetRecords.IteratorAgeMilliseconds for polling consumers or SubscribeToShardEvent.MillisBehindLatest for enhanced fan-out. For Pipes, watch ExecutionFailed and measure the age of the source record at the destination. Choose a lag threshold that leaves enough time to fix the issue and drain the backlog. Lambda metrics · Kinesis metrics · Pipes metrics
If a caught-up consumer stops for 26 hours while writes continue, changes from the first two hours are already outside the DynamoDB Streams replay window. TRIM_HORIZON starts at the oldest record still available. If the target needs current state, reconcile with a snapshot or use contiguous incremental exports when PITR covers the gap. If the system must recover every event, arrange longer Kinesis retention, a durable event archive, or a recoverable outbox before the failure. For OpenSearch, a pipeline that has fallen past retention may need a fresh index build. Streams retention · PITR recovery window · OpenSearch recovery
Frequently Asked Questions
What DynamoDB events does CDC capture?
What is the difference between DynamoDB Streams and EventBridge Pipes?
Can you replay DynamoDB changes after 24 hours?
Which DynamoDB zero-ETL targets are generally available?
Does an incremental export include deleted items?
Dynobase is a Professional GUI Client for DynamoDB
Start your 7-day free trial today
Product Features
DynamoDB Tools
- SSH GUI Client
- Chat With Cloud
- MongoDB GUI Client
- AWS Cost Monitoring
- DynamoDB Query Builder
- DynamoDB Code Examples
- DynamoDB Node.js Queries
- DynamoDB JSON Converter
- DynamoDB UUID Generator
- DynamoDB Local Admin GUI
- DynamoDB Pricing Calculator
- DynamoDB Single-Table Design
- Best DynamoDB GUI Clients
- Dynobase vs DynoTable