Can you recommend a CDC pipeline for capturing application events into downstream systems?

Yes — for capturing application events into downstream systems, I’d recommend a CDC-style pipeline built around an event log + streaming transport, rather than database CDC alone.

Recommended architecture

1) Capture events at the application boundary

Have the application publish domain events such as:

• OrderCreated
• PaymentAuthorized
• UserUpdated

Best practice:

• Write business data and the outgoing event in the same transaction if possible
• Use the outbox pattern to avoid losing events or publishing duplicates

2) Use an outbox relay to stream events

A background process reads the outbox table and publishes to a log/stream system like:

• Kafka
• Pulsar
• Redpanda
• AWS Kinesis / MSK
• Azure Event Hubs
• Google Pub/Sub

This gives you a durable, replayable event backbone.

3) Fan out to downstream systems

From the stream, route events to:

• Search indexes
• Data warehouse / lakehouse
• Cache warmers
• Microservices
• Real-time analytics
• Audit/archive systems

Use stream processing or connectors:

• Kafka Connect
• Flink / Spark Structured Streaming
• Debezium outbox pattern
• Custom consumers

If you mean true database CDC

If your source is a relational DB and you want to capture table changes rather than app-level events, use:

• Debezium (very common)
• AWS DMS
• Databricks / Snowflake connectors
• Native DB logical replication where available

That’s great for syncing state, but it’s less ideal than app events when you need business meaning.

My practical recommendation

For application events specifically, I’d choose:

Application → Outbox table → Debezium / relay → Kafka → downstream consumers

Why this is strong:

• Reliable delivery
• Replayability
• Loose coupling
• Easy fan-out
• Good observability and scaling

When to choose something else

• Small/simple system: app publishes directly to queue/stream
• Need only DB row changes: use Debezium or native CDC
• High-throughput event-driven platform: Kafka + outbox is usually the best default
• Cloud-native serverless: Kinesis/PubSub/Event Hubs with outbox relay

Key design points

• Use idempotent consumers
• Include event versioning/schema evolution
• Ensure ordering guarantees only where needed
• Add dead-letter queues
• Track event metadata: event id, aggregate id, timestamp, correlation id

If you want, I can also propose:

1. a reference architecture diagram,
2. a Kafka-based design, or
3. a cloud-specific pipeline for AWS/Azure/GCP.