---
# === IDENTITY ===
id: business/erp-integration/cdc-implementation-patterns/2026
canonical_question: "How do CDC implementations differ across Debezium, Oracle GoldenGate, Salesforce CDC, and SAP SLT?"
aliases:
  - "Change data capture comparison Debezium GoldenGate Salesforce CDC SAP SLT"
  - "Which CDC tool should I use for ERP integration?"
  - "Debezium vs Oracle GoldenGate vs SAP SLT for real-time data replication"
  - "CDC implementation patterns for enterprise ERP systems"
entity_type: erp_integration
domain: business > erp-integration > cdc-implementation-patterns
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Debezium"
    vendor: "Red Hat / Community"
    version: "3.4.x"
    edition: "Open Source (Apache 2.0)"
    deployment: "self-hosted (Kafka Connect or Debezium Server)"
    api_surface: "Kafka Connect REST, Kafka Topics"
  - name: "Oracle GoldenGate"
    vendor: "Oracle"
    version: "23ai"
    edition: "Enterprise, OCI GoldenGate (managed)"
    deployment: "on-premise, cloud (OCI), hybrid"
    api_surface: "Extract/Pump/Replicat CLI, REST Admin API"
  - name: "Salesforce Change Data Capture"
    vendor: "Salesforce"
    version: "API v66.0 (Spring '26)"
    edition: "Enterprise, Unlimited, Performance"
    deployment: cloud
    api_surface: "Pub/Sub API (gRPC), CometD Streaming"
  - name: "SAP SLT (Landscape Transformation)"
    vendor: "SAP"
    version: "DMIS 2018 SP4+ / S/4HANA 2023+"
    edition: "All S/4HANA editions"
    deployment: "on-premise, hybrid"
    api_surface: "ABAP RFC, database triggers, logging tables"

# === VERIFICATION ===
last_verified: 2026-03-07
confidence: 0.86
version: 1.0
first_published: 2026-03-07

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "Debezium 3.0 (Jan 2025): incremental snapshots, Kafka 4.x support; GoldenGate 23ai (Mar 2025): PostgreSQL logical decoding + Pulsar output"
  next_review: 2026-09-03
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Debezium requires Kafka or Kafka Connect cluster (or Debezium Server for non-Kafka sinks); PostgreSQL logical replication limits task parallelism to 1 slot per connector"
  - "Oracle GoldenGate requires licensing both source AND target processors; OCI managed service ~$0.32/OCPU-hour license-included"
  - "Salesforce CDC shares delivery allocation with Platform Events: 50K events/day baseline (Enterprise); 3-day replay retention only"
  - "SAP SLT uses database triggers (not log-based) which adds write overhead to source system; trigger-based CDC limited to 4 targets pre-DMIS 2018 SP4"
  - "Salesforce CDC only captures standard and custom objects enabled by admin; no schema DDL capture"
  - "GoldenGate Extract process requires supplemental logging enabled on source Oracle database; missed redo logs are unrecoverable"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Need Salesforce-specific event architecture (Platform Events, CDC, Pub/Sub) in depth"
    use_instead: "business/erp-integration/salesforce-streaming-platform-events/2026"
  - condition: "Need general ERP event-driven comparison across all platforms"
    use_instead: "business/erp-integration/erp-event-driven-comparison/2026"
  - condition: "Need CDC for analytics/data warehouse ETL rather than ERP-to-ERP integration"
    use_instead: "N/A — this card covers ERP integration CDC patterns, not analytics ETL pipelines"
  - condition: "Need batch/bulk import comparison instead of CDC"
    use_instead: "business/erp-integration/erp-bulk-import-comparison/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: cdc_use_case
    question: "What is your primary CDC use case?"
    type: choice
    options:
      - "ERP-to-ERP real-time sync"
      - "ERP-to-data-warehouse/lake replication"
      - "event-driven microservices from ERP changes"
      - "audit trail / compliance capture"
  - key: source_system
    question: "What is the source database or ERP system?"
    type: choice
    options:
      - "Oracle Database"
      - "Salesforce"
      - "SAP S/4HANA or ECC"
      - "PostgreSQL / MySQL / SQL Server"
      - "MongoDB"
  - key: budget_constraint
    question: "What is your licensing budget for CDC tooling?"
    type: choice
    options:
      - "Open source only (zero license cost)"
      - "Moderate ($10K-$100K/year)"
      - "Enterprise (>$100K/year, Oracle/SAP licensing acceptable)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/cdc-implementation-patterns/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-07)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/erp-integration/erp-event-driven-comparison/2026"
      label: "ERP event-driven architecture comparison (broader context)"
  related_to:
    - id: "business/erp-integration/salesforce-streaming-platform-events/2026"
      label: "Salesforce Platform Events and Streaming API details"
    - id: "business/erp-integration/change-data-capture-erp/2026"
      label: "General CDC concepts for ERP integration"
    - id: "business/erp-integration/error-handling-dead-letter-queues/2026"
      label: "Error handling and DLQ patterns for integrations"
  alternative_to:
    - id: "business/erp-integration/batch-vs-realtime-integration/2026"
      label: "Batch vs real-time integration decision framework"
  often_confused_with:
    - id: "business/erp-integration/erp-bulk-import-comparison/2026"
      label: "Bulk import comparison (batch, not CDC)"

# === SOURCES ===
sources:
  - id: src1
    title: "Debezium Documentation — Architecture & Connectors"
    author: Red Hat / Debezium Community
    url: https://debezium.io/documentation/reference/stable/architecture.html
    type: official_docs
    published: 2025-12-16
    reliability: authoritative
  - id: src2
    title: "Oracle GoldenGate 23ai Documentation — Configuring Extract"
    author: Oracle
    url: https://docs.oracle.com/en/middleware/goldengate/core/23/coredoc/extract-manage-trail-files.html
    type: official_docs
    published: 2025-03-01
    reliability: authoritative
  - id: src3
    title: "Salesforce Change Data Capture Developer Guide (Spring '26)"
    author: Salesforce
    url: https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_intro.htm
    type: official_docs
    published: 2026-02-01
    reliability: authoritative
  - id: src4
    title: "Salesforce CDC Allocations"
    author: Salesforce
    url: https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_allocations.htm
    type: official_docs
    published: 2026-02-01
    reliability: authoritative
  - id: src5
    title: "SAP Landscape Transformation Replication Server Documentation"
    author: SAP
    url: https://help.sap.com/docs/SAP_LANDSCAPE_TRANSFORMATION_REPLICATION_SERVER
    type: official_docs
    published: 2025-06-01
    reliability: authoritative
  - id: src6
    title: "10 Best CDC Tools (Change Data Capture) for 2026"
    author: Hevo Data
    url: https://hevodata.com/learn/best-cdc-tools/
    type: technical_blog
    published: 2025-11-01
    reliability: moderate_high
  - id: src7
    title: "How to Scale Debezium Deployments"
    author: OneUptime
    url: https://oneuptime.com/blog/post/2026-01-28-scale-debezium-deployments/view
    type: technical_blog
    published: 2026-01-28
    reliability: moderate_high
  - id: src8
    title: "The Best Oracle GoldenGate Alternatives for Real-Time CDC"
    author: Striim
    url: https://www.striim.com/blog/oracle-goldengate-alternatives/
    type: technical_blog
    published: 2025-09-01
    reliability: moderate_high
---

# CDC Implementation Patterns: Debezium vs Oracle GoldenGate vs Salesforce CDC vs SAP SLT

## TL;DR

- **Bottom line**: Debezium is the best default for log-based CDC with open-source budgets and Kafka ecosystems; GoldenGate excels in Oracle-to-Oracle with sub-second latency at enterprise cost; Salesforce CDC is the only option for Salesforce object changes; SAP SLT is the only supported CDC path for SAP HANA replication but uses triggers, not log-based capture.
- **Key limit**: Salesforce CDC shares its 50K event/day delivery allocation with Platform Events (Enterprise edition); GoldenGate requires licensing both source AND target database processors, effectively doubling expected cost.
- **Watch out for**: SAP SLT uses database triggers — not log-based CDC — which adds write overhead to source systems. This is fundamentally different from Debezium and GoldenGate's log-reading approach and can impact source system performance.
- **Best for**: Cross-system comparison when selecting a CDC tool for ERP integration — each tool owns a different niche and none is universally best.
- **Authentication**: Debezium uses database credentials (user/pass or SSL certs); GoldenGate uses Oracle DB credentials + trail file encryption; Salesforce CDC uses OAuth 2.0 (JWT bearer or web server flow); SAP SLT uses RFC credentials (ABAP user + authorization objects).

## System Profile

This card compares four CDC implementations that serve fundamentally different architectural niches. Debezium is an open-source, log-based CDC platform built on Kafka Connect. Oracle GoldenGate is a commercial, high-performance replication engine optimized for Oracle environments. Salesforce CDC is a proprietary, platform-native event stream for Salesforce object changes. SAP SLT is a trigger-based replication server purpose-built for SAP HANA data provisioning.

These tools are not direct substitutes — they operate at different layers of the stack and serve different source system ecosystems. The comparison is valuable when architects must choose a CDC approach for multi-ERP landscapes or heterogeneous data integration.

| System | Role | Capture Method | Primary Target |
|---|---|---|---|
| Debezium 3.4.x | Open-source log-based CDC | Transaction log reading (WAL, binlog, redo) | Kafka topics (any downstream consumer) |
| Oracle GoldenGate 23ai | Commercial log-based replication | Oracle redo log mining / LogMiner | Oracle, PostgreSQL, Kafka, Pulsar |
| Salesforce CDC (Spring '26) | Platform-native change events | Internal Salesforce change tracking | Pub/Sub API (gRPC) or CometD subscribers |
| SAP SLT (DMIS 2018 SP4+) | Trigger-based replication server | Database triggers + logging tables | SAP HANA, SAP BW/4HANA |

## API Surfaces & Capabilities

| CDC Tool | Protocol | Best For | Capture Granularity | Latency | Schema Evolution | Bulk Capable? |
|---|---|---|---|---|---|---|
| Debezium (Kafka Connect) | HTTP REST (mgmt), Kafka protocol (data) | Heterogeneous DB-to-Kafka CDC | Row-level DML + DDL | Sub-second to seconds | Yes (schema registry) | Snapshots only |
| Debezium Server | HTTP REST (mgmt), configurable sinks | Non-Kafka deployments (Pulsar, Kinesis, EventHubs) | Row-level DML + DDL | Sub-second to seconds | Yes | Snapshots only |
| GoldenGate Extract | CLI (GGSCI), REST Admin API | Oracle-to-Oracle, Oracle-to-Kafka | Row-level DML + DDL (committed txns) | 50ms-200ms | Manual DDL replication | Via initial load |
| GoldenGate OCI (Managed) | Web console, REST API | Cloud-native Oracle replication | Same as Extract | 50ms-200ms | Manual | Via initial load |
| Salesforce CDC | gRPC (Pub/Sub API), Bayeux (CometD) | Salesforce object change streaming | Field-level change events | Seconds (near real-time) | Automatic (schema-aware) | No |
| SAP SLT | ABAP RFC, DB triggers | SAP-to-HANA real-time replication | Row-level via trigger capture | Seconds to minutes | Manual (transformation rules) | Initial load + delta |

[src1, src2, src3, src5]

## Rate Limits & Quotas

### Per-Tool Throughput Limits

| Limit Type | Debezium | GoldenGate | Salesforce CDC | SAP SLT |
|---|---|---|---|---|
| Max events/sec (sustained) | 100K+ (Kafka-dependent) | 100K+ (hardware-dependent) | Limited by delivery allocation | Trigger overhead-limited |
| Max concurrent connectors | Unlimited (Kafka Connect cluster) | Per-license (source+target CPUs) | N/A (platform-managed) | Per-configuration (1:N targets from DMIS 2018 SP4) |
| Max message/event size | Kafka default 1 MB (configurable) | Trail file segment 100 MB default | 1 MB per change event | RFC packet size (~64 KB default) |
| Replay/rewind window | Kafka retention (configurable, days-weeks) | Trail file retention (configurable) | 3 days (72 hours) | No replay — triggers are point-in-time |

[src1, src4, src5, src7]

### Salesforce CDC-Specific Allocation

| Limit Type | Value | Window | Edition Differences |
|---|---|---|---|
| Event delivery (CometD + Pub/Sub) | 50,000 baseline | 24h | Enterprise: 50K; with add-on: up to 4.5M/month (enforced monthly) |
| Event publishing | 250,000 | Per hour | Internal (triggers, flows) — generous ceiling |
| Concurrent CometD clients | 1,000 | Per org | Shared across all streaming subscriptions |
| Event replay retention | 3 days | Rolling | Same across all editions |
| Max entities tracked | Admin-selected | N/A | Standard + custom objects; not all standard objects supported |

[src3, src4]

### Debezium Scaling Reference

| Target Throughput | Kafka Connect Workers | Memory/Worker | Connector Tasks | Partitions |
|---|---|---|---|---|
| 1K events/sec | 1 | 2 GB | 1 | 3-6 |
| 10K events/sec | 2 | 4 GB | 2-4 | 12-24 |
| 100K events/sec | 4+ | 4-8 GB | 4-8 | 24-48 |
| 1M events/sec | 8+ | 8 GB | 8-16 | 48+ |

[src7]

## Authentication

| CDC Tool | Auth Method | Credential Type | Rotation | Notes |
|---|---|---|---|---|
| Debezium | Database native | User/password, SSL certificates, Kerberos | Manual credential rotation | Needs SELECT + REPLICATION privileges on source DB |
| GoldenGate | Oracle DB auth + OS auth | DB credentials + trail file encryption keys | Manual; OCI uses IAM | Requires DBMS_GOLDENGATE_AUTH admin package grants |
| Salesforce CDC | OAuth 2.0 | JWT bearer (server-to-server) or web server flow | Refresh tokens auto-rotate; JWT certs manual | Connected App required; API-enabled user profile |
| SAP SLT | RFC user auth | ABAP system user + authorization objects (S_RFC, S_TABU_DIS) | SAP user management (SU01) | Requires RFC trust between source and SLT server |

[src1, src2, src3, src5]

### Authentication Gotchas

- Debezium PostgreSQL connector requires a dedicated replication slot; dropping and recreating the slot loses unprocessed WAL segments permanently. [src1]
- GoldenGate requires supplemental logging enabled at database level (`ALTER DATABASE ADD SUPPLEMENTAL LOG DATA`); forgetting this silently produces incomplete change records. [src2]
- Salesforce CDC subscriptions via Pub/Sub API require the user to have "View All Data" or object-level read permissions; field-level security still applies and can silently exclude fields from change events. [src3]
- SAP SLT RFC user needs exact authorization objects (S_RFC, S_TABU_DIS, S_BTCH_JOB) — missing any one causes silent replication failures with no clear error message. [src5]

## Constraints
<!-- Agents: read this section before recommending any CDC approach from this unit.
     These are hard constraints that must not be violated. -->

- Debezium requires Apache Kafka (or a Kafka-compatible broker) for the Kafka Connect deployment model; Debezium Server is the alternative but has fewer production deployments and less community support. [src1]
- Oracle GoldenGate licensing requires counting processors on BOTH source and target systems, effectively doubling expected license cost. On-premises list price is ~$17,500/processor (NUP not available for production). [src8]
- Salesforce CDC is limited to objects explicitly enabled by an admin in Setup; not all standard objects are supported, and junction objects (many-to-many) are not available for CDC. [src3]
- SAP SLT trigger-based CDC adds write overhead to every INSERT, UPDATE, and DELETE on source tables — each operation writes an additional row to a logging table, doubling write I/O on high-volume tables. [src5]
- Salesforce CDC replay window is 3 days only — if a subscriber is offline for more than 72 hours, events are permanently lost with no recovery path except full re-sync. [src4]
- GoldenGate requires supplemental logging on Oracle source; if redo logs cycle before Extract processes them, those transactions are permanently lost. Size redo logs and Extract checkpoint frequency accordingly. [src2]

## Integration Pattern Decision Tree

```
START — Need CDC for ERP integration
├── What is the source system?
│   ├── Salesforce
│   │   └── Salesforce CDC (only option for SF object changes)
│   │       ├── Need >50K events/day? → Add-on license required
│   │       ├── Need >3-day replay? → Salesforce CDC insufficient → store events externally
│   │       └── Pub/Sub API (gRPC) preferred over CometD for new integrations
│   ├── SAP S/4HANA or ECC → target is SAP HANA?
│   │   ├── YES → SAP SLT (vendor-supported path)
│   │   │   └── Source system performance-sensitive? → size SLT server separately (standalone deployment)
│   │   └── NO (target is Kafka/warehouse) → Debezium with SAP HANA connector or ODP extraction
│   ├── Oracle Database
│   │   ├── Budget for licensing? (>$17.5K/processor)
│   │   │   ├── YES → GoldenGate (lowest latency, best Oracle integration)
│   │   │   └── NO → Debezium with Oracle connector (LogMiner-based, no extra license)
│   │   └── Need bidirectional replication?
│   │       ├── YES → GoldenGate (native bidirectional support)
│   │       └── NO → Debezium is sufficient
│   ├── PostgreSQL / MySQL / SQL Server / MongoDB
│   │   └── Debezium (best open-source coverage, production-proven)
│   │       ├── PostgreSQL → 1 replication slot per connector (parallelism via table grouping)
│   │       └── MySQL → binlog-based, multiple tasks possible
│   └── Multiple heterogeneous sources
│       ├── All open-source DBs → Debezium (one platform, multiple connectors)
│       └── Mix of Oracle + open-source → Debezium for all (or GoldenGate for Oracle + Debezium for rest)
├── What latency is required?
│   ├── <100ms → GoldenGate (tuned) or Debezium (tuned Kafka)
│   ├── <1 second → Debezium (default config sufficient)
│   ├── <10 seconds → Any tool works
│   └── Minutes acceptable → SAP SLT or polling-based approaches
└── What is the budget?
    ├── Zero license cost → Debezium (Apache 2.0)
    ├── Moderate ($10K-100K/yr) → Debezium + Confluent Cloud or OCI GoldenGate BYOL
    └── Enterprise (>$100K/yr) → GoldenGate on-prem or OCI managed
```

## Quick Reference

| Capability | Debezium 3.4.x | Oracle GoldenGate 23ai | Salesforce CDC (Spring '26) | SAP SLT (DMIS 2018 SP4+) |
|---|---|---|---|---|
| **Capture method** | Log-based (WAL, binlog, redo) | Log-based (redo log mining) | Platform-internal tracking | Database triggers + logging tables |
| **Latency** | Sub-second (Kafka-dependent) | 50-200ms (tuned) | Seconds (near real-time) | Seconds to minutes |
| **Delivery semantics** | At-least-once (exactly-once with Kafka txns in 3.3+) | At-least-once (trail-based) | At-least-once (replay-based) | At-least-once (logging table) |
| **Supported sources** | PostgreSQL, MySQL, SQL Server, MongoDB, Oracle, DB2, Cassandra, Vitess, Spanner | Oracle, PostgreSQL (23ai), MySQL, SQL Server, DB2 | Salesforce objects only | SAP ECC, S/4HANA, BW (ABAP-based) |
| **Supported targets** | Kafka (any downstream), Pulsar, Kinesis, EventHubs, Redis, HTTP | Oracle, PostgreSQL, Kafka, Pulsar (23ai), Big Data targets | Pub/Sub API / CometD subscribers | SAP HANA, SAP BW/4HANA |
| **Schema DDL capture** | Yes (via schema history topic) | Yes (manual DDL replication) | No (data changes only) | No (schema must be pre-configured) |
| **Replay / rewind** | Kafka retention (configurable) | Trail file retention | 3 days only | No replay capability |
| **Initial load / snapshot** | Yes (incremental snapshots in 3.0+) | Yes (initial load mode) | No (CDC only) | Yes (full load + delta) |
| **Bidirectional sync** | Not native (requires custom logic) | Yes (native bidirectional) | No | No |
| **Licensing** | Apache 2.0 (free) | ~$17.5K/processor or ~$0.32/OCPU-hr (OCI) | Included (Enterprise+); add-on for high-volume | Included with S/4HANA license |
| **Deployment complexity** | Moderate (Kafka cluster required) | High (specialized DBA skills) | Low (platform-managed) | Moderate (ABAP installation + RFC config) |
| **Exactly-once support** | Yes (Kafka transactions, v3.3+) | No (at-least-once) | No (at-least-once) | No (at-least-once) |

[src1, src2, src3, src5, src6, src8]

## Step-by-Step Integration Guide

### 1. Configure Debezium CDC connector for PostgreSQL

Register a Debezium PostgreSQL connector via Kafka Connect REST API. Requires a running Kafka Connect cluster with the Debezium PostgreSQL plugin installed. [src1]

```bash
# Input:  Running Kafka Connect cluster, PostgreSQL with wal_level=logical
# Output: Connector registered, change events flowing to Kafka topic

curl -X POST http://localhost:8083/connectors \
  -H "Content-Type: application/json" \
  -d '{
    "name": "erp-postgres-cdc",
    "config": {
      "connector.class": "io.debezium.connector.postgresql.PostgresConnector",
      "database.hostname": "erp-db.example.com",
      "database.port": "5432",
      "database.user": "debezium_repl",
      "database.password": "${file:/secrets/pg-password.txt:password}",
      "database.dbname": "erp_production",
      "topic.prefix": "erp.cdc",
      "table.include.list": "public.orders,public.invoices,public.customers",
      "plugin.name": "pgoutput",
      "slot.name": "debezium_erp_slot",
      "publication.name": "dbz_erp_publication",
      "snapshot.mode": "initial",
      "max.batch.size": "4096",
      "max.queue.size": "16384",
      "poll.interval.ms": "100",
      "heartbeat.interval.ms": "10000",
      "schema.history.internal.kafka.bootstrap.servers": "kafka:9092",
      "schema.history.internal.kafka.topic": "erp.schema-history"
    }
  }'
```

**Verify**: `curl http://localhost:8083/connectors/erp-postgres-cdc/status | jq '.connector.state'` -> expected: `"RUNNING"`

### 2. Subscribe to Salesforce CDC via Pub/Sub API (gRPC)

Use the Salesforce Pub/Sub API to subscribe to change events for a specific object. Requires OAuth 2.0 access token and a Connected App with API access. [src3]

```python
# Input:  Salesforce Connected App with OAuth JWT bearer flow configured
# Output: Stream of change events for Account object

import grpc
import avro.io
import io
from salesforce_pubsub_api import pubsub_api_pb2, pubsub_api_pb2_grpc

# Authenticate via OAuth 2.0 JWT bearer flow
access_token = get_salesforce_token()  # Your OAuth implementation
instance_url = "https://yourorg.my.salesforce.com"
tenant_id = "00D..."  # Your org ID

# Connect to Pub/Sub API endpoint
channel = grpc.secure_channel(
    "api.pubsub.salesforce.com:7443",
    grpc.ssl_channel_credentials()
)
stub = pubsub_api_pb2_grpc.PubSubStub(channel)
metadata = [
    ("accesstoken", access_token),
    ("instanceurl", instance_url),
    ("tenantid", tenant_id),
]

# Subscribe to Account change events
def subscribe_to_cdc():
    topic = "/data/AccountChangeEvent"
    fetch_request = pubsub_api_pb2.FetchRequest(
        topic_name=topic,
        replay_preset=pubsub_api_pb2.ReplayPreset.LATEST,
        num_requested=100
    )
    for response in stub.Subscribe(iter([fetch_request]), metadata=metadata):
        for event in response.events:
            # Decode Avro payload
            schema = get_schema(stub, response.schema_id, metadata)
            decoded = decode_avro(event.event.payload, schema)
            print(f"Change: {decoded['ChangeEventHeader']}")
```

**Verify**: Create/update an Account record in Salesforce -> expected: change event appears in subscriber output within seconds.

### 3. Configure Oracle GoldenGate Extract process

Set up an Extract process to capture changes from an Oracle source database. Requires supplemental logging enabled and GoldenGate installed. [src2]

```sql
-- Step 1: Enable supplemental logging on Oracle source
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;

-- Step 2: Create GoldenGate admin user
CREATE USER ggadmin IDENTIFIED BY "SecurePassword123";
GRANT DBA TO ggadmin;
EXEC DBMS_GOLDENGATE_AUTH.GRANT_ADMIN_PRIVILEGE('ggadmin');
```

```
-- Step 3: GoldenGate Extract parameter file (dirprm/ext_erp.prm)
EXTRACT ext_erp
SETENV (NLS_LANG = "AMERICAN_AMERICA.AL32UTF8")
USERID ggadmin, PASSWORD SecurePassword123, ENCRYPTKEY DEFAULT
EXTTRAIL ./dirdat/et
LOGALLSUPCOLS
UPDATERECORDFORMAT COMPACT

TABLE hr.employees;
TABLE fin.invoices;
TABLE fin.payments;
TABLE sales.orders;
```

```bash
# Step 4: Register and start Extract via GGSCI
GGSCI> ADD EXTRACT ext_erp, INTEGRATED TRANLOG, BEGIN NOW
GGSCI> ADD EXTTRAIL ./dirdat/et, EXTRACT ext_erp, MEGABYTES 200
GGSCI> START EXTRACT ext_erp
```

**Verify**: `GGSCI> INFO EXTRACT ext_erp, DETAIL` -> expected: Status `RUNNING`, checkpoint advancing.

### 4. Configure SAP SLT replication

Set up SAP SLT to replicate tables from an SAP ECC or S/4HANA source to SAP HANA. Requires SLT server installed (standalone or embedded) and RFC connection configured. [src5]

```
-- Step 1: Verify SLT server installation (transaction LTRS)
1. Open transaction LTRS in the SLT system
2. Define a new configuration:
   - Source system: RFC destination to SAP source (SM59 connection)
   - Target system: DB connection to SAP HANA
   - Mass transfer ID: unique identifier
   - Number of data transfer jobs: 3-5 (based on sizing)
   - Number of initial load jobs: 5-10

-- Step 2: Configure RFC destination (SM59)
   - Connection type: 3 (ABAP Connection)
   - Target host: source system hostname
   - System number: source system number
   - Logon user: SLT replication user (with S_RFC, S_TABU_DIS authorizations)

-- Step 3: Add tables for replication (LTRC)
1. Open transaction LTRC
2. Select your configuration
3. Add tables: VBAK (Sales Orders), VBAP (Sales Items), BKPF (Accounting Docs)
4. Choose replication mode: "Replicate" (initial load + real-time delta)
```

**Verify**: Transaction `LTRC` -> Data Transfer Monitor -> expected: tables show status "Green" (active replication), delta record count increasing.

## Code Examples

### Python: Debezium CDC consumer with error handling

```python
# Input:  Kafka cluster with Debezium CDC topics
# Output: Processed change events with idempotent handling

from confluent_kafka import Consumer, KafkaError  # confluent-kafka==2.6.1
import json

def create_cdc_consumer(bootstrap_servers, group_id, topics):
    """Consume Debezium CDC events with idempotent processing."""
    consumer = Consumer({
        "bootstrap.servers": bootstrap_servers,
        "group.id": group_id,
        "auto.offset.reset": "earliest",
        "enable.auto.commit": False,  # Manual commit for exactly-once
        "max.poll.interval.ms": 300000,
    })
    consumer.subscribe(topics)

    processed_lsns = set()  # Track processed LSNs for dedup

    try:
        while True:
            msg = consumer.poll(timeout=1.0)
            if msg is None:
                continue
            if msg.error():
                if msg.error().code() == KafkaError._PARTITION_EOF:
                    continue
                raise Exception(f"Consumer error: {msg.error()}")

            event = json.loads(msg.value().decode("utf-8"))
            lsn = event.get("source", {}).get("lsn")

            # Idempotency check — skip already-processed events
            if lsn in processed_lsns:
                consumer.commit(msg)
                continue

            op = event.get("op")  # c=create, u=update, d=delete, r=read(snapshot)
            if op in ("c", "u"):
                after = event.get("after", {})
                process_upsert(event["source"]["table"], after)
            elif op == "d":
                before = event.get("before", {})
                process_delete(event["source"]["table"], before)

            processed_lsns.add(lsn)
            consumer.commit(msg)  # Commit only after successful processing
    finally:
        consumer.close()
```

### Bash: GoldenGate health check and diagnostics

```bash
# Input:  GoldenGate installation with running processes
# Output: Status of all Extract and Replicat processes

# Check all process status
echo "INFO ALL" | $OGG_HOME/ggsci

# Check Extract lag and checkpoint
echo "INFO EXTRACT ext_erp, DETAIL" | $OGG_HOME/ggsci

# Check trail file disk usage
du -sh $OGG_HOME/dirdat/

# View Extract statistics (records processed, errors)
echo "STATS EXTRACT ext_erp, TOTAL, TABLE *.*" | $OGG_HOME/ggsci

# Check for errors in Extract report
tail -50 $OGG_HOME/dirrpt/ext_erp*.rpt
```

## Error Handling & Failure Points

### Common Error Patterns

| CDC Tool | Error | Cause | Resolution |
|---|---|---|---|
| Debezium | `REPLICATION_SLOT_ALREADY_EXISTS` | Previous connector instance not cleaned up | Drop slot: `SELECT pg_drop_replication_slot('slot_name');` then restart |
| Debezium | Kafka lag increasing, connector RUNNING | Slow consumer or insufficient partitions | Scale Kafka Connect workers; increase `max.batch.size` and `max.queue.size` |
| GoldenGate | `OGG-00868: Trail file corrupted` | Disk full during trail write or storage failure | Restore from previous checkpoint; ensure adequate disk space (2x peak trail volume) |
| GoldenGate | `OGG-01028: Extract lag exceeds threshold` | Source redo generation faster than Extract can process | Add parallel Extract threads; increase trail file size; reduce table scope |
| Salesforce CDC | `EXCEEDED_EVENT_DELIVERY_LIMIT` | 50K daily delivery allocation consumed | Purchase Platform Events add-on license; reduce subscribed objects; batch downstream processing |
| Salesforce CDC | Missed events after subscriber downtime | Subscriber offline >72 hours; replay window exceeded | Full re-sync required; implement external event store for longer retention |
| SAP SLT | `IUUC_REPL_RUNTIME: Job cancelled` | Source table locked or RFC timeout | Check SM21 logs on source; increase RFC timeout in SM59; verify table lock status |
| SAP SLT | Trigger creation failure on source | Missing authorizations (S_TABU_DIS) or table space issues | Grant required authorizations to SLT user; verify tablespace availability |

[src1, src2, src3, src5]

### Failure Points in Production

- **Debezium replication slot growth**: If the Kafka Connect consumer stops processing, PostgreSQL WAL segments accumulate indefinitely behind the replication slot, eventually filling the disk and crashing the database. Fix: `Monitor pg_replication_slots for inactive slots; set max_slot_wal_keep_size to limit WAL retention (PostgreSQL 13+)`. [src1]
- **GoldenGate redo log gap**: If Extract falls behind and Oracle recycles redo logs before they are read, those transactions are permanently lost. Fix: `Size redo logs to hold at least 2x the expected Extract processing time; configure FRA (Fast Recovery Area) adequately; use integrated Extract for automatic redo management`. [src2]
- **Salesforce CDC silent field exclusion**: If the integration user lacks field-level security on a field, that field is silently omitted from change events — no error, no notification. Fix: `Grant "View All" object permission or explicit FLS on every field you need in change events; audit field coverage on initial setup`. [src3]
- **SAP SLT trigger-induced deadlocks**: On high-volume source tables, SLT triggers can cause deadlocks with application transactions, leading to both failed business transactions and missed replication events. Fix: `Deploy SLT as a standalone server (not embedded) with dedicated background work processes; schedule SLT replication off-peak for high-volume tables`. [src5]
- **Debezium schema evolution breakage**: Schema changes (ALTER TABLE) during active replication can cause deserialization failures in downstream consumers if the schema registry is not configured. Fix: `Always use Avro + Confluent Schema Registry with compatibility mode set to BACKWARD or FULL; test schema changes in staging first`. [src1]

## Anti-Patterns

### Wrong: Using CDC for bulk data migration

```python
# BAD -- CDC is designed for ongoing change streams, not one-time bulk loads.
# Using Debezium snapshot mode for 500M-row initial migration will:
# 1. Create massive Kafka lag
# 2. Hold a replication slot for hours/days, growing WAL
# 3. Block other replication slots from advancing

config = {
    "snapshot.mode": "initial",  # Scans entire 500M-row table
    "table.include.list": "public.massive_history_table",
    # No batch size or chunk controls for initial snapshot
}
```

### Correct: Use bulk tools for migration, CDC for ongoing sync

```python
# GOOD -- Use purpose-built bulk tools for initial load, then switch to CDC
# Step 1: Bulk migration with pg_dump/COPY or Spark
# pg_dump -t public.massive_history_table | psql target_db

# Step 2: After bulk load completes, start Debezium from current LSN
config = {
    "snapshot.mode": "no_data",  # Skip snapshot, start from current position
    "table.include.list": "public.massive_history_table",
    # Or use "initial" with snapshot.max.threads for parallel snapshots
    # on smaller tables where snapshot is feasible
}
```

### Wrong: Ignoring schema evolution in CDC pipelines

```python
# BAD -- Consuming CDC events as raw JSON without schema validation.
# When source adds a column, downstream breaks with KeyError.

event = json.loads(msg.value())
customer_name = event["after"]["customer_name"]  # Breaks when field renamed
order_total = event["after"]["total"]  # Breaks when type changes to decimal
```

### Correct: Use schema registry with backward compatibility

```python
# GOOD -- Schema Registry enforces compatibility and handles evolution
from confluent_kafka.schema_registry import SchemaRegistryClient
from confluent_kafka.schema_registry.avro import AvroDeserializer

sr_client = SchemaRegistryClient({"url": "http://schema-registry:8081"})
deserializer = AvroDeserializer(sr_client)

# Avro handles missing fields (defaults) and type promotions automatically
event = deserializer(msg.value(), None)
customer_name = event.get("after", {}).get("customer_name", "UNKNOWN")
```

### Wrong: Subscribing to all Salesforce CDC events without filtering

```python
# BAD -- Subscribing to /data/ChangeEvents captures ALL enabled objects.
# Burns through 50K/day delivery allocation in minutes on active orgs.

topic = "/data/ChangeEvents"  # Every object, every field, every change
# A busy org can generate 100K+ events/day just from automated processes
```

### Correct: Subscribe to specific object change events

```python
# GOOD -- Subscribe only to specific objects you need
topic = "/data/AccountChangeEvent"  # Only Account changes
# Or use a Custom Channel to filter specific objects and fields:
# /data/MyCustomChannel (defined in Setup > Change Data Capture)
```

## Common Pitfalls

- **Debezium: PostgreSQL replication slot limit**: PostgreSQL has `max_replication_slots` (default 10). Each Debezium connector uses one slot. Running out of slots causes new connectors to fail silently. Fix: `Set max_replication_slots = 2x expected connectors + headroom; monitor with SELECT * FROM pg_replication_slots`. [src1]
- **GoldenGate: Trail file disk exhaustion**: Trail files accumulate if Pump or Replicat processes lag behind Extract. 100 MB default segment size x thousands of segments = disk full. Fix: `Configure PURGEOLDEXTRACTS in Pump parameters; monitor dirdat/ directory size; set alerts at 70% disk utilization`. [src2]
- **Salesforce CDC: Platform Events allocation sharing**: Salesforce CDC shares its delivery allocation with Platform Events. If your org also uses Platform Events heavily, CDC can be starved of delivery capacity. Fix: `Monitor EventBus usage in Setup > Platform Events > Usage-Based Entitlements; separate high-volume Platform Events to their own add-on allocation`. [src4]
- **SAP SLT: Source system performance impact**: Unlike log-based CDC (Debezium, GoldenGate), SLT triggers execute synchronously with the source transaction. High-frequency tables can see 15-30% write performance degradation. Fix: `Deploy SLT standalone (not embedded in source); use transformation rules to replicate only needed columns; monitor source system response times after SLT activation`. [src5]
- **All tools: Ignoring timezone handling**: CDC timestamps are in the source system's timezone. Debezium uses UTC by default, GoldenGate uses source DB timezone, Salesforce CDC uses UTC, SAP SLT preserves source timezone. Fix: `Normalize all CDC timestamps to UTC at the consumer layer; document timezone expectations in integration contracts`. [src1, src5]
- **Debezium: Connector task failure not auto-recovering**: If a Debezium task fails (e.g., OOM), Kafka Connect does NOT auto-restart it by default. The connector shows RUNNING but the task shows FAILED. Fix: `Configure "errors.retry.timeout": "-1" for infinite retries on transient failures; deploy a connector health check sidecar or use Confluent Control Center for monitoring`. [src7]

## Diagnostic Commands

```bash
# === Debezium Diagnostics ===

# Check connector status and task state
curl -s http://localhost:8083/connectors/erp-postgres-cdc/status | jq '.'

# List all connectors and their states
curl -s http://localhost:8083/connectors?expand=status | jq '.'

# Check PostgreSQL replication slot health
psql -h erp-db.example.com -U debezium_repl -d erp_production \
  -c "SELECT slot_name, active, restart_lsn, confirmed_flush_lsn,
      pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn))
      AS lag_bytes FROM pg_replication_slots;"

# Monitor Kafka consumer group lag for CDC topics
kafka-consumer-groups --bootstrap-server kafka:9092 \
  --describe --group erp-cdc-consumer-group

# === GoldenGate Diagnostics ===

# Check all process status
echo "INFO ALL" | $OGG_HOME/ggsci

# Check Extract checkpoint and lag
echo "SEND EXTRACT ext_erp, STATUS" | $OGG_HOME/ggsci

# View Extract statistics
echo "STATS EXTRACT ext_erp, TOTALSONLY *.*" | $OGG_HOME/ggsci

# Check trail file disk usage
ls -lah $OGG_HOME/dirdat/

# === Salesforce CDC Diagnostics ===

# Check org event delivery usage (REST API)
curl -s "https://yourorg.my.salesforce.com/services/data/v66.0/limits" \
  -H "Authorization: Bearer $ACCESS_TOKEN" | jq '.DailyDeliveredPlatformEvents'

# List objects enabled for CDC
curl -s "https://yourorg.my.salesforce.com/services/data/v66.0/sobjects" \
  -H "Authorization: Bearer $ACCESS_TOKEN" | jq '.sobjects[] | select(.changeDataCaptureEnabled==true) | .name'

# === SAP SLT Diagnostics ===

# Check replication status: Transaction LTRC -> Data Transfer Monitor
# Check trigger status: Transaction LTRS -> Trigger Administration
# Check logging table sizes: SE16 -> table IUUC_REPL_LOG
# Check background jobs: SM37 -> job name IUUC_*
```

## Version History & Compatibility

| Tool/Version | Release Date | Status | Breaking Changes | Migration Notes |
|---|---|---|---|---|
| Debezium 3.4.0 | 2025-12 | Current | Kafka 4.1 baseline | Update Kafka Connect to 4.1+ |
| Debezium 3.3.0 | 2025-10 | Supported | Exactly-once for all core connectors | Enable Kafka transactions for exactly-once |
| Debezium 3.0.0 | 2025-01 | Supported | Incremental snapshots GA, new partition reassignment | Incremental snapshots replace ad-hoc snapshots |
| Debezium 2.7.x | 2024-06 | Maintenance | — | Minimum for Kafka 3.x clusters |
| GoldenGate 23ai | 2025-03 | Current | PostgreSQL source support, Pulsar output | New connector types require 23ai license |
| GoldenGate 21c | 2022-01 | Supported | — | Minimum for OCI GoldenGate managed |
| GoldenGate 19c | 2019-01 | Maintenance | — | Upgrade to 23ai for PostgreSQL support |
| Salesforce CDC (Spring '26) | 2026-02 | Current | Pub/Sub API v2 enhancements | Migrate from CometD to Pub/Sub API |
| Salesforce CDC (Winter '26) | 2025-10 | Supported | — | — |
| SAP SLT DMIS 2018 SP4+ | 2023-01 | Current | New CDC mechanism (1:N targets) | Legacy triggers limited to 4 targets; upgrade for more |
| SAP SLT DMIS 2011 | 2015-01 | Legacy | — | Upgrade required for S/4HANA 2023+ compatibility |

[src1, src2, src3, src5]

### Deprecation Policies

- **Debezium**: Community-driven releases quarterly; no formal deprecation policy but major versions maintained for ~18 months. Connectors follow Kafka Connect API compatibility.
- **Oracle GoldenGate**: Oracle provides Premier Support for 5 years + Extended Support for 3 years. Version-specific support tied to Oracle Database certification matrix.
- **Salesforce CDC**: No separate deprecation — follows Salesforce API version lifecycle (minimum 3-year support, retired in groups). Pub/Sub API supersedes CometD for new development.
- **SAP SLT**: Tied to DMIS add-on lifecycle. DMIS 2018 is the current long-term supported version. Older DMIS versions lose maintenance with each S/4HANA release.

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Need real-time change streaming from relational databases to Kafka | One-time bulk data migration (>100M rows) | pg_dump, Oracle Data Pump, Bulk API, SAP DMF |
| Need event-driven integration between ERP systems | Simple scheduled batch sync (daily/weekly) | business/erp-integration/batch-vs-realtime-integration/2026 |
| Source database supports log-based capture (PostgreSQL WAL, MySQL binlog, Oracle redo) | Source is a SaaS application with no DB access (e.g., Salesforce, Workday) | Platform-native CDC (Salesforce CDC) or API polling |
| Need to capture every change including intermediate states | Only need current state / point-in-time snapshot | Full table replication or API-based sync |
| Budget allows Kafka infrastructure (Debezium) or Oracle licensing (GoldenGate) | Zero infrastructure budget and no Kafka cluster | Platform-native webhooks or managed ETL services |

## Cross-System Comparison

| Capability | Debezium 3.4.x | Oracle GoldenGate 23ai | Salesforce CDC | SAP SLT |
|---|---|---|---|---|
| **Architecture** | Kafka Connect source connector | Standalone Extract/Pump/Replicat pipeline | Platform-native event stream | ABAP-based trigger + logging table |
| **Capture method** | Transaction log reading | Redo log mining (integrated or classic) | Internal object change tracking | Database triggers |
| **Source DB overhead** | Minimal (reads logs, no source writes) | Minimal (reads logs, no source writes) | Zero (platform-managed) | Moderate (trigger writes to logging table) |
| **Latency (typical)** | 100ms-2s | 50-200ms | 1-5 seconds | 5-60 seconds |
| **Throughput ceiling** | 1M+ events/sec (Kafka-dependent) | 100K+ events/sec (hardware-dependent) | 50K-4.5M events/day (edition-dependent) | Hardware-dependent, trigger overhead limits |
| **Exactly-once delivery** | Yes (v3.3+ with Kafka transactions) | No (at-least-once) | No (at-least-once) | No (at-least-once) |
| **Schema evolution** | Automatic (schema registry) | Manual DDL replication | Automatic (platform-managed) | Manual (transformation rules) |
| **Data transformation** | SMTs (Single Message Transforms) | Column mapping, filtering, tokenization | Field selection only | ABAP transformation rules (LTRS) |
| **Replay / rewind** | Kafka offset reset (retention-dependent) | Trail file replay | 3-day replay via replayId | No replay |
| **Bidirectional sync** | No (requires custom logic) | Yes (native) | No | No |
| **Monitoring** | Kafka Connect REST + JMX metrics | GGSCI CLI + Enterprise Manager | Setup > Platform Events usage | LTRC monitor + SM37 |
| **Total cost (typical mid-market)** | $0 license + Kafka infra ($5K-50K/yr) | $50K-500K+/yr (processor licensing) | Included (Enterprise); add-on $10K+/yr for high-volume | Included with S/4HANA license |
| **Skill requirements** | Kafka + SQL DBA | Oracle DBA + GoldenGate specialist | Salesforce admin + developer | SAP Basis + ABAP developer |
| **Cloud-native option** | Confluent Cloud, AWS MSK Connect, Aiven | OCI GoldenGate (managed) | Native (Salesforce platform) | SAP BTP / SAP DI (limited) |

[src1, src2, src3, src5, src6, src7, src8]

## Important Caveats

- Debezium's "exactly-once" semantics (v3.3+) require Kafka transactions enabled on the broker — most existing Kafka clusters run without transactions, and enabling them has a ~10-15% throughput cost.
- Oracle GoldenGate pricing is per-processor-core with Oracle's core factor table — ARM and Intel cores count differently. Always verify the core factor for your specific hardware before estimating cost.
- Salesforce CDC delivery allocations are shared with Platform Events across the org. An org that uses Platform Events for internal automation may have very little allocation remaining for CDC.
- SAP SLT performance impact on the source system is highly variable — simple tables may see <5% overhead while tables with many triggers or complex indexes can see 20-30% write performance degradation.
- This comparison covers CDC for ERP integration patterns. For analytics/data warehouse CDC (Fivetran, Airbyte, AWS DMS), the decision criteria are different — those tools prioritize warehouse connector breadth over latency.
- All throughput numbers are approximate and hardware-dependent. Actual performance depends on source database load, network bandwidth, event size, and downstream consumer speed.
- GoldenGate 23ai's PostgreSQL and Pulsar support is new (March 2025) and may have fewer production deployments than its mature Oracle-to-Oracle path.

## Related Units

- [ERP Event-Driven Integration Comparison](/business/erp-integration/erp-event-driven-comparison/2026)
- [Salesforce Platform Events and Streaming](/business/erp-integration/salesforce-streaming-platform-events/2026)
- [General CDC Concepts for ERP Integration](/business/erp-integration/change-data-capture-erp/2026)
- [Error Handling and Dead Letter Queues](/business/erp-integration/error-handling-dead-letter-queues/2026)
- [Batch vs Real-Time Integration](/business/erp-integration/batch-vs-realtime-integration/2026)