Temporal alternative — Temporal vs Skippr

Temporal is a MIT durable-execution server. Workflows and activities retry across process death; history is the source of truth. Latest named server patch is 1.32.2 (31 Oct 2026). The 1.33.0 line is tagged 1.33.0-166.0 (2 Nov 2026). Self-host is MIT. Temporal Cloud Pay-As-You-Go is 50 USD per million Actions, 0.042 USD per GB-hour active storage, 0.00105 USD per GB-hour retained. Developer has no base fee (support is 10 percent of usage) and 150 USD credits for 90 days. Business is the greater of 500 USD/month or 10 percent of usage (includes 2.5M Actions). Enterprise is a quote. An Action is a workflow start, activity, timer, signal, query, or schedule. There is no first-party Iceberg writer. CDC is a workflow you author. This is not Iceberg ∪ WAL you query in one binary.

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

Feature	Skippr	Temporal
Deploy	Single Rust binary, your VPC or on-prem	Self-hosted server + workers, or Temporal Cloud
Schema	In-stream evolution, sibling columns	Workflow payloads. No Iceberg schema of its own
Storage	Open Iceberg on Parquet you own	Event history. Iceberg only if an activity writes it
CDC	Log-based; fails closed if the dest cannot honour	A workflow you author. Temporal keeps it durable
Query	skipprd query on Iceberg ∪ WAL; history in any Iceberg engine	Workflow Query. Not a lake SQL engine
Pricing	Free self-hosted engine	MIT self-host. Cloud from 50 USD per million Actions.

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

Durable workflows so a long-running business process survives a crash without you rebuilding a state machine. That is the product. Signals, timers, and the SDKs (including Rust GA, 4 Sep 2026) are why some teams put order-lifecycle and ML jobs on Temporal instead of cron. If the job is "this activity must finish even if the worker dies," that is a real product.

Where the job is wider

Temporal is durable execution. It is not a Streamhouse. There is no Iceberg ∪ WAL. There is no skipprd query on in-flight lake rows. Iceberg still starts in PyIceberg, Spark, or Flink inside an activity. Postgres CDC still starts in Debezium or skipprd. Skippr will not replace Temporal Cloud, workers, or the workflow SDK.

The server (or Cloud Actions) and worker fleets are the ops. Skippr will not run Temporal. Airflow, Prefect, and Flyte are separate pages.

If the job is "Temporal we already staff," Temporal is the narrower tool. If the job is live SQL on Iceberg you run, the workflow 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 Temporal if you want durable execution, and Iceberg or CDC as activities you already write is enough.

Choose Skippr if you want one binary, live SQL on Iceberg ∪ WAL, and files that stay yours. Skippr will not run Temporal.

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