Timeplus alternative — Timeplus vs Skippr

Timeplus is streaming SQL. Proton is the Apache-2.0 C++ engine (ClickHouse libraries plus a WAL and stream structures). Latest GitHub release is Proton 3.0.32 (30 Oct 2026). One binary, Docker, or Helm. External streams read Kafka, Redpanda, or Pulsar. External tables talk ClickHouse. Iceberg is a CREATE DATABASE … SETTINGS type='iceberg' catalog: REST only (catalog_type='rest'), with Glue Iceberg REST, Amazon S3, and Apache Gravitino documented. Writes go through INSERT INTO or a materialized view (s3_min_upload_file_size on the MV). Compaction is not in the current Iceberg integration. Iceberg reads behave like static tables: the query returns and terminates. Continuous streaming reads of Iceberg are listed as future. CDC is a Kafka (or similar) external stream, or Timeplus's own revision processing on those streams, not a Postgres WAL connector. Proton is free to self-host. Timeplus Enterprise Cloud starts at 199 USD a month (dedicated, up to 32 CPU / 128 GiB, from 250 GiB SSD, 99.5% SLA, 14-day trial). Self-hosted or BYOC Enterprise is an annual custom quote (30-day trial, support within 4 hours). This is not Iceberg ∪ WAL you query in one Skippr 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 Proton server. ELT into a warehouse is one path, not the product.

Feature	Skippr	Timeplus
Deploy	Single Rust binary, your VPC or on-prem	Proton binary / Docker / Helm, or Timeplus Enterprise Cloud / BYOC
Schema	In-stream evolution, sibling columns	Timeplus SQL DDL. Iceberg via REST catalog
Storage	Open Iceberg on Parquet you own	Proton streams. Iceberg REST writes; compaction not yet
CDC	Log-based; fails closed if the dest cannot honour	External stream (Kafka / Redpanda / Pulsar). Not Postgres WAL
Query	skipprd query on Iceberg ∪ WAL; history in any Iceberg engine	Streaming SQL on Proton streams. Iceberg SELECT is batch and exits
Pricing	Free self-hosted engine	Proton Apache-2.0. Cloud from 199 USD/month. BYOC is custom.

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

Streaming SQL in a C++ binary: windows, multi-stream joins, incremental materialized views, and Kafka-protocol sources without standing up Flink. That is the product. Native Iceberg REST writes (no JVM) is why some teams land Parquet from Proton instead of a Spark job. If the job is "this Kafka topic through this SQL into this Iceberg table," that is a real product.

Where the job is wider

Timeplus is a streaming SQL engine with an Iceberg catalog adapter. It is not a Streamhouse in the Skippr sense. There is no Iceberg ∪ WAL you query as one committed-plus-in-flight surface. Iceberg SELECT in Timeplus finishes. Compaction is still yours (Spark, or wait). catalog_type is REST only. Postgres CDC still starts before Kafka.

Proton-plus-catalog is the ops. Small files until someone compact, Glue SigV4 settings, and Enterprise CPU/SSD if you are not on Apache Proton alone. Skippr will not replace a Timeplus MV that already joins Kafka streams. Skippr also will not run Proton. Flink and ksqlDB are separate pages.

If the job is "Timeplus SQL we already staff," Timeplus is the narrower tool. If the job is live SQL on Iceberg you run from Postgres CDC, Proton 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 Timeplus if you want streaming SQL on Kafka-protocol sources, and Iceberg REST append from Proton is enough.

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

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