Operated open lakehouse
AI-driven data engineering, operated for you, owned by you in your own cloud account.
Most companies get two choices: pay a vendor in “credits” you can’t trace, or assemble twenty open-source projects and hire five engineers to keep them running. RunningLake is the third option — we run the stack, the bill arrives in cloud dollars with the compute each query used priced from your provider’s own export, and AI agents will draft the pipelines as a reviewable diff that a person approves.
Databricks’ capabilities. Kubernetes’ operating model. A bill you can read.
Pre-product. The control plane, the router’s constraint layer, the data-plane Terraform module and the platform bundle are built. No customers yet — the first eight are design partners, and we charge from the start.
- All-purpose compute
- 4,182 credits
- SQL warehouse
- 1,904 credits
- Jobs compute
- 2,771 credits
- Serverless
- 988 credits
- Total
- 9,845 credits
Which pipeline? Which team? Was that Tuesday’s backfill, or the dashboard nobody opens? Credits convert to money at a rate you don’t set.
- daily_revenue_by_plan duckdb · 744 runs
- $3.72 measured
- bi.adhoc trino · 218 queries
- $214.80 $151.30 measured · $63.50 shared
- exec_dashboard starrocks · always-on
- $88.10 reserved · split shown
- Management fee 25% of the platform and work lines above
- $76.65
- Storage 1.7 TB, your bucket
- $39.10 at cost
- Total
- $422.37
Two of these compute figures are measured and one is an allocation. The statement says which, and shows the division. An allocation you can see is not a credit unit. An allocation you can’t is.
Illustrative, for a 12 GB hourly pipeline plus a BI workload on the Team tier. Your numbers will differ; we measure them on your workload before you sign anything.
What RunningLake is
Five things it does for you, and whether each one runs yet.
This is what we are building and what we promise. The chip beside each claim says what is built today; a claim without a RUNNING chip is not built yet.
Describe it. AI builds it. You approve it.
AI agents draft your pipelines, checks and repairs as changes you can read, and nothing goes live until a person says yes. It’s the same for a team of two and a team of hundreds, because the agents do the engineering and your people make the calls.
We run it. You own it.
We operate the open lakehouse stack for you, with five SQL engines and one for your own code. On a plane in your own cloud account, your tables’ files sit in your bucket, under keys in your own KMS, in open formats (Iceberg, Hudi, DuckLake). If you ever leave, the files are already in your account.
Ask in plain English. Answered within your access.
Business users ask questions in words. The SQL agent builds the SQL from your team’s defined metrics and shows it first, and the person runs it as themselves. Keep an answer as a flow and re-run it with new values, with no AI call.
Governed once, correct everywhere.
One place, the catalog, decides who sees what, so a rule is written once for every engine. The platform picks the right engine and format for each job, and correctness comes before price.
A bill in cloud dollars you can read.
Every line traces to a job, a team and a table, with no credits and no conversion rate. The month is forecast as a range, and advice comes with its dollars.
A plane we host, and every trial, is in our account. The five objectives describe the product, and each chip says whether it is running. Registering your own encryption key is built in the console and is not switched on yet. Five SQL engines is a Business-tier count: the trial has DuckDB only and Team has three.
control plane · router CONSTRAIN · data-plane Terraform module · platform bundle
engine services · cost attribution
Spark · StarRocks · Flink · Hudi · GCP · Azure · Pipeline Agent · Quality Agent · Analyst Agent · Repair Agent
SOC 2 · HIPAA · ISO 27001 · PCI DSS
Every capability claim on this site carries one of these. If it isn’t marked RUNNING, we haven’t built it. The full build order →
The parts are free. Running them is the job.
Every capability in a data platform now exists as open source that genuinely works — Spark on Kubernetes with Karpenter, Kyuubi, Celeborn, Gluten or Comet, Lakekeeper, OPA and Ranger, OpenLineage, OpenCost. The components are not the problem. Integrating them behind one coherent surface and operating them well takes three to five strong platform engineers who know Kubernetes and Spark internals. Most companies cannot hire that team, and those that can would rather spend it on their own product.
platform engineers needed to run the open stack well
what they cost all-in, per year — at $160K–$290K each
average annual pipeline maintenance per company (Fivetran)
of a data engineer’s time on maintenance, not new capability
The second figure is our own arithmetic on our own source, and it is larger than the number our go-to-market document uses. We publish the larger one because it’s the one the source supports.
RunningLake is that platform team, delivered as software.
Three claims, in the order we’d like to be judged on.
One is easy to prove and we lead with it. One is the product. One is the reason a security team says yes.
A bill you can read.
Real cloud dollars, not credits: the compute each query used is priced from your provider’s own export and added up by project, environment, submitter and engine. No credit unit anywhere in the product. Where a figure is an allocation rather than a measurement — an always-on cluster’s share, a warm pool’s floor — it is labelled as one, and the split is shown.
Stop needing a platform team.
Karpenter, Kueue, Lakekeeper — pinned, patched and upgraded on a schedule. Not by you.
Your data, your bucket, open formats.
Iceberg in your own S3. Every component we run is permissively licensed, with no vendor licence, and the parts list names who stands behind each. A customer who cancels keeps working tables — retention has to be earned elsewhere.
One qualification, stated here rather than at the bottom of a page: your bucket is a bucket in your own cloud account, on a plane you connect. A plane we host is in our account, and the trial is designed to run on a bucket of ours. Registering your own encryption key is built in the console and is not switched on yet; today the keys are the ones a plane’s own setup creates. At-rest encryption costs nothing at every tier, the trial included, because charging for baseline encryption would be indefensible.
The router
You don’t pick the engine. Correctness picks it, then price picks between what’s left.
Step 4 runs before step 5, always. A wrong answer delivered cheaply is worth less than nothing.
The job · examples/
gold.
hourly · 12 GB scanned · operation MERGE · declared consumer: Trino BI, 1h freshness
Step 1 · which format
Step 2 · constrain, then cost
Notice what did not happen. DuckDB costs 1× and Trino costs 6–20×. DuckDB was eliminated before anything was priced, because it cannot perform a MERGE on an Iceberg table. In the source specification there was no Iceberg-DML rule at all — so DuckDB stayed eligible and won on cost, for a statement it cannot execute. It bit hardest on the two things the docs give as reasons to choose Iceberg: GDPR erasure and partition evolution.
The rules are versioned, signed data released independently of any binary, and every capability cell of an engine in the first release that asserts anything names the conformance run that is to prove it, and is marked unverified until it does. Engines outside the first release are listed with no evidence at all. Which engine pairs have actually been compared, and what each pair’s evidence is, is on its own page.
Actual runtime and cost are written back after every run, and the cost model is refit per tenant — so a job that ran on Trino last month may route elsewhere this month because the estimator learned it over-predicted.
What one hour costs.
One pipeline, one run, start to finish. Illustrative for a 12 GB hourly job — your numbers will differ, and we measure them on your workload before you sign anything.
This run
duration
per run
runs a month
a month, in cloud dollars
744 runs at half a cent. We show the run count so you can check the multiplication — on a page arguing for legible arithmetic, a total you have to take on trust would be self-defeating.
And when Stripe renames a field at nine in the morning.
REPAIR AGENTThis one is designed, not built. Nothing quarantines rows yet, and the Repair Agent is item 17 of 20 in the build order, below the line marked “a coherent, sellable product.” We’re showing you the design, not a demo.
Agents
It’s a git diff, not magic.
The agents are planned, not built. The Pipeline Agent is designed so that you describe the pipeline in plain language and get back a pull request: the SQL, the DAG, the quality tests, the docs, a format recommendation with its reasoning, and a cost estimate in cloud dollars, which you approve the way you approve anything else. Data engineers are professionally sceptical of AI writing production code, and they’re right to be.
Repair autonomy is designed as L0–L3, set by you, with L1 the default — diagnose and propose, open a PR, wait for a human. L3, auto-apply to production, will be available only for action classes with a demonstrated 99% success rate in your tenant, and always reversible. Every autonomous action will write to an immutable audit log, with no configuration option to disable that.
For a business user whose role may run queries, the Analyst Agent is the SQL agent. A question in plain English becomes SQL built from your team’s defined metrics, shown first and run by the person who asked, as themselves, inside their own access. A business flow keeps the question’s SQL, run again with new values and no AI call.
# Owned by finance. Ask #data-platform before changing the schedule.
kind: Pipeline
metadata:
name: daily-revenue
labels: { team: finance } # used for cost attribution
spec:
schedule: "0 * * * *" # hourly
routing:
format: ICEBERG # append-heavy, multiple consumers
engine: "" # unpinned — let the router learn
consumers:
- engine: TRINO
freshnessSla: 1hAgent rationale, carried in the diff: “12 GB scanned, single consumer, append-only. ICEBERG chosen over DUCKLAKE because bi-trino is a declared consumer — a second engine triggers promotion.”
Every mutating endpoint returns a change set with a git ref, not “created”. The console shows a diff before every change because there is nothing else it can show — the agent’s proposal and a human’s hand-edit are the same mechanism.
Operations
Pinned, patched, upgraded on a schedule. Not by you.
One opinionated version set, unforked, across every plane. The platform bundle is a digest-pinned OCI artifact, byte-identical on every cluster; per-plane variation lives in one config object and nowhere else. A private fork of Spark, Flink or Trino is a permanent tax on a small team — so we don’t keep one. Contributions go upstream.
Not every part here runs today: the parts list says which are running, which are being built and which are planned. Dagster is not on either list, because it is not something we run; a Dagster or Airflow you already run is meant to call RunningLake the way any other client does, and starting a run from outside is not available yet: the call exists, and the control plane refuses it until a data plane can run a task.
customer data planes per platform engineer, by year three.
This metric is the business. If one engineer can’t support forty-plus, RunningLake is a consultancy with a product attached rather than a software company.
Today it is one. We publish the target and the current value together, because a north-star metric quoted without its present value is marketing rather than measurement.
Trust boundary
RunningLake cannot reach into your network.
Your cluster opens the connection to the control plane, and the control plane never dials into the cluster. Hosted and BYOC run the identical mechanism, so the BYOC path can’t rot from disuse. Work flows down the stream; metering and run history flow up.
And the schema is the enforcement mechanism, not a convention. No message the plane sends is meant to carry customer data: LogRef, not Log. ResultHandle, not ResultSet. Opaque ids, not names. Every field the plane sends is held to a shape, and the control plane refuses a message that does not fit; a shape limits form, not meaning, so a short summary could still hold a name. A query’s rows are written to the plane’s own storage: the control plane is handed a short-lived link, never the rows, and your browser follows it. It is told how many rows and bytes, how long the query took and what it cost. The text of a query goes down to the plane, and the control plane keeps a sealed copy of it for a limited time; a statement a person saves is kept, sealed, until they delete it.
Control plane · runs at RunningLake
identity · catalog · router · policy · cost meter · agents
Data plane · runs in your cloud account
engines · your bucket · your KMS keys · Kubernetes
Where this is not absolute: the per-tenant context store lives in the control plane and holds schemas, column-level lineage, run history and sampled statistics — derived customer data. The rule keeping raw values out of a model’s context is scoped to columns classified as sensitive, which means values from unclassified columns can reach a model API. Bringing your own model endpoint is Enterprise-only today.
Cost attribution
An allocation you can see is not a credit unit. An allocation you can’t is.
On AWS, the control plane reads the cost and usage export in your own account and prices the compute each query used as that query’s share of the machine it ran on. What a plane costs with nobody on it is shown as its own line and is not divided among queries. Work is added up by project, environment, submitter and engine; not yet by pipeline, table or team. For a dedicated engine — one pod, one query — the usage is measured and the price is that pod’s share of its node. For a shared cluster it’s an allocation, because there is no honest way to make it anything else. So every figure carries how it was derived, and the formula sits next to it. This runs on our QA plane today; GCP and Azure readers are not built.
Reconciled every six hours against your cloud provider’s own export, and a query’s figure can keep moving for about a day after it ran, because AWS restates the export. A query is priced for the whole seconds its pod ran; only where a node’s facts are missing is its reserved vCPU-seconds rounded up to a whole second, and the trial’s compute allowance always counts each query up to a whole vCPU-second. A pipeline can record a monthly spend cap today; nothing enforces it yet, so no job is held at one. A limit on metered compute is planned; it will not cap the whole cloud bill.
- measuredone pod, one query — the CPU that pod used, priced at its share of its node
- shared_amortisedyour share of a cluster several jobs used, with the split shown
- idlewarm-pool floor, attributed rather than hidden
- reservedan always-on component, allocated across what used it
The cheapest tier is the easiest to account for: the trial’s DuckDB runs one pod per query in a single-use sandbox, so a query’s share of its node is unambiguous.
The console’s cost page renders no figure it cannot stand behind: nothing on the trial, where the plane is included and you owe nothing; and, once a bill has been read, the month’s work by project, environment, submitter and engine, and your planes’ standing cost with the components it came from. What it will not do is divide that standing cost by a rule nobody chose.
Three ways to have a data platform. You’re already on one of them.
We’re not going to run a feature-by-feature comparison against a company with a decade’s head start and several thousand engineers. This compares operating models, which is the thing that actually decides who runs the platform: your team, or us.
| Dimension | Buy the package | Assemble it yourself | RunningLake |
|---|---|---|---|
| The bill | Credits, converted at a rate you don’t set | Your cloud bill, plus three to five salaries | Cloud dollars, with the compute each query used priced from your provider’s own export, plus our fee stated separately |
| Where the data lives | The vendor’s format, the vendor’s catalog | Your bucket | Your bucket, in Iceberg, on a plane in your own cloud account. A plane we host is in our account. |
| Who operates it | Their software; you still size and tune the machines | You, once you’ve hired the team | We do. That’s the product, not a support tier. |
| Which engine runs a job | You pick a cluster or a warehouse size | You configure every engine by hand | Chosen per job. Correctness rules first, then price. |
| When a pipeline breaks | A person reads logs | A person reads logs | Quarantined, blast radius traced through lineage, a fix proposed as a diff. Planned, not built. |
| Leaving | A migration project | Nothing to leave | Your tables are Iceberg in your bucket and stay readable by anything. What doesn’t transfer is the run history the router learned from — so we won’t tell you leaving is free. |
| Built for | Companies willing to pay in credits for a managed package | Teams that can hire specialists | Every size of company, with no platform team needed: a data team of two, or of two hundred |
None of these are features anyone can bolt on next quarter. Each is a consequence of how a company is built and what it charges for. The first column’s constraints are unfixable without repricing the business — a strong claim, not an eternal one. If a large vendor drops the credit and bills in cloud dollars, the first column changes. We’d rather say so than pretend otherwise.
What we won’t claim.
Serverless economics
Large vendors share giant pools of machines across thousands of customers. We can’t match that at our size and we don’t pretend to. Shared driver pools help; they do not match.
Heavy Python workloads
The open-source Spark accelerators get roughly 2–3× on scan-heavy SQL and nothing on Python UDFs. That figure is the community’s, not ours — we haven’t run the bake-off yet. When we do, we’ll publish it with its limits.
Depth of governance tooling
A decade-old catalog’s lineage, ABAC and audit are years ahead of a catalog plus OPA plus OpenLineage assembled. Ours will be good. It is not as deep.
Anything a certificate would prove
We hold no SOC 2, no HIPAA BAA, no ISO 27001, no PCI DSS. Not “in progress” — none. There will be no trust badge on this site before there is an auditor’s report behind it.
If one of the first three is your biggest problem, buy the incumbent. You should hear that from us before you hear it from anyone else.
Data engineering in 2026
For how data engineering works now.
AI applications, contracts between teams, declarative pipelines and cost you can see, in the shape the rest of RunningLake has: open tables in your bucket, and a bill in dollars.
Data engineering in 2026
Five shifts that define the year, what RunningLake does about each, and what it deliberately leaves out.
Data contracts
A table’s keys, checks, freshness, owner and consumers in git, and a breaking change that waits for them.
AI-ready data
Documents as rows and embeddings as columns of open tables in your bucket, searched in SQL.
FinOps
A month-end forecast as a range, alerts that never act, and advice that shows its dollars.
The parts list is public. That’s the point.
Every component we run is permissively licensed, with no vendor licence, and the table names the foundation, host or maintainer behind each. Anyone can read this list. Almost nobody can run it — which is why we do.
We say “permissively licensed” and name the governing body on each row rather than “Apache or CNCF” because the shorter version isn’t true: DuckDB is MIT under its own foundation, Trino is governed by the Trino Software Foundation, StarRocks by the Linux Foundation, and Lakekeeper and SQLGlot are independent projects with no foundation behind them. The licence and the governing body are in the table so you don’t have to take our word for the summary.
We keep no private fork of any of these. Contributions go upstream. A fork is a permanent tax on a small team.
Dagster is not on this list because it is not something we run. A Dagster or Airflow you already run is meant to call RunningLake the way any other client does, and starting a run from outside is not available yet: the call exists, and the control plane refuses it until a data plane can run a task.
Who this is for, and what we’d say to you.
Your team is underwater and you can’t hire platform engineers.
“You get the platform team as software. Your engineers go back to building.”
- Three to five specialists is what the open stack takes to run well.
- The router picks engine and format, so nobody on your team has to hold that in their head.
- Pipelines arrive as pull requests your engineers review, not as a black box.
The bills are growing faster than the value.
“Your bill is cloud dollars. The compute each query used is priced from your provider’s own export, and what a plane costs with nobody on it is its own line. No credit unit. We’ll model your current spend before you sign anything.”
- Reconciled every six hours against your cloud provider’s own export. A query is priced for the whole seconds its pod ran; the trial’s compute allowance counts each query up to a whole vCPU-second.
- Planned: a monthly limit on metered compute, not on your whole cloud bill. Today a pipeline records its cap and nothing holds a job at it; the trial’s compute allowance is the one spend limit enforced.
- The 25% management fee on Team-tier compute is a line on the statement, not a margin inside a unit.
You tried assembling the stack and it became a second job.
“Karpenter, Kueue, Lakekeeper — pinned, patched, upgraded on a schedule. Not by you.”
- One digest-pinned bundle, byte-identical on every plane.
- Kubernetes is the only substrate. No YARN, no standalone, no HDFS.
- Your cluster dials out. We never dial in.
The data platform is an audit finding waiting to happen.
“Your bucket, your keys, column-level encryption, policy compiled to every engine.”
- Your cluster opens the connection to us and we never dial into it, so nothing has to be allowed inbound. That connection is not encrypted on the environment we run today; encrypting it and authenticating both ends of it are not built yet.
- Built in the console and not switched on yet, on an AWS plane in your own account: a project’s table files in your bucket encrypted under a key in your own KMS, which you create and can disable.
- Hash-chained, append-only audit. You take an export and check the chain yourself; delivery to your own bucket is not switched on yet.
What we can’t hand you today is a completed SIG or a SOC 2 report. We hold neither. What we can hand you is the architecture, the trust-boundary decision record, and the list of what isn’t built.
Tool sprawl, 2am pages, and format decisions you’ll regret.
“Describe the pipeline, and the agent will pick the format and engine and tell you why, as a git diff, not magic.”
- Choosing Hudi removes three of five engines from the write path. The platform refuses the selection at creation time rather than letting you find out in production.
- Constructs that don’t transpile cleanly across your table’s engines are rejected at authoring time, with a message. Never silently rewritten.
- You can pin the engine and the format. Format, engine and instance type are all overridable.
And who it isn’t for. Size doesn’t decide it: a data team of two and a data team of two hundred are both a fit. What rules a company out: work that is primarily ML training, data that is on-premises only, no existing cloud spend to compare against, or no appetite for Kubernetes. We’d rather say so on the home page than on the third call.
Four tiers, and what each one actually gets you today.
The tier table we published promises more than the architecture will deliver right now. This is the corrected one.
Trial
$0
for 90 days, then you pay
- 90 vCPU-hours per 30 days
- 5 GiB on our bucket
- 1 vCPU · 2 GiB per query
- $10 of model spend, once
- 30 vCPU-hours per 30 days, 2 GiB and $5 on a personal email
- 1 project · 3 users
- DuckDB only · Iceberg + DuckLake
- AWS
Team
25%
management fee on your cloud cost, no flat fee
- 2 TB, or your bucket
- 5 projects · 20 users
- Up to 64 vCPU
- AWS, GCP
- Pipeline + Quality Agents
- Bring your own model endpoint
- Management fee on the statement
Business
$5,000
per month, BYOC — you pay cloud direct
- Your bucket
- 25 projects · 75 users
- Up to 512 vCPU
- All three clouds
- Customer-managed keys
- Column-level encryption
- All four agents · Hudi
Enterprise
from $12,000
per month, BYOC multi-cloud
- Unlimited
- CMK / HSM
- Confidential compute
- Differential privacy
- 99.9% SLA
The trial is ninety days, and we can withdraw it. After ninety days you pay to carry on. The compute cap is a gate — measured per query and refused at the boundary. Storage is measured on a plane that reports it can, and is not a gate. The pricing page says which is which. We may also withdraw the trial entirely, at any time. It is there so you can try this on your own data — it is not a free tier, and a plan built on it is a plan built on something we have told you we can take away.
The ten dollars is ten dollars. The trial grants a one-time balance of ten US dollars for agent usage, in the same currency as every other figure on this site. Nothing draws it down yet, because the agents are unbuilt. It is a starting balance, not a unit — there is no conversion rate, because there is nothing to convert. On a personal email address it is five dollars, alongside a third of the compute and two gigabytes rather than five. The pricing page lists which domains count as personal and why.
The correction, stated inline. Our published table said the free tier included DuckDB and Trino. It’s DuckDB only — several free tenants’ rows would pass through one Trino JVM’s memory, and no amount of policy makes that a story we’d want to tell. Trial DuckDB runs one pod per query in a sandbox: no shared process, no shared heap.
What none of them get today: Spark, Flink, StarRocks, Hudi, GCP, Azure and all four agents — the Pipeline Agent, the Quality Agent, the Analyst Agent and the Repair Agent — are not built. Hudi is gated to Business not to upsell but because its table services carry real operational cost — and it won’t be offered to anyone until those services have passed a 30-day unattended proof on our own QA plane.
Forty conversations, then a product.
We’re looking for eight to twelve design partners, and two or three should be CDC-heavy — those are the ones who’ll tell us whether a whole phase of this plan should exist at all. Twelve months at 70% off, direct Slack access to engineering, roadmap influence, and a written case study when there’s something to write about. We charge from the start: even $500 a month changes the quality of the conversation entirely.
No card. No demo-booking flow. A reply from a founder, usually the same day.