Matillion alternative — Matillion vs Skippr

Matillion is visual ELT that leans on your cloud warehouse. You draw orchestration and transformation pipelines. Transformations compile to SQL and push down into Snowflake, BigQuery, or Redshift. The SaaS product is Maia Foundation (formerly Data Productivity Cloud). Credits meter task hours: 1 per orchestration hour, 3 per transformation hour, 1 or 2 per CDC hour. Extra developer seats are 70 credits a month. You also pay the warehouse for the SQL it runs.

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

Feature	Skippr	Matillion
Deploy	Single Rust binary, your VPC or on-prem	SaaS Designer. Classic Matillion ETL is a VM you leave switched on
Schema	In-stream evolution, sibling columns	Pipeline-defined. Pushdown SQL uses warehouse types
Storage	Open Iceberg on Parquet you own	The warehouse you already pay for
CDC	Log-based; fails closed if the dest cannot honour	Streaming pipelines, essential or premium CDC credit rates
Query	skipprd query on Iceberg ∪ WAL; history in any Iceberg engine	Warehouse SQL after the pipeline lands
Pricing	Free self-hosted engine	Credits on task hours plus warehouse compute. 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 Matillion is good at

Pushdown is the honest design. Matillion does not try to be the compute engine. Your warehouse does the joins. For a Snowflake-centric team that wants a visual Designer, Git, and a scheduler, that is a strong fit. Classic ETL on a VM still exists if you want the older product. Validation and sampling in Maia do not burn credits, so you can build a pipeline before you pay to run it.

Where the job is wider

You pay twice: Matillion credits for the run, warehouse credits for the SQL. A full reload that should have been incremental lights both bills. Transformation hours cost 3x orchestration hours. CDC has its own rate. Developer seats add a monthly credit floor even when pipelines are quiet.

Matillion is a warehouse tool. It is not a Streamhouse. There is no Iceberg ∪ WAL query in the engine. Live state waits for the next task hour to finish in Snowflake. If you do not already run a cloud warehouse, you just bought one so Matillion has somewhere to push SQL.

Skippr will not give you Matillion's Designer canvas. If the job is "visual pushdown on Snowflake we already staff," Matillion is the narrower tool. If the job is one binary and live SQL on files you own, Designer 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 Matillion if your warehouse is the compute plane, you want a visual Designer, and you will budget credits plus warehouse time.

Choose Skippr if you want one binary, live SQL on Iceberg ∪ WAL, and no second credit table for the ingest engine.

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