Kafka Connect Iceberg alternative — Kafka Connect Iceberg vs Skippr

The Apache Iceberg Kafka Connect sink (org.apache.iceberg.connect.IcebergSinkConnector) writes Kafka topic records into Iceberg tables. Current Iceberg release is 1.12.0 (29 Sep 2026); Maven artifact iceberg-kafka-connect matches. Features listed in the Iceberg docs: centralized commit coordination, exactly-once via KIP-447 (Kafka 2.5 or later), multi-table fan-out, optional auto-create and schema evolution, column mapping, and Parquet variant shredding (write.parquet.shred-variants). Default control topic is control-iceberg. Default commit interval is 300,000 ms (five minutes). Catalogs include REST, Glue, Hive, Hadoop, Nessie, JDBC, and BigQuery Metastore. Auto-create and evolve-schema both default to off. CDC is not the sink. A Debezium (or DMS) source still writes the topic; DebeziumTransform and DmsTransform SMTs exist for the sink's CDC path and are marked experimental. There is no licence fee. You pay Kafka, Connect workers, disks, and people. Confluent Cloud treats it as custom Connect (task-hours plus GB), not a first-party managed connector. This is not a Streamhouse. There is no Iceberg ∪ WAL.

Skippr is an open Streamhouse you run as one Rust binary. Write skippr.yml (or the same thing in Python), discover, sync. You query live state over Iceberg ∪ WAL, and the history is ordinary Iceberg in your bucket. No Connect cluster. ELT into a warehouse is one path, not the product.

Feature	Skippr	Kafka Connect Iceberg
Deploy	Single Rust binary, your VPC or on-prem	Kafka Connect workers plus the Iceberg sink plugin
Schema	In-stream evolution, sibling columns	Connect converters plus optional evolve-schema-enabled
Storage	Open Iceberg on Parquet you own	Iceberg after the sink. Catalogs: REST, Glue, Hive, Nessie, …
CDC	Log-based; fails closed if the dest cannot honour	Debezium (or DMS) onto the topic. SMT CDC helpers are experimental
Query	skipprd query on Iceberg ∪ WAL; history in any Iceberg engine	After the commit. Default interval five minutes
Pricing	Free self-hosted engine	Apache-2.0. Pay Kafka and Connect. Cloud is custom-connector rates.

Talk through skipprd now

Paul Bot knows the docs. Google Meet as soon as you join, any time of day.

Chat now →

Any time · 20 minutes · Google Meet now

What Kafka Connect Iceberg is good at

A Kafka topic you already run that needs to land as Iceberg without a Spark job. That is the product. Exactly-once commits through a coordinator, multi-table fan-out, and REST/Glue catalogs in the same plugin are why lake teams still install it. If the job is "this topic into this table," that is a real product.

Where the job is wider

The sink is a Connect plugin. It is not a Streamhouse. There is no Iceberg ∪ WAL. There is no skipprd query on in-flight rows. Postgres is not a Connect Iceberg source. CDC starts before the sink: Debezium Server or Connect source, then this writer. The Debezium SMT is experimental. Auto-create and schema evolution are flags you turn on.

The workers are the ops. Control topic, commit interval, coordinator failures (iceberg.control.commit.max-consecutive-failures defaults to 1), and a JVM per worker. Skippr will not replace a Kafka bus. Skippr also will not run Connect. Debezium is a separate page. Tableflow is the Confluent-managed sibling.

If the job is "Connect Iceberg we already staff," the sink is the narrower tool. If the job is live SQL on Iceberg you run, Connect was never that.

Getting started

Install skipprd from the install guide, or pip install skippr. The three tabs write the same skippr.yml. Then discover, sync, and query.

YAML

skippr:
  workspace: analytics
  skipprd_el_storage_mode: local

pipelines:
  orders:
    data_source: data_sources.app_db
    data_sink: data_sinks.lake

data_sources:
  app_db:
    Postgres:
      host: db.internal
      user: skippr_reader
      password: ${APP_DB_PASSWORD}
      database: app
      tables: [orders, customers]
      cdc_mode: snapshot_then_cdc

data_sinks:
  lake:
    AthenaIceberg:
      warehouse: s3://my-iceberg-warehouse/
      glue_database_name: analytics
      athena_workgroup_name: primary
      athena_results_s3_bucket: my-athena-results
      region: us-east-1
    schema_sink: schema_sinks.lake_schema

schema_sinks:
  lake_schema:
    AthenaIceberg:
      warehouse: s3://my-iceberg-warehouse/
      glue_database_name: analytics
      athena_workgroup_name: primary
      athena_results_s3_bucket: my-athena-results
      region: us-east-1

CLI

skipprd --workspace analytics --storage-mode local connect data-source postgres \
  --pipeline orders \
  --name app_db \
  --host db.internal \
  --user skippr_reader \
  --password '${APP_DB_PASSWORD}' \
  --database app \
  --tables orders \
  --tables customers \
  --cdc-mode snapshot_then_cdc

skipprd connect data-sink athenaiceberg \
  --pipeline orders \
  --name lake \
  --warehouse s3://my-iceberg-warehouse/ \
  --glue-database-name analytics \
  --athena-workgroup-name primary \
  --athena-results-s3-bucket my-athena-results \
  --region us-east-1

skipprd connect schema-sink athenaiceberg \
  --pipeline orders \
  --name lake_schema

Python

from skippr import (
    Config,
    DataSinkAthenaIceberg,
    DataSourcePostgres,
    DataSourcePostgresSourceCdcMode,
    EnvRef,
    LocalStorage,
    Pipeline,
)

cfg = Config().workspace("analytics").storage(LocalStorage())

app_db = cfg.data_source(
    "app_db",
    DataSourcePostgres(
        host="db.internal",
        user="skippr_reader",
        password=EnvRef("APP_DB_PASSWORD"),
        database="app",
        tables=["orders", "customers"],
        cdc_mode=DataSourcePostgresSourceCdcMode.SNAPSHOTTHENCDC,
    ),
)

lake = cfg.data_sink(
    "lake",
    DataSinkAthenaIceberg(
        warehouse="s3://my-iceberg-warehouse/",
        glue_database_name="analytics",
        athena_workgroup_name="primary",
        athena_results_s3_bucket="my-athena-results",
        region="us-east-1",
    ),
    schema_sink="lake_schema",
)

cfg.pipeline("orders", Pipeline(data_source=app_db, data_sink=lake))
cfg.save("skippr.yml")

export APP_DB_PASSWORD='your-postgres-password'
skipprd discover --pipeline orders
skipprd sync --pipeline orders --once
skipprd query "SELECT count(*) FROM analytics.orders"

Which to choose

Choose the Iceberg Kafka Connect sink if you already run Kafka Connect, and writing that topic into Iceberg is the job.

Choose Skippr if you want one binary, live SQL on Iceberg ∪ WAL, and files that stay yours. Skippr will not run Connect workers.

Install from Install. Connector and query reference live in Developer Docs. For optional onboarding in your VPC, Enterprise Jumpstart or Contact.