Debezium CDC (Change Data Capture)

Estimated read time 6 min read

What is Debezium CDC?

Debezium CDC (Change Data Capture) is an open-source distributed platform for capturing changes in databases and streaming those changes into Apache Kafka or other messaging systems. CDC is a software design pattern used to track changes in a database and propagate them to other systems in real-time.

Debezium offers connectors for various databases like MySQL, PostgreSQL, MongoDB, SQL Server, and others. These connectors monitor the database’s transaction log to capture changes, such as inserts, updates, and deletes, as they occur. Then, they convert these database changes into a stream of events that can be consumed by downstream applications or systems.

Using Debezium, developers can build real-time data pipelines, data synchronization, and event-driven architectures. It’s particularly useful in scenarios like microservices architectures, data integration, data replication, and building materialized views for analytics. By capturing and processing database changes in real-time, Debezium enables applications to react to those changes immediately, enabling more responsive and scalable systems.

Connector support for Debezium

As of my last update, Debezium supports connectors for various databases. Here’s a list of some of the connectors it supports:

  1. MySQL
  2. PostgreSQL
  3. MongoDB
  4. SQL Server
  5. Oracle (Experimental)
  6. Cassandra (Incubating)
  7. DB2 (Experimental)

Additionally, there might be community-contributed connectors or experimental connectors for other databases or systems. The availability of connectors might have changed since my last update, so it’s a good idea to check the official Debezium documentation or GitHub repository for the most up-to-date information on supported connectors.

Alternative Debezium CDC for open-source

While Debezium is one of the most popular open-source CDC platforms, there are several alternatives available, each with its own features and capabilities. Some alternatives to Debezium CDC include:

  1. Maxwell’s Daemon: Maxwell’s Daemon is an open-source CDC tool for MySQL databases. It captures row-level changes and produces JSON messages that can be sent to Kafka or other messaging systems.
  2. Debezium (Kafka Connect) + Apache NiFi: Apache NiFi can be used alongside Debezium’s Kafka Connect connectors to create a robust data ingestion and processing pipeline. NiFi provides additional features for data routing, transformation, and enrichment.
  3. Debezium + Apache Pulsar: Apache Pulsar is an open-source distributed pub-sub messaging system. You can use Debezium’s Kafka Connect connectors alongside Pulsar’s Kafka compatibility layer to stream database changes into Apache Pulsar.
  4. Debezium + Apache Flink or Apache Spark: Apache Flink and Apache Spark are powerful stream processing frameworks. You can integrate Debezium with these frameworks to process and analyze database change events in real-time.
  5. Liquibase and Flyway: While not CDC tools in themselves, Liquibase and Flyway are popular open-source database schema migration tools. They can be used in conjunction with custom scripts or tools to capture and propagate database changes manually.
  6. Debezium Embedded Mode: Debezium also offers an embedded mode, allowing developers to embed Debezium’s change data capture capabilities directly into their Java applications without relying on Kafka Connect.

These are just a few alternatives to Debezium for implementing change data capture in an open-source environment. The choice of tool depends on your specific requirements, existing infrastructure, and preferred technology stack.

There are open-source CDC (Change Data Capture) tools available for PostgreSQL, MySQL, and MongoDB. Here are some options for each:


  • Debezium: Debezium provides a PostgreSQL connector that captures changes from PostgreSQL databases and streams them into Apache Kafka or other messaging systems.
  • pg_cdc: pg_cdc is a PostgreSQL extension that enables Change Data Capture functionality directly within PostgreSQL. It captures changes to tables and provides a way to stream these changes to external systems.


  • Debezium: Debezium offers a MySQL connector for capturing changes from MySQL databases and streaming them into Kafka or other messaging systems.
  • Maxwell’s Daemon: Maxwell’s Daemon is a CDC tool specifically designed for MySQL databases. It captures row-level changes and produces JSON messages that can be sent to Kafka or other systems.
  • MySQL Binary Log: While not a tool in itself, you can utilize MySQL’s binary log along with custom scripts or tools to implement Change Data Capture.


  • Debezium: Debezium provides a MongoDB connector for capturing changes from MongoDB databases and streaming them into Kafka or other messaging systems.
  • MongoDB Change Streams: MongoDB includes Change Streams, which allow applications to receive real-time notifications of changes to data in MongoDB collections. You can leverage this feature to build your own CDC solution or integrate it with other systems.

These are some of the open-source CDC options available for PostgreSQL, MySQL, and MongoDB databases. Each tool has its own features, capabilities, and suitability for different use cases, so you may want to evaluate them based on your specific requirements and preferences.

Yes, you can implement Change Data Capture (CDC) without using Apache Kafka. While Kafka is a popular choice for streaming and processing data, there are other messaging systems and approaches you can use depending on your requirements and infrastructure.

Alternatives to using Kafka for CDC:

Direct Database Integration:

  • Some CDC tools, like Debezium, offer options for direct integration with databases without requiring Kafka. For example, Debezium can be used in embedded mode within Java applications to capture changes from databases and process them without Kafka.

Custom Messaging Systems:

  • You can implement CDC by streaming change events to custom messaging systems like RabbitMQ, Apache Pulsar, or even directly to HTTP endpoints. This approach requires building custom connectors or adapters to capture database changes and publish them to the messaging system of your choice.

Database-Specific Features:

  • Some databases offer built-in features for streaming change events. For example, PostgreSQL’s logical replication and MongoDB’s Change Streams allow you to capture database changes without relying on external messaging systems.

Streaming Frameworks:

  • Instead of Kafka, you can use other stream processing frameworks like Apache Flink or Apache Spark for processing and analyzing change events. These frameworks support various input sources, including databases, and offer capabilities for real-time data processing.

File-Based Approaches:

  • In some cases, you may opt for file-based approaches to capture database changes. For instance, you could periodically dump database tables into files and use file-based change detection mechanisms to identify and process the changes.

Database Triggers and Logs:

  • You can implement CDC using database triggers or by parsing database transaction logs. This approach involves writing custom scripts or using database-specific features to capture and process changes at the database level.

Each of these alternatives has its own trade-offs in terms of complexity, scalability, and capabilities. When choosing an approach for CDC without Kafka, consider factors such as your existing infrastructure, data volume, latency requirements, and integration preferences.

Related Articles