Change Data Capture

Load the starting point. Stream every committed change after it.

SQL Flow combines a parallel seed with durable CDC. Pin the handoff position, catch the target up, monitor lag, and continue applying changes without introducing a second product or control plane.

The job to be done

Move committed data with a path your team can explain.

A capability matters when it removes an operational decision, not when it adds another checkbox. SQL Flow connects source-aware capture, durable progress, target apply, and validation so the page you are reading leads to a usable operating path.

SQL Flow records the source position that belongs to the initial load, streams subsequent committed transactions, and makes lag visible. When the target is ready, your team chooses the cutover window instead of rebuilding state from another snapshot. SQL Flow handles parallel initial load; pinned CDC handoff; visible lag and progress; pause and resume from durable state.

Why this path matters

Keep the application writing while the target catches up.

SQL Flow records the source position that belongs to the initial load, streams subsequent committed transactions, and makes lag visible. When the target is ready, your team chooses the cutover window instead of rebuilding state from another snapshot. SQL Flow handles parallel initial load; pinned CDC handoff; visible lag and progress; pause and resume from durable state.

What changes for you

DirectLog moves decoding onto SQL Flow compute when logs are reachable. Native streams and SQL readers cover environments with different privilege and managed-service constraints. SQL Flow handles oracle DirectLog or LogMiner; SQL Server raw log, native CDC, or polling; PostgreSQL pgoutput; MySQL row binlog and Sybase capture paths.

The outcome

Tell us the source, hosting model, target, and access you can grant. We will map the initial load, capture mode, prerequisites, and cutover checkpoints.

The payoff

See what the capability changes.

Seed + stream

One coordinated handoff

Start with parallel table load, then continue from the pinned change position.

10 paths

Source-aware capture

Choose direct-log, native-stream, or SQL-based access by engine and hosting model.

1 → many

Independent fan-out

Each destination advances from its own durable cursor.

Where the work happens

The details that make the result usable.

Read each capability as part of the operating path. The important question is not whether a feature exists, but what work it removes and what evidence it leaves behind.

Cutover without a long freeze

Keep the application writing while the target catches up.

SQL Flow records the source position that belongs to the initial load, streams subsequent committed transactions, and makes lag visible. When the target is ready, your team chooses the cutover window instead of rebuilding state from another snapshot.

SQL Flow handles parallel initial load; pinned CDC handoff; visible lag and progress; pause and resume from durable state.

  • Parallel initial load
  • Pinned CDC handoff
  • Visible lag and progress
  • Pause and resume from durable state

Match access to the source

There is no honest one-size-fits-all reader.

DirectLog moves decoding onto SQL Flow compute when logs are reachable. Native streams and SQL readers cover environments with different privilege and managed-service constraints.

SQL Flow handles oracle DirectLog or LogMiner; SQL Server raw log, native CDC, or polling; PostgreSQL pgoutput; MySQL row binlog and Sybase capture paths.

  • Oracle DirectLog or LogMiner
  • SQL Server raw log, native CDC, or polling
  • PostgreSQL pgoutput
  • MySQL row binlog and Sybase capture paths

One engine, two capabilities

Burst Load and CDC share deployment, correctness, and operations.

Use Burst Load for a one-shot move, CDC for a continuous stream, or coordinate both for seed-and-stream migration. The same navigation, agents, catalog, and operational contracts cover the whole path.

Before you choose

Check the path against your environment.

Use the page-specific details below as a short discovery checklist. They are the conditions and work areas that shape the capability, not generic product promises.

  • Parallel initial load
  • Pinned CDC handoff
  • Visible lag and progress
  • Pause and resume from durable state
  • Oracle DirectLog or LogMiner
  • SQL Server raw log, native CDC, or polling

The path to confidence

See the work. Make the call. Prove the result.

The page keeps the product detail close to the decision it supports. Your team can see what the software handles automatically, what it changes for the target, and what the result leaves ready to operate.

  1. Keep the application writing while the target catches up.

    SQL Flow records the source position that belongs to the initial load, streams subsequent committed transactions, and makes lag visible. When the target is ready, your team chooses the cutover window instead of rebuilding state from another snapshot. SQL Flow handles parallel initial load; pinned CDC handoff; visible lag and progress; pause and resume from durable state.

  2. There is no honest one-size-fits-all reader.

    DirectLog moves decoding onto SQL Flow compute when logs are reachable. Native streams and SQL readers cover environments with different privilege and managed-service constraints. SQL Flow handles oracle DirectLog or LogMiner; SQL Server raw log, native CDC, or polling; PostgreSQL pgoutput; MySQL row binlog and Sybase capture paths.

  3. Burst Load and CDC share deployment, correctness, and operations.

    Use Burst Load for a one-shot move, CDC for a continuous stream, or coordinate both for seed-and-stream migration. The same navigation, agents, catalog, and operational contracts cover the whole path.

Keep the plan connected

Take the next useful step.

A capability becomes easier to operate when the next decision follows from the constraint you just uncovered. Explore the related work that completes this part of the path.

Your working set

What this page leaves you with

  • One coordinated handoff
  • Source-aware capture
  • Keep the application writing while the target catches up.
  • There is no honest one-size-fits-all reader.
  • Keep the target current from first row to cutover.

Take the next step

Keep the target current from first row to cutover.

Tell us the source, hosting model, target, and access you can grant. We will map the initial load, capture mode, prerequisites, and cutover checkpoints.

Talk through my use case