Datamake is a build system for data products
Built to do exactly one thing: reduce time to value for data. Package SQL transforms, the data they produce, and a versioned contract into one self-contained unit called a cell, and serve it as a REST API. One binary, no warehouse ticket, no orchestration platform.
One cell, from sources to consumers
A cell is a software module for data: everything inside is private and free to change. The only way in is the declared, versioned interface.
Sources
Parquet on object storages3://lake/orders/*.parquet Warehouse tablesread-through with filter pushdown Other cellsversioned exports, by nameDatamake cell
Consumers
REST + OpenAPIGET /orders_daily@2?region=us-east DuckDB, read-onlydatamk attach Downstream cellsbuild on pinned releasesStorage is Parquet, the catalog is DuckLake, the engine is embedded DuckDB. Open formats end to end, so your data is never held hostage by the tool.
Why composable data products?
You already run warehouse + dbt + Airflow.
But not every use case belongs there, and it's the only paved road. So every new data product costs a ticket, a queue, and a shared bill.
Datamake is the release valve.
Deploy exactly what one data product needs, with or without the monolith.
Key features
Data contracts that can't lie
Every run verifies actual output against the declared schema and grain. Drift fails the build: not a warning, a failure.
Atomic snapshots
All transforms commit as one snapshot. Consumers never see a half-built state, and releases pin the exact snapshot others build on.
Versioned interfaces
Breaking changes ship as a new major with its own route. @1 and @2 serve side by side while consumers migrate on their own clock.
Zero infrastructure
A single binary with an embedded engine. Runs on a laptop with no services; the same cell deploys to Kubernetes with a profile switch.
Every feature is judged against one test: does it shorten the distance between “I have a question about my data” and “I have a trustworthy answer”?
Not a warehouse replacement: the escape hatch for the use cases that never needed one.
Create your first cell
Five commands from scaffold to a served, versioned API, on your laptop, in
minutes. The installer verifies its checksum and installs to ~/.local/bin.
macOS (Apple Silicon) · Linux (x86_64 / arm64) · Windows via WSL2, or
cargo install from source.
$ datamk init orders && cd orders
$ datamk run # atomic snapshot, auto-verified
$ datamk serve # REST + OpenAPI on :8080
$ curl 'localhost:8080/orders_daily@2?region=us-east'
[{"order_date":"2026-07-10","region":"us-east",
"revenue":48210.55}]cell: orders
sources:
raw_orders: s3://acme-lake/orders/*.parquet
transforms: # private SQL → one snapshot
- sql/stg_orders.sql
- sql/orders_daily.sql
interface: # the only thing exposed
- name: orders_daily
version: 2.1.0 # MAJOR → /orders_daily@2
grain: [order_date, region]
schema: { order_date: date, region: string,
revenue: decimal }Frequently asked questions
What is Datamake, exactly?
An open-source build system for data products, built to do one thing:
reduce time to value for data. You write plain SQL and one
cell.yaml; Datamake builds the data (atomic snapshots on Parquet), verifies it
against the declared contract, and serves it as a versioned REST API. It ships as a single
Rust binary with an embedded DuckDB engine, so no warehouse, cluster, or orchestrator
is required.
Is Datamake a dbt alternative?
It solves a different problem. dbt materializes models back into the warehouse, where every table is still reachable and contract checks are tests someone can forget to run. A cell's contract is the serving boundary: non-exported tables have no route, the build fails (not warns) when the contract breaks, and the result deploys as a standalone, versioned REST API.
Can I serve Parquet files as a REST API?
Yes. Point a source at s3://bucket/path/*.parquet, write plain
SQL, declare the interface, and datamk serve exposes it as REST + OpenAPI with
versioned routes and filterable parameters, with no cluster required.
Does Datamake replace my data warehouse?
No. It's the escape hatch for the use cases that never needed the warehouse. Your warehouse becomes one input among others: a cell can read warehouse tables, lake files, and other cells' versioned exports.
What's a composable data product?
A composable data product, which Datamake calls a cell, bundles logic, output, a versioned interface, and access rules into one deployable directory. Cells build on each other's exports the way code libraries do. Read the concept doc →
How much does it cost?
Nothing. Apache-2.0 licensed and free. No gated features, no paid tiers, no "contact sales."