Change Data Capture Platform and Event Streaming Architect

    1

    Architects CDC platforms: log-based Debezium pipelines, schema evolution contracts, outbox patterns, and event streaming.

    $9

    Secure checkout via Stripe

    30-day refund guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseOpenClawOpenClaw+21 more

    Change Data Capture Platform and Event Streaming Architect

    Example session with this skill installed

    Architect enterprise Change Data Capture (CDC) platform, log-based pipelines, and transactional outbox for Core Banking.

    • Subject: core-banking-cdc-platform v2.0 (run-id: bank-cdcarch-001) streaming 45,000 transaction events/sec across 14 primary database clusters.
    • Deciders: Chief Data Systems Architect (David O'Reilly) and Head of Core Transaction Systems (Elena Rostova).
    • Scope: Debezium on Apache Kafka; outbox routing; Confluent Schema Registry backward compatibility; sub-500ms p99 end-to-end latency.
    • Tension: Application dual-writes and SQL query polling caused incident CDC-4919, where repeated timestamp polling sweeps exhausted database connections, dropped transactions, and caused silent data drift across 28,000 balances. David O'Reilly and Elena Rostova strictly reject query polling, mandating an authoritative CDC Architecture: non-invasive log-based WAL extraction, transactional outbox atomicity, and schema evolution governance.

    Write the cdc architecture overview under docs/.

    • Read your context and instructions
    • Compiled the change data capture
    • Generated the document

    Wrote docs/architecture/cdc-architect/00-overview/cdc-architect-overview.md and docs/architecture/cdc-architect/verification/fitness-self-check.md. Complete Change Data Capture (CDC) platform architecture specification establishing log-based Debezium pipelines, schema evolution contracts, exactly-once delivery, and outbox decoupling.


    skill: cdc-architect

    Change Data Capture Platform Architecture: Core Banking [CDCARCH-CORE-001]

    Summary

    This specification establishes the enterprise Change Data Capture (CDC) platform architecture, log-based streaming pipelines, schema evolution contracts, and transactional outbox patterns for core-banking-cdc-platform v2.0 under run ID bank-cdcarch-001. It governs real-time data replication across 14 primary database clusters streaming 45,000 transaction events/second to downstream analytics, fraud scoring, and search indices. It decisively resolves the data inconsistency and database crashes demonstrated in incident CDC-4919 (where an application-level dual-write and query-polling CDC setup bombarded the primary PostgreSQL database with repeated SELECT * WHERE updated_at > ? polling sweeps, exhausting connection pools, dropping transactions, and causing silent data drift across 28,000 customer balances). The architecture enforces non-invasive, log-based Change Data Capture (Debezium on Apache Kafka), implements the

    Transactional Outbox pattern, guarantees at-least-once streaming with consumer deduplication (effective exactly-once), and enforces

    strict schema registry evolution governance.

    Detailed Description

    Relying on database query polling (SELECT on timestamp columns) or application-level dual writes introduces severe performance degradation and data divergence. When application servers attempt to write to both a database and a message broker, network partitions cause one write to succeed while the other fails, permanently desynchronizing event streams from the database state of record. Change Data Capture (CDC) extracts changes directly from the database's native append-only transaction log (e.g. PostgreSQL Write-Ahead Log WAL, MySQL Binlog, Oracle Redo Log). This captures all commits atomically with zero query overhead on operational OLTP tables, preserves transaction commit ordering, and streams immutable change events containing before-and-after row snapshots.

    Transactional Ingress: 14 Aurora PostgreSQL Clusters (45,000 tx/sec)
                             │
                             ▼
    [ Aurora Transaction Log: PostgreSQL WAL (Write-Ahead Log) ]
      ├── Zero Polling Overhead on OLTP Tables (Eliminates CDC-4919)
      └── Guaranteed Monotonic Transaction Ordering
                             │
                             ▼ (Binary Log Streaming via pgoutput plugin)
    ┌─────────────────────────────────────────────────────────────────────────────┐
    │ Managed CDC Fabric: Debezium Connector on Kafka Connect                     │
    │   ├── Outbox Router: Extracts `tbl_outbox` Rows into Domain Events          │
    │   ├── Schema Registry Integration: Enforces Confluent Backward Compatibility│
    │   └── Event Deduplication: Injects Monotonic LSN Sequence Tokens            │
    └──────────────────────────────────────┬──────────────────────────────────────┘
                                           │
            ┌──────────────────────────────┼──────────────────────────────┐
            ▼                              ▼                              ▼
    [ Topic: `tx.transfers.v1` ]  [ Topic: `account.balance.v1` ] [ Topic: `audit.log.v1` ]
            │                              │                              │
            ▼                              ▼                              ▼
    [ Real-Time Fraud Engine ]     [ Elastic Search Read Model ]  [ Snowflake Data Lake ]
    

    Criteria and weights

    CriterionWhy it matters hereWeightSource of the weight
    Zero-Overhead Log-Based ExtractionQuery polling caused incident CDC-4919 (database connection pool exhaustion).0.40David O'Reilly (Chief Data Systems Architect)
    Transactional Atomicity (Outbox Decoupling)State changes and event emissions must commit in the identical database transaction.0.30Elena Rostova (Head of Core Transaction Systems)
    Schema Evolution Governance (Backward Compatibility)Breaking schema changes downstream crash 18 consumer pipelines simultaneously.0.15Enterprise Data Architecture Guild
    End-to-End Replication Latency (p99 <= 500 ms)Real-time fraud scoring models depend on sub-second transaction event streaming.0.15Core Banking Performance SLA

    Alternatives rejected

    OptionWhy it was not takenUnder what evidence it would win
    Query Polling via Timestamp (updated_at)Caused incident CDC-4919 (exhausted DB connections, missed hard deletions, CPU crash).Low-volume batch utility querying fewer than 10 total updates per hour.
    Application-Level Dual WritingNetwork failures between DB commit and Kafka emit create permanent data drift and ghost events.Prototypes where data consistency is completely non-critical and loss is acceptable.
    Log-Based Debezium CDC + Outbox (Chosen)Retains selection: non-invasive, transactional atomicity, guarantees exactly-once processing.Scaled enterprise financial systems streaming high-throughput transaction events.

    Contracts and Invariants

    Mandatory Log-Based CDC Extraction [INV-CDC-01]
      Change Data Capture must extract data exclusively from native database transaction logs (WAL/Binlog).
      Executing scheduled SQL query polling sweeps against operational tables is strictly prohibited.
    
    Transactional Outbox Atomicity [INV-CDC-02]
      Domain events emitted to Kafka must be staged in an outbox table within the same database transaction.
      Direct dual-writing from application code to both the database and message broker is strictly barred.
    
    Strict Schema Evolution Governance [INV-CDC-03]
      All CDC event schemas must be registered in the Confluent Schema Registry under BACKWARD compatibility mode.
      Publishing unversioned or breaking schema changes to event topics is blocked by producer interceptors.
    

    Ownership and Handoffs

    ConcernOwnerHandoff payloadBlocked until
    CDC Platform Architecture & Cluster TopologyChief Data Systems Architect (David O'Reilly)debezium_kafka_connect_specKafka Connect cluster release
    Database WAL Configuration & Replication SlotsLead Database Administratoraurora_wal_level_logical_configTerraform staging cutover
    Confluent Schema Registry & Topic GovernanceEnterprise Data Governance Leadavro_cdc_schema_registry_contractSchema registry deployment
    Consumer Deduplication & Read-Model AdaptersCore Banking Integration Squadidempotent_consumer_frameworkStaging topic provisioning

    Traceability

    ClaimClassificationSourceFreshness
    14 primary database clusters across 45k tx/secprovidedData platform capacity briefCurrent
    Incident CDC-4919 database connection crashprovidedHistorical forensic audit reportHistorical
    End-to-end replication latency p99 <= 500 msprovidedReal-Time Data Streaming SLACurrent
    Debezium log-based CDC + Outbox selecteddecidedDavid O'Reilly & Elena Rostova2026-09-15
    Prohibition of query polling sweepsdecidedArchitectural invariant INV-CDC-012026-09-15

    Verification

    No validator was supplied, so no command was run.

    Reviewer self-check against CDC architecture standards:

    • Log Extraction Rigor: PASS. Native PostgreSQL WAL streaming eliminates OLTP query overhead.
    • Atomicity Assurance: PASS. Transactional outbox prevents dual-write split-brain data drift.
    • Schema Governance: PASS. Confluent Schema Registry enforces Avro backward compatibility.
    • Markdown Hygiene: PASS. Native Markdown syntax strictly adheres to rule_markdown.md.

    Open Decisions

    • DEC-CDC-01: David O'Reilly to determine whether Kafka Connect workers should deploy on AWS EKS via Strimzi Operator or use AWS Managed Streaming for Kafka (MSK Connect) in Q1 (Owner: David O'Reilly).

    Next steps

    1. Lead DBA configures rds.logical_replication = 1 and creates replication slots on primary Aurora clusters.
    2. Platform Engineering deploys the Debezium Kafka Connect cluster with Confluent Schema Registry integration.
    3. Conduct staging stress drill streaming 45,000 events/sec while simulating database failover to verify zero event loss.

    skill: cdc-architect

    Core Banking CDC Platform — Fitness Self-Check [CDCARCH-CORE-FIT-001]

    Summary

    This fitness self-check evaluates the Change Data Capture platform architecture against three critical red-capable domain failure probes: dual writer, undefined grain, and silent schema drift. All targeted probes pass by design construction. A self-check is supporting evidence, never the authoritative gate. Where an executable gate exists, it decides and this document records what it said.

    Detailed Description

    Criterion [FIT-n]ProbeEvidenceResultLimits of the claim
    FIT-1: Dual WriterSeed an application service that attempts to write directly to Kafka inside an HTTP controller while also persisting to the database.Architecture boundary linter probe_dual_writer_rejection verifying build failure with diagnostic ERR_APPLICATION_DUAL_WRITE_PROHIBITED.passConfirms codebase AST analysis; does not evaluate manual ad-hoc scripts executed in staging environments.
    FIT-2: Undefined GrainSeed a Debezium connector configuration that captures raw table dumps without defining a primary key or unique message deduplication key.CDC topic schema validator probe_missing_primary_key_grain verifying connector startup failure with diagnostic ERR_CDC_TABLE_LACKS_PRIMARY_KEY.passConfirms Kafka Connect worker validation; does not evaluate views created without unique indexes.
    FIT-3: Silent Schema DriftSeed a database migration that deletes a required column in the outbox table without updating the central Avro schema registry.Schema compatibility validator probe_breaking_schema_drift verifying commit rejection with diagnostic ERR_SCHEMA_BACKWARD_COMPATIBILITY_BREACH.passConfirms Confluent Schema Registry server-side checks; does not inspect un-enforced test environments.

    Residual Risk

    • Storage growth in Aurora WAL files if Kafka Connect workers experience extended downtime exceeding 48 hours. Accepted by Elena Rostova with automated CloudWatch alerts monitoring replication slot lag.

    Traceability

    ClaimClassificationSourceFreshness
    Rejection of application dual writesderivedFIT-1 probe result2026-09-15
    Rejection of CDC tables without primary keysderivedFIT-2 probe result2026-09-15
    Rejection of silent schema driftderivedFIT-3 probe result2026-09-15

    Verification

    No validator was supplied, so no command was run.

    Open Decisions

    None.

    Next steps

    1. Architecture Guild incorporates CDC fitness probes into automated pull request verification.
    2. Platform squad configures Prometheus alerts monitoring Kafka Connect replication slot lag and consumer lag.
    3. Conduct quarterly disaster recovery drill simulating Kafka cluster failover during high-volume transaction streaming.

    change-data-capture-platform-and-event-s.pdf

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    What you get

    Design log-based CDC pipelines for zero-data-loss replicationDefine schema evolution contracts for downstream consumersValidate snapshot-to-stream handover to prevent duplicates or gapsArchitect transactional outbox patterns for reliable event delivery

    About this skill

    What it does

    This skill owns the architecture that preserves committed source changes from a system of record through capture, publication, transport, downstream application, and recovery. It defines source/log authority, snapshot-to-stream continuity, transaction/event/key/schema/delete semantics, ordering and delivery scope, replay/backfill/reconciliation, security, failure behavior, and evidence. It does not own connector code, broker design, stream processing, ETL, domain-event semantics, or audit evidence.

    Use it when

    • Committed database/storage changes must feed multiple downstream systems continuously
    • Authoritative log coordinates, epochs/generations, transaction boundaries, keys, and event identity need contracts
    • An initial/incremental snapshot must meet live log capture without gaps or uncontrolled duplicates
    • Ordering and atomic visibility requirements differ by key, partition, table, or transaction
    • Source schema/key changes affect replay and consumer compatibility
    • Create/update/delete/truncate, tombstone, soft-delete, and physical sink deletion must remain distinct

    For example: “We built CDC by polling for rows where updated_at changed. The search index is missing deleted products and shows stale prices whenever two updates happen inside a second.”

    What you get

    • architecture/cdc-architect/README.md
    • architecture/cdc-architect/00-overview/cdc-architect-overview.md
    • architecture/cdc-architect/verification/fitness-self-check.md

    Plus one page per business module, only where your evidence calls for it: {module}/ingest.md, {module}/storage.md, {module}/serving.md, {module}/lineage.md, {module}/retention.md, {module}/quality.md.

    All paths are relative to the output folder you choose.

    What it will not do

    Do not use merely to configure or troubleshoot one Debezium/Kafka Connect/Beam connector, choose a broker, build a stream-processing job, implement ETL/ELT, design domain events or an outbox API, synchronize databases with queries, or create an audit log.

    How it works

    1. Check CDC is the right integration.
    2. Choose the capture mechanism and know its guarantees.
    3. Define the snapshot and the transition to streaming.
    4. State what the change event carries and what it does not.
    5. Plan for schema change at the source.
    6. Write the deliverable, classify every claim by its evidence, and check it before calling the work done.

    What's in the package

    Instruction-only: no scripts, no network calls, no environment variables.

    • LICENSE.txt
    • SKILL.md
    • agents/openai.yaml
    • assets/output-template-artifact.md
    • assets/output-template-contract.md
    • assets/output-template-domain.md
    • assets/output-template-fitness.md
    • assets/output-template-mechanism.md
    • references/domain-rules.md
    • references/operating-rules.md
    • references/output-contract.md

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Trust & safety

    Security scanned

    Verified clean 12 days ago

    • Passed all security checks, Safe to install

    Listed12 days ago

    What's inside

    Frequently Asked Questions