NeuronCDC 1.3.10 — Verified end to end. See connectors →
NEW Resume-safe initial load for composite keys

Every change.
Every database.
Nothing lost quietly.

NeuronCDC reads committed changes straight from the database log and delivers them to your targets in real time — then checks the result, so a missing row becomes an alert, not a surprise at month end.

Log-based, no triggers Commit-ordered apply Runs on your servers
LIVE · neuroncdc-ora-pg
SourceTrailTarget
    Events0
    Transactions0
    Apply lag0.4s

    CAPTURE FROM AND DELIVER TO THE ENGINES YOU ALREADY RUN

    OROracle TBTibero TAC ALAltibase PostgreSQL MySQL MariaDB SQLSQL Server DB2Db2 LUW DB2Db2 for i { }CSV / JSONL files
    Apache Kafka CFConfluent Schema Registry MongoDB Elasticsearch Apache Parquet Apache Avro Apache Hive IMApache Impala Hadoop HDFS Cloudera Snowflake
    0

    Source engines, from Oracle and Tibero to Kafka and flat files

    0

    Target types — relational, streaming, NoSQL, search and data lake

    0

    Independent checks between a commit and a trusted replica

    0

    Agent to deploy — pure Java 17, on Linux, near your data

    The real problem

    Replication rarely fails loudly.
    It fails quietly.

    The agent looks healthy, the lag chart is flat, and rows are still missing. These are the failure modes NeuronCDC was engineered around.

    01 / CONFIGURATION

    Logging that is almost on

    Without database-level supplemental logging, the log records the commit but not the row. Capture keeps running and replicates nothing. NeuronCDC's preflight checks the source before the first event.

    02 / RESTARTS

    Transactions cut in half

    A log switch, restart or archive catch-up in the middle of an open transaction is where tools drop work. NeuronCDC resumes before the transaction began, not after it.

    03 / DRIFT

    Targets edited by hand

    A manual truncate or a second writer changes the target behind replication's back. The reconciler and drift validator compare both sides and tell you — or fix it.

    One platform

    From the first snapshot to the millionth commit

    Load, capture, apply, verify and fail over with one agent and one repository — no bolt-on tools.

    Log-based capture for every engine

    Native readers for Oracle LogMiner and XStream, Tibero redo (including TAC threads), PostgreSQL logical replication, MySQL and MariaDB binlog, SQL Server CDC, Db2 recovery logs and journals, and Altibase ALA.

    • Commit-ordered, transaction-grouped events
    • Oracle multitenant: mine in CDB$ROOT, read the catalog in the PDB
    • DDL captured with schema-change handling
    • Server-side filtering keeps the log reader lean
    Capture details
    Events captured per second · per source thread

    Snapshots that pick up where they stopped

    Copy existing data while capture already runs. Apply for each table is held until its load completes, so the snapshot and the change stream meet exactly once.

    • Consistent AS OF SCN reads, or flashback-free chunks
    • Checkpointed by primary key — including composite and RAW keys
    • Parallel tables and PK-range partitions
    • Reload one table live from the console
    Load modes
    Initial load progress
    REGISTRATION.EVENTS4.69M rows
    CORE.ACCOUNTScomplete
    LEDGER.ENTRIES · 8 partitionsresuming
    CRM.CUSTOMERSqueued · CDC gated
    ORDERS.PAYMENTScomplete

    Replication you can prove

    A reconciler compares source and target by key and re-applies what is missing. A drift validator runs on a schedule and raises an alarm when counts or values disagree.

    • Heal missing inserts automatically
    • Optional value-mismatch repair and orphan deletion
    • Loss counters surfaced in logs and metrics
    • Targeted re-read when a log record cannot be decoded
    Verification
    Row blocks compared · source vs target
    MatchedDrift foundHealed

    Active-passive with fencing

    Two agents share a lease in the repository. The standby takes over from the last durable checkpoint, and an epoch number fences the old node so a returning process can never write twice.

    • Lease renewal and automatic or manual takeover
    • Epoch fencing on every repository write
    • Survives repository outages without losing position
    • Split extract and apply topologies
    HA design
    Failover simulation
    NODE Aneuroncdc-agentACTIVE
    NODE Bneuroncdc-agentSTANDBY
    Architecture

    One agent between every source and every target

    Changes flow through a durable trail in your own repository database, so capture and apply can stop, restart and fail over independently.

    SOURCES NEURONCDC AGENT TARGETS OracleLogMiner · XStream Tibero TACredo · per thread AltibaseLog Analyzer (ALA) PostgreSQLlogical replication MySQL · MariaDBbinlog · GTID SQL Servernative CDC DB2for i (AS400) · for LUW Capturepreflight · decode · filter Trail repositorydurable · checkpointed Apply & verifyordered · reconciled LOAD · HA · METRICS PostgreSQL · MySQLJDBC apply Oracle · TiberoJDBC apply AltibaseJDBC apply Kafka · ConfluentJSON · Avro MongoDB · Elasticupsert · _bulk index Data lakeParquet · Avro · Hive
    Captured change Delivered change Durable checkpoint
    Built for production

    The details that decide whether data arrives

    Preflight before the first event

    Archive mode, supplemental logging, grants, container names and target tables are checked at start-up. Problems that would otherwise replicate zero rows without an error stop the agent with a clear message.

    source.preflight.enabled: true

    Transforms and joins

    Rename, drop and derive columns, or join lookup tables into a flattened target, using the same code for the snapshot and the stream.

    Secure by deployment

    The agent runs inside your network. Built-in SSH tunnels reach databases behind bastions, and nothing leaves for a vendor cloud.

    Exactly-once to Kafka

    Keyed by primary key, serialised as JSON or Avro with Schema Registry, using transactional producers.

    Metrics you can alert on

    Monitoring endpoint, per-thread lag, sink counters and loss counters — alert on progress, not just liveness.

    How a change travels

    From COMMIT to verified in four steps

    Every stage writes a durable position, so any component can restart without re-reading from the beginning or skipping ahead.

    1

    Read the log

    The capture reader follows redo, WAL or binlog from a saved position and groups records into transactions. Rolled-back work is discarded; only COMMIT moves forward.

    2

    Write the trail

    Committed events land in the trail tables of your repository — Oracle, PostgreSQL, Tibero and others — with the capture checkpoint in the same transaction.

    3

    Apply in order

    The applier replays transactions in commit order, maps names and types per target, and marks each event applied. Tables still loading are gated until their snapshot completes.

    4

    Verify the result

    The reconciler and validator compare source and target on a schedule. Drift is healed or reported, and counters make any gap visible in your monitoring.

    Neuron Manager

    Run every pipeline from one console

    See capture and apply lag, trigger a table reload with or without truncate, add a schema or table to a running agent, and read the audit trail — in the browser or with the viriyaneuron_adm CLI.

    • Live agent, target and sink health
    • Per-table initial-load status and reload
    • Add schemas and tables without a restart
    • Configuration editing over SSH
    manager.internal/agents/neuroncdc-ora-pg
    OverviewAgentsInitial loadTransactionsSinksAuditSettings
    Capture lag0.6 s▼ steady
    Applied today1.28M▲ events
    Drift0last check 2m ago
    ora-pg · node-aACTIVEscn 63134510.6s
    tibero-tac · thread 2ACTIVEtsn 884121.1s
    pg-kafka · ordersLOADING62%gated
    Solutions

    What teams build with NeuronCDC

    Zero-downtime migration

    Load the new platform while the old one serves traffic, keep both in step, and cut over when counts match.

    Plan a migration

    Disaster recovery

    Keep a warm replica on another engine or site, verified by the reconciler rather than assumed healthy.

    Design DR

    Analytics offload

    Stream production changes into PostgreSQL, Snowflake, or a Hive and Impala data lake as Parquet or Avro, so reports stop competing with transactions.

    Offload reporting

    Event streaming

    Publish every row change to Kafka as keyed events and feed microservices, caches and search indexes.

    Stream changes
    FAQ

    Questions teams ask first

    Does NeuronCDC use triggers or query the source tables?

    No. Capture reads the database's own change log — redo, WAL, binlog, CDC tables or journals. Source tables are queried only for the initial load and for verification.

    What does it need on an Oracle multitenant database?

    ARCHIVELOG mode, database-level supplemental logging, a common user that can run LogMiner in CDB$ROOT, and a PDB user that can read the catalog and the replicated tables. The documentation lists the exact grants.

    Can I reload one table without stopping replication?

    Yes. Request a reload from Neuron Manager or the CLI. Apply for that table is held while it loads and resumes automatically when the load completes; other tables keep flowing.

    Where does the agent run?

    On your Linux servers, close to the data, as a single Java 17 process. The trail and checkpoints live in a repository database you choose.

    How do I know nothing was lost?

    Enable the reconciler and drift validator. They compare source and target by key, repair missing rows, and raise alerts through logs and monitoring metrics.

    Get started

    See your own database replicate — and prove it.

    Bring a source and a target. We will run a proof of concept on your infrastructure and show the verification report.