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

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 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

    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.

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

    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

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Data & Databases.

    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 to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Read Files
    Write Files

    Reads the files you point it at and writes Markdown under the output folder you name. No network access, no environment variables, and no bundled scripts.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    No. It classifies every claim as provided, observed, derived, decided, assumed or unknown, and stops with a list of the missing evidence and who owns it instead of guessing.

    No. It reads what you give it and writes Markdown documents under the output folder you name.

    Any agent that supports SKILL.md skills, including Claude Code, Codex CLI, Cursor and Gemini CLI. It has no scripts and makes no network calls.

    Unzip it into your agent's skills folder, for example: unzip cdc-architect.zip -d ~/.claude/skills/

    New in Data & Databases