Fivetran alternative — Fivetran vs Skippr

Fivetran is managed ELT. You point a connector at a source, it lands rows in a warehouse or a Fivetran-managed Iceberg lake, and you pay Monthly Active Rows. Transforms run in dbt after the load. Fivetran and dbt Labs completed their merger in June 2026, so ingest and SQL modelling now sit in one company. Census is sold as Fivetran Activations on the same MAR meter.

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

Feature	Skippr	Fivetran
Deploy	Single Rust binary, your VPC or on-prem	SaaS. Hybrid is an Enterprise option
Schema	In-stream evolution, sibling columns	Connector-maintained schema; drift handled in their plane
Storage	Open Iceberg on Parquet you own	Warehouse tables, or Managed Data Lake Iceberg in your cloud storage
CDC	Log-based; fails closed if the dest cannot honour	Log-based on supported databases, billed as MAR
Query	skipprd query on Iceberg ∪ WAL; history in any Iceberg engine	Destination warehouse, or Lake Compute (DuckDB, private beta) on the lake
Pricing	Free self-hosted engine	Usage-based MAR. From 1 Jan 2026 inserts, updates, and deletes count. Standard connections have a $5 minimum per active connection. 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 Fivetran is good at

Fivetran is the default managed connector plane for a reason. Hundreds of maintained sources, incremental sync, and a UI that a data team can leave running. If you only need SaaS and database rows in Snowflake or BigQuery, and you will pay MAR for that reliability, it does that job well.

The dbt merger puts hosted model runs on the same contract. Activations (the old Census product) reverse-ETL out of the warehouse on the same MAR curve. Managed Data Lake Service writes Iceberg into a bucket you name, with a REST catalog Fivetran hosts. That is a real lake path, not a rumour.

Where the job is wider

Fivetran prices unique primary keys that change in a calendar month. Change a lot of old rows and the bill moves with them. Deletes count toward paid MAR from January 2026. A quiet source still incurs the per-connection minimum on paid plans.

The data path is still extract-and-load, then transform somewhere else. Hosted dbt does not run against the lake destination; Lake Compute is a separate DuckDB engine in private beta. You do not get in-stream schema evolution with sibling columns, and you do not get skipprd query over committed Iceberg plus the in-flight WAL. Query happens after the load, in their destination or theirs-plus-DuckDB.

Fivetran is SaaS. Enterprise hybrid keeps more of the worker in your network. It is not a single binary you start on a laptop and keep in your VPC with no vendor plane.

Skippr does not match Fivetran's connector catalog. If you need 400 long-tail SaaS extractors with someone else on-call for API drift, Fivetran 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 Fivetran if you want someone else to own connector maintenance, you are happy with MAR, and the destination is a warehouse (or their managed Iceberg lake) you already query with dbt.

Choose Skippr if you want the same Postgres (or file, or CDC) load without a row meter, live SQL before the warehouse batch, and Iceberg files that stay yours when the binary stops. One file, one engine, your machines.

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