Airbyte alternative — Airbyte vs Skippr

Airbyte is an ELT connector platform. Core is open source and self-hosted. Cloud is managed and billed in credits. Flex keeps the data plane in your VPC and leaves the control plane with Airbyte. The catalog is the point: hundreds of sources built on one CDK, including community Marketplace connectors you verify yourself.

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. ELT into a warehouse is one path, not the product.

Feature	Skippr	Airbyte
Deploy	Single Rust binary, your VPC or on-prem	Core on Kubernetes or abctl. Cloud SaaS. Flex hybrid (their control plane, your data plane)
Schema	In-stream evolution, sibling columns	Per-connector catalog schema; CDC behaviour is source- and version-specific
Storage	Open Iceberg on Parquet you own	Destination you configure (warehouse, lake, database). No in-engine Iceberg ∪ WAL
CDC	Log-based; fails closed if the dest cannot honour	Available on supported databases. Quality and resume semantics vary by connector version
Query	skipprd query on Iceberg ∪ WAL; history in any Iceberg engine	Destination only. Transforms are a later tool
Pricing	Free self-hosted engine	Core is free software. Cloud Standard from $20/month (credits). Flex is quote. You own infra and on-call on Core. See their pricing.

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 Airbyte is good at

The catalog is real. If a long-tail SaaS source exists as an Airbyte connector, you can self-host it or run it on Cloud without waiting for a vendor roadmap. You can read the connector, patch it, and run your fork. That is a genuine difference from closed SaaS ELT.

Cloud is the low-ops path: Standard for hourly syncs, Plus for 15-minute syncs and SSO, Pro for capacity pricing. Flex is the sovereignty path that still uses Airbyte's UI and API. Same CDK either way.

Where the job is wider

Airbyte moves rows. It does not query the stream. You still add dbt (or SQL in the warehouse) for models, and something else if you want live state. Marketplace connectors have no SLA. CDC remains source- and version-specific; a Postgres connector upgrade can change resume behaviour.

Core is not a single binary. Sync jobs spawn containers. Teams running it on Kubernetes report memory spikes, silent "success" jobs, and a platform you operate rather than a pipeline you start. That is a fair trade if you already run Helm competently. It is not the same as skipprd sync.

Cloud credits and sync-frequency caps are the other bill. Standard is hourly. You pay volume or you pay Flex. Skippr does not have a credit meter. It also does not have 700 connectors. If the job is "every SaaS tool in the company, someone else's connector," Airbyte is the narrower, better tool for that slice.

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 Airbyte if the catalog is the job: many SaaS extractors, a CDK you can fork, and you will operate Kubernetes (or pay Cloud/Flex) for ELT into a warehouse you already query.

Choose Skippr if you want one binary, one file, live SQL on Iceberg ∪ WAL, and open Iceberg you keep when the process exits. Fewer connectors. Less platform.

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