Appearance

Your Real-Time Data
Open Streamhouse

Deploy the Skippr stream engine in your cloud. Ingest into Iceberg tables. Query, transform, and aggregate live state as it streams.

Get started
Developer Docs

Works out of the box

Skippr is a complete stream platform and warehouse in a single Rust binary. Configure your data sources, implement your SQL-based stream processing, and land Iceberg tables in your bucket.

Zero vendor lock-in

Your data is never trapped. Open source and schema-sink connectors write standard Apache Iceberg on Parquet. Query with any compatible engine.

Privacy by default

CDC, writes and queries stay inside your VPC. Full data residency and sovereignty. We do not take a copy off-site.

Enterprise-ready

Leading ELT Streamhouse ingestion with powerful in-stream schema evolution, exactly-once delivery, and recovery semantics — including full CDC, atomic commits, and strong consistency guarantees.

Get started

Launch the binary.

skipprd is a complete, self-serve engine. Install it, point it at Postgres, and land Apache Iceberg tables in your own bucket. No call required.

Install skipprdDeveloper Docs →

skipprd
$ brew install skipprd/tap/skipprd$ skipprd connect data-source postgres --pipeline orders --name production$ skipprd connect data-sink skippr-lake --pipeline orders --name lake --warehouse 's3://my-lake/' --catalog-table skippr$ skipprd sync --pipeline orders

Skippr is an open Streamhouse ​

A warehouse batch job of last night's extract is not enough. Skippr implements the open Streamhouse architecture: capture continuously from OLTP systems, SaaS APIs, files and streams. Query a real-time, strongly consistent SQL view over committed Iceberg tables and in-stream rows. Iceberg snapshot commits are ACID — atomic, so committed readers never see a half-written table. Skippr surfaces live operational state on open standards, in a deployment you own.

Production database to Iceberg on your S3 bucket Production database streams through local CDC into the skipprd Rust binary, which performs a local multi-threaded write of Iceberg and Parquet into your S3 bucket. Production DatabasePostgres, MySQLSQL Server, MongoDBLocal CDCInserts, updates, deletesStays in your VPCskipprd Rust binaryOne processWAL · schema · IcebergLocal multi-threaded writeParquet filesACID Iceberg snapshotsYour S3 bucketIceberg / Parquet you ownskipprd query · open engines
Production Database → Local CDC → skipprd Rust binary → Local multi-threaded write → Your S3 bucket (Iceberg / Parquet).

Open architecture. Data is never trapped. ​

Most platforms batch into a vendor warehouse, leaving your data locked inside a proprietary plane. Skippr lands Apache Iceberg tables on Parquet in your object store or filesystem. Use Skippr Streamhouse to query, transform, and aggregate committed snapshots and in-stream rows. Committed Iceberg is an open, consistent data architecture — Skippr, Athena, Snowflake, DuckDB, Databricks, Spark, and notebooks can read that history on the same files. No second copy. Zero vendor lock-in.

  • Zero vendor lock-in — open connectors for sources and sinks. Standard Apache Iceberg on Parquet in your bucket. Data is never trapped.
  • Dual query path — strongly consistent live state in Skippr, or committed history through any Iceberg-compatible warehouse engine (including Skippr).
  • Ingest that finishes — CDC including updates and deletes, event streams, files, and APIs. Exactly-once where the destination supports it. Each source declares append, merge, or replace-by-day, and Skippr refuses to start a pipeline the destination cannot honour.
  • In-stream schema evolution — new fields and types are picked up during sync without stopping the pipeline; type conflicts become non-breaking sibling columns.
  • One Rust binary, your machines — an ultra-lightweight, memory-efficient Rust binary. Deploy in your cloud or on-prem.
  • Full sovereignty and privacy — data stays in your deployment. Self-host in your cloud or on-prem — your buckets, your sovereignty.

Why Skippr

Built to replace the expensive defaults

Privacy by default. Each source declares append, merge, or replace-by-day — and Skippr refuses to start a pipeline the destination cannot honour.

AgainstSkippr
vs. FivetranNo volume-based pricing anxiety. Data stays inside your VPC.
vs. Apache FlinkNo complex JVM cluster management. One ultra-lightweight Rust binary.
vs. DuckDBOwns continuous ingest and the live query path. DuckDB and peers read committed Iceberg on open standards — not the in-stream WAL union.
vs. Proprietary ELT & WarehousesZero vendor lock-in. Open connectors and open Iceberg in your bucket mean your data is never trapped.

How the Streamhouse works ​

  1. Capture & ingest — CDC from Postgres, MySQL, SQL Server, MongoDB, DynamoDB, plus Kafka, files, and SaaS APIs land through one engine.
  2. In-stream schema evolution — schema evolves in-stream without dropping pipelines or failing jobs at 2am.
  3. Live query in Skippr — Skippr's SQL engine: strongly consistent SQL over committed Iceberg and in-stream rows.
  4. Open Iceberg storage — atomic snapshots land as standard Parquet and Iceberg metadata in your object store. Data is never trapped.
  5. Historical query anywhere — Athena, Snowflake, DuckDB, Databricks, Spark, and notebooks read the exact same committed Iceberg tables. No second ETL copy.
  6. Downstream consumers — live tables give BI dashboards, applications, and agents fresh context from your private cloud without data leaving your deployment.

You keep the systems you already run. Skippr is the open Streamhouse they write to.

Get started ​

Install skipprd, then land Postgres into Iceberg on a bucket you own. Full flags, Python, and every connector live in Developer Docs.

bash
brew install skipprd/tap/skipprd
skipprd --version
skipprd connect data-source postgres --pipeline orders --name production
skipprd connect data-sink skippr-lake --pipeline orders --name lake \
  --warehouse 's3://my-lake/' --catalog-table skippr
skipprd discover --pipeline orders
skipprd sync --pipeline orders
bash
curl -sL https://raw.githubusercontent.com/skipprd/skipprd/main/install.sh | sh
skipprd --version
bash
pip install skippr
python -c "import skippr; print(skippr.Session)"

Enterprise Jumpstart ​

Skippr works completely out of the box. You do not need a call to land Iceberg tables in your own bucket.

Enterprise Jumpstart is optional: we deploy the binary in your VPC, wire the first sources, and hand you the keys. It is a premium onboarding track for teams that want a founder-engineer in the room for the first pipelines — not how Skippr ships, and not a substitute for the software.

Book a 20-min callWhat Jumpstart covers →

  • PostgreSQL
  • Xero
  • Salesforce
  • Shopify
  • Snowflake
  • Sage
  • Stripe
  • SAP
  • MySQL
  • HubSpot
  • BigQuery
  • QuickBooks
  • MongoDB
  • WooCommerce
  • Databricks
  • Odoo
  • SQL Server
  • Magento
  • Amazon S3
  • Zoho
  • ClickHouse
  • PayPal
  • DuckDB
  • KashFlow
  • DynamoDB
  • Google Analytics
  • Power BI
  • Microsoft
  • Google Ads
  • Excel
  • Meta
  • IRIS
  • Redshift
  • LinkedIn
  • MariaDB
  • SumUp
  • Azure
  • Revolut
  • Oracle
  • Google Cloud
  • PrestaShop
  • Apache Kafka
  • Slack
  • Google Sheets
  • Autodesk
  • Square
  • Tableau
  • Instagram
  • RabbitMQ
  • BigCommerce
  • Bing
  • Looker
  • AdRoll
  • eBay
  • Apple
  • Zendesk

Built for data teams who want the lake, not a project ​

Skippr is for ambitious data teams and startups. You might already have a data team, or want a trusted lake fast. The Skippr Rust binary drops into your cloud or on-prem. Data does not leave your deployment.

  • Working Streamhouse in days, not a six-month project.
  • You keep the stack. You own the tables.
  • Open-source engine with zero vendor lock-in.
Tom Quigley

“Skippr has saved us hundreds of hours of engineering time and thousands of dollars every month. It's a no brainer.”

Tom QuigleyDevOps EngineerLinkedIn

You own the Iceberg tablesZero vendor lock-inOptional Enterprise Jumpstart

Night shift flipped SKU-14 to −4.2% margin

Xero

overtime
£4.1k
labour
£62k

MES

scrap_rate
2.1%
sku
SKU-14

Margin after scrap

8.4%

Business insight

SKU-14 still makes 8.4%.

The open Streamhouse stack. One binary. Your cloud.

Open architecture with zero vendor lock-in. Realtime data in Skippr, historical Iceberg anywhere.

Capture & IngestIn-stream schema evolutionOpen Iceberg storageLive query in SkipprHistorical query anywherePrivacy & sovereignty

Capture & Ingest

Databases, streams, files and SaaS APIs through one engine.

Accounts, ERP, CRM, databases and event streams land in the lake or warehouse you already run. Change data capture includes updates and deletes.

Each source declares how it must be written — append events, merge current state, or rewrite a revised day — and Skippr refuses to start a pipeline the destination cannot honour.

  • CDC from Postgres, MySQL, SQL Server, MongoDB and DynamoDB — updates and deletes included
  • Kafka and event stream ingest with durable landing guarantees
  • Exactly-once delivery where the destination supports it
  • Crash-safe: re-run the same command and it resumes where it stopped
Browse connectors →

You own the Iceberg tables. Open architecture with zero vendor lock-in — your data is never trapped. The engine is open source and self-hosted. It works out of the box.