Appearance

Book a call

Meltano alternative — Meltano vs Skippr ​

Meltano is a Git-native ELT CLI. You add Singer taps and targets from Meltano Hub (600+ listings), commit meltano.yml, and run extract-load on your own machines. Open is MIT. There is no UI in Open (it left in v3). There is no built-in scheduler. Airflow, cron, or another runner is yours. Meltano Cloud is a managed plane billed on compute hours, quote only: Starter is 200 hours a month, Growth 2,000, Scale 5,000, Enterprise unlimited. Reverse ETL is a target, same as any other loader.

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

FeatureSkipprMeltano
DeploySingle Rust binary, your VPC or on-premOpen: pip / Docker, you run it. Cloud: managed, quote only
SchemaIn-stream evolution, sibling columnsCatalog from the tap. A new column can sit unseen until you refresh
StorageOpen Iceberg on Parquet you ownWhatever target you add (Snowflake, Postgres, DuckDB, files, …)
CDCLog-based; fails closed if the dest cannot honourIncremental if that tap implements it. Quality varies by tap
Queryskipprd query on Iceberg ∪ WAL; history in any Iceberg engineDestination after the load. No engine-side live SQL
PricingFree self-hosted engineOpen is free. Cloud is compute hours, see their pricing.

What Meltano is good at ​

meltano.yml in Git is the honest design. Plugins lock. CI installs from the lock file. The Singer SDK lets you write a tap without inventing a protocol. Hub is a real catalog: many extractors, fewer loaders, and you can pip install a tap that is not on the Hub. For a team that already runs Python, Airflow, and dbt, and wants extract-load without a MAR bill, that is a real product.

Where the job is wider ​

Hub count is not Hub quality. MeltanoLabs maintains a small default set. The rest are community variants. When an API moves, the fix is whoever owns that fork, or you. Reviewers who like the CLI still say they fork abandoned taps. Schema drift can skip a new column until you refresh the catalog. That is Singer, not a Meltano bug. It is still your on-call.

Open has no scheduler and no UI. Production is Meltano plus Airflow plus alerts you wire. Cloud sells that ops surface on compute hours. Dollar prices are not on the public page.

Meltano is ELT. It is not a Streamhouse. There is no Iceberg ∪ WAL. Query waits for the target. Skippr will not give you 600 Singer listings or a tap SDK. If the source you need is a Hub tap and skipprd does not have it yet, Meltano is the narrower tool for that extract. If the job is live SQL on Iceberg you run, Meltano 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
bash
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")
bash
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 Meltano if you want Singer taps in Git, you will run the orchestrator, and a Hub extractor exists for the source.

Choose Skippr if you want one binary, no compute-hour quote, live SQL, and Iceberg files that stay yours.

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