A SQL Server change feed can produce events for applications to consume or keep tables in a warehouse current. Those are different jobs. A Kafka connector can publish the facts of an insert, update or delete, with a separate consumer deciding how to apply them. A managed warehouse connector can take responsibility for both capture and destination writes.

Debezium fits an event pipeline a team operates itself. Airbyte, Fivetran, Estuary and Hevo are candidates when the goal is a maintained warehouse table. Qlik and Striim fit installations that need more control over readers and replication tasks, while Datastream and AWS DMS have documented paths into their cloud data platforms. Across all of them, source retention determines whether a stopped reader can catch up, and the destination’s write mode determines what a delete means for a report.

SQL Server CDC tools at a glance

Treat capture and destination behavior as separate contracts. Verify the exact source edition, destination connector, table key, write mode and replay rules during a trial.

SQL Server CDC source, destination and recovery comparison
ToolSQL Server captureDestination decisionUseful trial check
DebeziumSQL Server CDC tables, connector snapshots and Kafka Connect offsetsKeyed Kafka events with a configurable tombstone; warehouse sink is separateVerify delete envelope, tombstone, offset recovery and sink result
AirbyteSQL Server CDC and primary key for incremental CDC synchronizationSelected destination's configured synchronization and deduplication modeCheck composite keys, repeated events and destination deletion behavior
FivetranConnector-specific SQL Server methods including CDC or Change Tracking where eligibleDefault soft deletes for new CDC tables; configure supported history as neededConfirm delete flag or history through a pause and re-sync
Qlik ReplicateSelected SQL Server or MS-CDC source endpointEndpoint and task determine apply-changes or change storageVerify task selection, table keys and recoverable positions
Google Cloud DatastreamSupported SQL Server change-table or transaction-log collectionBigQuery merge for keyed tables or append-only eventsCompare merge output, append history and LOB limitations
StriimMS SQL Reader or MSJet, depending on platform and log pathReader feeds a chosen target writer and its configured behaviorTest permissions, eligible logs and checkpoint recovery for that reader
Estuary FlowSelected SQL Server capture connector and its configured backfillCapture collection materialized with destination-specific semanticsCheck a backfill plus delivery to the expected warehouse key
Hevo EdgeSQL Server log-based capture for documented sources and versionsDestination and pipeline configuration determine final deletesTest captured deletes and resync a disposable object
AWS Database Migration ServiceDocumented replication or CDC based on source deploymentFull load and eligible CDC into a supported destination such as RedshiftVerify source prerequisites, full load, apply and resume for that pair

Debezium SQL Server Connector

The Debezium SQL Server connector can take an initial snapshot and then read the database’s CDC change tables. It publishes change events through a supported runtime and records its progress using log sequence numbers. This gives an existing Kafka pipeline a source of row-level events without making every consumer query SQL Server.

Its appeal is the ability to use the same events for several consumers and control how the warehouse sink applies them. A delete event and its tombstone have different roles in Kafka. Delivery and recovery depend on the sink’s behavior and on keeping offsets, schema history and source CDC retention compatible.

Inspect the Kafka message key and the change envelope for a deleted row. Debezium documents a delete event and, with tombstones enabled, a follow-up record with a null value. Topic compaction and a warehouse sink use those messages independently, so verify both behaviors.

Run the initial snapshot and record the connector offset before stopping it. Restart inside retained SQL Server changes first, then rehearse the documented snapshot workflow for a gap in a disposable connector. Confirm available history in the destination separately from what survives compaction.

Debezium documentation and JSON sample for a SQL Server delete event.
Debezium’s SQL Server documentation shows the delete event payload and its key fields. Documentation screenshot
Compatibility
Requires SQL Server CDC on the source databases and tables and a supported Debezium runtime.
License and trial
Open-source connector. Runtime, Kafka and destination operations are separate responsibilities.

Airbyte Microsoft SQL Server Connector

Airbyte’s Microsoft SQL Server connector can read inserts, updates and deletes through CDC. The same connector can send them to a supported destination under an Airbyte sync mode. That suits a data team already using Airbyte to manage source and destination configurations.

The distinction is what the destination does with the changes. The documented at-least-once delivery can expose duplicate records, while destination sync and deduplication settings determine how consumers see them. The incremental CDC path requires a primary key, which matters when older SQL Server tables have no stable identifier.

Airbyte documents primary keys for incremental SQL Server CDC and at-least-once delivery. Include a composite key in the source pilot and replay part of the stream intentionally. Check whether the destination's current-state tables contain duplicates or stale values after retry.

Choose a destination and synchronization mode before interpreting the delete test. Check the raw result and the table queried by analytics. Document which connector state and destination artifacts an operator needs to preserve if one stream must be refreshed.

Airbyte SQL Server source form with connection fields and the CDC method selected.
Airbyte’s source setup example shows how to configure SQL Server replication and select the CDC method. Publisher example
Compatibility
Airbyte documents SQL Server CDC and a primary-key requirement for incremental CDC sync. Destination and version support vary.
License and trial
Self-managed and commercial options. Availability depends on the source, destination and selected plan.

Fivetran SQL Server Connector

Fivetran’s SQL Server connector provides managed syncs through several documented methods, including Change Tracking, CDC, Binary Log Reader and Teleport Sync. A company that wants the provider to run the connector can select the method that works with its SQL Server deployment and warehouse.

The capture method changes the setup and operating cost. The Binary Log Reader, for example, involves transaction-log access and supplemental logging. At the warehouse, soft-delete and history options can make the same source delete look different to a report. A re-sync can also add time and usage that a steady-state trial would miss.

Take a newly added SQL Server CDC table and examine its configured sync mode. Fivetran documents soft deletion by default for that case, which retains the row with a delete marker. Run the same change on a trial table configured for supported history to compare the reader-facing shapes.

The capture choice matters when comparing history with Change Tracking, which has different source details from CDC. Use a brief outage to confirm source retention and expected re-sync behavior, then reconcile the destination's current state and separately count versions or deleted rows.

Fivetran installer screen for setting the SQL Server backup log directory.
Fivetran’s Windows Authentication Server setup shows the backup-log folder option for SQL Server. Publisher example
Compatibility
Supported methods depend on SQL Server deployment, operating system and selected connector configuration.
License and trial
Commercial managed connector. Billing depends on usage and applicable re-sync behavior.

Qlik Replicate

Qlik Replicate uses configured source and target endpoints to move SQL Server data and apply ongoing changes. Operators can see both incoming and applied change activity. That is useful during a backlog because a reader that has caught up with SQL Server and a target that has applied the queue are two different milestones.

It suits a company already operating Replicate or one that wants the endpoint and task controls in its own replication workflow. The SQL Server and MS-CDC endpoints have distinct requirements. For MS-CDC, permissions and limitations on DDL such as renames can affect how a schema change is handled.

Qlik documents a distinct Microsoft SQL Server MS-CDC endpoint. Apply the limitations for the precise source endpoint instead of reusing permissions and assumptions from a generic SQL Server task. Start with a table that has the production key and the data types your pipeline needs.

Record the task mode and the checkpoint an operator can use for recovery. Exercise a delete and two nearby updates and inspect the selected target. If the team wants a separate change store and an up-to-date target table, verify both modes in the trial's actual endpoint combination.

Qlik Replicate Change Processing tab with task gauges and a chart of applied operations.
Qlik Replicate’s change processing view shows incoming and applied changes and apply throughput. Publisher example
Compatibility
Qlik documents SQL Server and MS-CDC source endpoints. Required permissions and target features depend on the endpoint.
License and trial
Commercial. Source and target licenses depend on the deployed configuration.

Google Cloud Datastream

Google Cloud Datastream can capture changes from supported SQL Server deployments using change tables or transaction logs. It is particularly relevant for BigQuery. A destination can maintain the current state of keyed tables in merge mode or retain change events in append-only mode.

The choice is useful when the warehouse team already works in BigQuery and needs a native managed ingestion path. Merge mode needs a primary key, so keyless tables remain append-only. Source method and destination mode also affect the consequences of adding columns or loading large values that need supplementation.

BigQuery's merge mode applies changes to current rows for tables with a primary key. Append-only mode keeps event records. Compare the two with the same committed changes and account for the documented intermediate-change limitations for some large object fields.

Make the source method part of the result by recording whether you capture from change tables or transaction logs. Test a controlled late batch, wait for the chosen staleness bound and verify whether a deleted key still appears in the exact table your reporting queries.

Google Datastream documentation comparing BigQuery merge and append-only write modes.
Google’s BigQuery destination guide shows the merge and append-only write modes for Datastream. Documentation screenshot
Compatibility
SQL Server change-table and transaction-log paths have separate support limits. BigQuery merge mode requires keyed tables.
License and trial
Usage-based Google Cloud service. BigQuery storage and processing are additional cost factors.

Striim

Striim offers two documented SQL Server readers for continuous replication. Microsoft SQL Reader can consume SQL Server CDC change tables, while MSJet has a different transaction-log and backup support matrix. That choice matters for a team with several SQL Server versions or source topologies.

It is a candidate when the reader and initial-load handoff need deliberate configuration. The reader that works for one server may have different prerequisites on another deployment. The handoff and target settings also affect which order of changes the warehouse can see during catch-up.

The MS SQL Reader and MSJet paths cover different versions, deployments and log handling. Check the comparison for the source under test and record where it reads changes. Plan the connection and archive or change-table dependencies before enabling a production task.

Test recovery at the reader and the selected writer. Compare an ordering field or source checkpoint from the captured event against the row that actually appears in the destination. Ensure the same state can be recovered when a network outage interrupts destination writes.

Striim pipeline wizard SQL Server source form with inline configuration guidance.
Striim’s pipeline wizard shows the options for connecting a SQL Server source. Publisher example
Compatibility
SQL Server source and target support depend on the Microsoft SQL Reader or MSJet path and deployment.
License and trial
Commercial platform. Reader availability and deployment terms depend on the plan.

Estuary Flow

Estuary Flow captures SQL Server changes into a collection and materializes that collection to destinations such as Snowflake. Separating capture and delivery makes it possible to keep the captured stream as a reusable input. A configured materialization determines how a source delete is represented in the warehouse.

The strength is a durable stage between SQL Server and the destination. SQL Server change-table retention and collection retention are separate, so either one can shape how long a recovery can wait. Automatic cleanup or capture-instance management also matters if other consumers depend on the same source CDC data.

Estuary documents backfill controls for its SQL Server capture and bindings. Choose a binding with a known key, record how historical rows enter the collection, and compare its first few captured changes with the later destination output.

A collection can serve multiple downstream materializations. Test the one warehouse and mode you need by replaying a deleted key and reading both audit data and current rows. Record whether the documented re-backfill or a destination rebuild changes previously retained history.

Estuary SQL Server advanced settings showing cleanup and capture instance controls.
Estuary’s SQL Server capture options include change table cleanup and capture instance management. Publisher example
Compatibility
The SQL Server CDC connector has deployment-specific variants. A separate Change Tracking connector is documented.
License and trial
Commercial managed service. Capture, collection and materialization terms depend on usage and plan.

Hevo Data Edge

Hevo Data Edge provides a managed pipeline for documented SQL Server deployments and destinations. Its generic SQL Server workflow can use CDC or Change Tracking. That makes it a candidate when a warehouse team wants a managed sync with visible scheduling and deleted-row handling.

One limitation is especially relevant during schema changes. Hevo’s Edge workflow expects one CDC capture instance per table. A change that replaces the capture instance can remove old history, so how the pipeline reconciles the interval affects whether a downstream table can be trusted after the change.

Use the SQL Server Edge guide for the source version and deployment you plan to run. It lists delete capture and resync as supported features. Compare their actual result under the chosen warehouse mapping and verify which role supplies access to the SQL Server source.

Run an object-level resync in a disposable pipeline after a sequence of updates and a delete. Compare how the destination indicates the deleted key before and after reloading, then confirm what source position and configuration an operator needs to start again.

Hevo object status screen with a warning about a mismatch between source and CDC table columns.
Hevo’s SQL Server pipeline example shows the warning raised when a new column has no matching CDC capture column. Publisher example
Compatibility
Hevo documents generic SQL Server support through SQL Server 2022 in the cited guide. Source and destination coverage depend on the Edge setup.
License and trial
Commercial managed pipeline. Edge availability and destination terms depend on the plan.

AWS Database Migration Service

AWS Database Migration Service can load and replicate supported SQL Server sources to targets such as Amazon Redshift. Capture prerequisites vary with the source and whether tables have keys. This is useful when an AWS-based team wants an initial load and a period of ongoing replication under one managed task.

The important distinction is source capture progress versus destination apply behavior. AWS documents that resuming a Redshift task can replay changes, which can produce duplicates where keys are unenforced. A migration plan needs a way to reconcile the warehouse at the selected cutover position even when the task reports healthy.

Determine whether the SQL Server source is managed or self-managed before preparing the task. AWS documents different capture prerequisites for each path. Verify the necessary SQL Server features, source privileges and available change history before attempting a full-load-plus-CDC run.

Start a rehearsal with a known target already configured and record the task's behavior after full load. Generate a committed insert and delete, then compare changes applied to the target and the task state. Retain point-in-time data separately if your application needs to recover a lost event.

AWS DMS monitoring dashboard with source latency, target latency, and changes applied to the target.
AWS’s DMS monitoring example shows separate source and target CDC latency and target change charts. Publisher example
Compatibility
AWS documents different SQL Server prerequisites for managed and self-managed sources. Redshift is a supported target option.
License and trial
Usage-based service. Replication capacity and target resources affect cost.

SQL Server CDC tools by target and operating model

What you needTools to shortlistWhat to verify
Send SQL Server changes to a Kafka pipelineConfirm who owns Kafka, ordering, offset recovery and the downstream consumer.
Load an existing warehouse with a managed connectorVerify capture mode, destination delete behavior, schema changes and whether replay adds duplicate rows.
Use a client-managed replication serverMonitor the source and target separately, and verify DBA permissions and baseline recovery.
Replicate into a warehouse on AWS or Google CloudCheck the supported source deployment, exact warehouse write mode and recovery after a retention gap.

Choose what the destination keeps after a delete

Write down the destination contract before picking a connector. A single deleted source row can leave a flag, an event or no current row. Verify that behavior on the table analysts will query, and test a separate history consumer when the project needs one.

What will the destination be used for?
  • Operational queries need the current record

    Use a keyed current-state table

    Check whether deletes remove the row or whether every reader must filter a flag.

  • Auditors need previous amounts

    Keep a versioned change history

    Confirm history is captured at the required granularity and retained through resync.

  • An event stream drives several consumers

    Preserve ordered, keyed events

    Check delete events, null-value tombstones, compaction and each sink's contract.

Check that you can recover from an expired checkpoint

Record the initial snapshot boundary and the consumer's next unread source position. SQL Server exposes the lower valid LSN for each capture instance through sys.fn_cdc_get_min_lsn. A connector may store other offset fields alongside an LSN, so use its documented recovery procedure if the saved state falls outside retained changes.

A new snapshot rebuilds current state for an eligible connector. It cannot reconstruct intermediate events already aged out of both the source and the destination. Include a separate backup, event history or explicit gap decision if the reporting requirement depends on those events.

Expected outcomes for one insert, two updates and one delete
View of the source changesExpected for Order 101What to verify in a product
Current-state replicaNo active Order 101A delete is applied, or downstream readers filter an explicit flag
Soft deleteOne marked-deleted recordReader excludes that record, and its stored amount follows the configured mode
Append historyFour conceptual changes, from insert to deleteActual event count can also include before images, snapshots, duplicates or tombstones
Keyed Kafka topicDelete event and optional tombstoneWith Debezium tombstones enabled, observe the null value for the same key
Lagged consumerThe sample's next expected version is no longer availableState gap is explicit; recovery reconciles current rows and documents lost history

How to compare these tools

Update and delete rows, stop the connector and repeat after it resumes. Then test what happens after the SQL Server changes it needs expire. Verify the destination state after both runs. Sources checked .

Replay a delete and recover a missing checkpoint

Use a disposable SQL Server source and target for a connector trial. Apply one insert, two updates and a delete for key 101, with key 102 as a retained row. The SQL below models expected states and an expired checkpoint using portable integer versions. The actual connector will report its own log or offset positions.

SQL

Model current rows, optional history and an expired checkpoint

T-SQL · 29 lines

SET NOCOUNT ON;DECLARE @Changes table (    ChangeVersion int NOT NULL PRIMARY KEY,    OrderId int NOT NULL,    Operation char(1) NOT NULL,    Amount decimal(10,2) NULL);INSERT @Changes VALUES    (1,101,'I',10.00), (2,101,'U',12.00), (3,101,'U',15.00),    (4,101,'D',NULL), (5,102,'I',25.00); WITH Latest AS (    SELECT OrderId, Operation, Amount,        ROW_NUMBER() OVER (PARTITION BY OrderId ORDER BY ChangeVersion DESC) AS RowNum    FROM @Changes)SELECT OrderId, Amount FROM LatestWHERE RowNum = 1 AND Operation <> 'D'; SELECT ChangeVersion, OrderId, Operation, AmountFROM @Changes WHERE OrderId = 101 ORDER BY ChangeVersion; -- These integers model exclusive offsets, independent of a connector's LSN format.DECLARE @LastAppliedVersion int = 1;DECLARE @EarliestReadableVersion int = 3;SELECT @LastAppliedVersion + 1 AS NextExpectedVersion, @EarliestReadableVersion AS FirstAvailableVersion,    CASE WHEN @LastAppliedVersion + 1 < @EarliestReadableVersion         THEN 'Source gap: reconcile and recover'         ELSE 'Resume reading the available stream' END AS ResumeDecision;
Review before runningT-SQLUTF-829 lines
  1. Finish the initial snapshot, then commit the five events in the fixture's order using the source table. Pause the test consumer after the first event and observe the checkpoint.
  2. Resume while changes are still retained. Check the absent or marked-deleted key 101, the active key 102 and any history or tombstone output configured for the test.
  3. Rehearse a resume after retention in a disposable instance, without reducing the production retention window. Use the vendor's recovery workflow and reconcile current rows. Record which intermediate changes are still available.

Conclusion

Choose a SQL Server CDC tool for the destination behavior you actually need and the failure you can recover from. A fresh baseline can rebuild current rows after a retention gap, and those rows give you no record of the intermediate changes. If the warehouse must preserve them, size retention, alert on lag and test the replay path.

Frequently asked questions

Is SQL Server Change Tracking the same as change data capture?

Change Tracking identifies changed keys, operations and versions so a reader can query the latest row state. SQL Server CDC captures row values from the transaction log into change tables. Which method fits depends on whether the consumer needs current values or the sequence of changes.

How do SQL Server CDC tools handle deletes in a data warehouse?

The target can apply a delete, record a deleted flag or append a delete event. Verify the exact connector and write mode on the target you use, including what happens if a row with the same key is inserted again.

Can a SQL Server CDC connector resume after an outage?

Yes, when its saved position is still available and valid. If needed changes have been cleaned up or truncated, a fresh snapshot or backfill can restore current state. The missing intermediate history requires another retained source.

Will adding a SQL Server column immediately appear in a CDC pipeline?

A SQL Server CDC capture instance reads the columns registered for it. A connector may need a new capture instance and a destination schema change. Follow its supported handoff and check for a gap around the DDL.

Does a SQL Server CDC pipeline need a primary key?

SQL Server Change Tracking requires a primary key. CDC can capture some tables without one, but the tool and destination need a reliable row identity to apply updates or deletes. Verify how keyless tables are handled in your connector.

Can a CDC resnapshot recover history that expired at the source?

A new snapshot can establish current table contents. Intermediate changes need a retained event stream, backup or another historical store. Record the gap after resnapshot if those events can no longer be recovered.

Related guides

Guide~15 min readUpdated 15 Nov 2026
LinkedInXEmail