An isolated, production-like database for every pull request, preview deployment, and coding agent — writable, disposable, ready in seconds. The whole platform deploys into your own cloud account with one terraform run.
To test, experiment, and execute safely, every agent and pipeline needs an isolated database with production-like data — created in seconds, discarded without ceremony.
Every agent run gets its own writable branch of production — real schema, real data, zero blast radius. It verifies its migration actually works, not that it parses. Branch goes wrong? Delete it. Goes quiet? It sleeps by itself.
Migrations, backfills, and integration tests run against production-like data on every PR. The branch sleeps when review goes quiet and wakes the moment someone opens the preview.
Every developer works on their own fork of production instead of a shared, drifting staging database. Version before a risky change, rewind when it goes sideways, fork a teammate's branch to reproduce a bug.
With pgvector, the vector index lives inside Postgres — so a branch clones the whole RAG store in seconds: documents, embeddings, index. Try a new chunking or embedding model on a fork, compare retrieval side by side, promote the winner. Idle experiments sleep like any other branch.
To test safely, every developer and agent needs its own database with real data — without multiplying storage, and without a graveyard of forgotten copies.
Fork any database in seconds, regardless of size. A branch shares data with its parent and stores only what changes — and it's a real, writable Postgres, not a read-only replica.
Tag versions as you work; recovery points accumulate automatically in between. Fork from any version — or from any moment in time — and revert without losing what came after.
Idle branches power down by themselves — compute off, data moved to object storage by the storage engine itself, block by block. What's asleep is still a database, not a backup file. The first query wakes it: same connection string, no restore job.
A branch runs at full speed on NVMe with its own compute. Go quiet, and the whole branch hibernates — compute off, NVMe released, everything on object storage — until the first query brings it back. Your working set stays small while the fleet grows.
idle → the whole branch hibernates ↓ · ↑ wakes on the first query
Compute and NVMe are released together — a sleeping branch occupies neither. The storage engine carries it to object storage whole, automatically, with no lifecycle rules and no migration jobs — and what's asleep is still a live database, not a backup; waking attaches it, nothing is imported.
Give each team a project with a storage budget and a bronze, silver, or gold performance tier. Limits are enforced by the platform — a runaway agent can't slow production down.
Connect to a sleeping branch and it answers. The gateway holds your connection while the branch wakes — no errors, no retry loops, one stable connection string for life.
Create, fork, version, revert, sleep, wake — from the web console, the REST API, or plain Kubernetes resources your CI already speaks. Scoped tokens let every team self-serve safely.
Point-in-time recovery is built in — no bucket to create, no archiving to babysit. Fork the database as it was at 9:03, or rewind a branch to just before the bad migration.
Every branch and version is labeled in the data itself and stored durably. Even if the control plane disappears, your whole branch tree can be rebuilt from the data alone.
100% upstream Postgres. Every extension, every driver, every ORM and tool that works with Postgres works on a branch. Nothing to migrate to, nothing to migrate back from.
terraform apply → storage · Postgres · control plane · GCP · AWS · Azure
Every pull request, agent run, and experiment leaves a branch behind — and on premium SSD, that growth never stops. Zettabranch tames it with no archival jobs, no migrations, and nothing deleted: idle branches and their versions move to object storage by themselves — carried by the storage engine as incremental block changes, not exported by a backup tool. What lands there is still a live database, and it wakes on the first query.
Dormant branches move to economical storage by themselves — no lifecycle rules, no migration jobs.
One terraform run stands up the whole platform in your own cloud — storage, Kubernetes, Postgres, and the branching control plane. Nothing hosted, nothing to sign up for.
Load your data, then branch from the web console, the REST API, or Kubernetes resources your CI already speaks. Apps and agents connect with plain postgresql:// — nothing to install.
Add projects for every team, scoped tokens, storage quotas, and performance tiers as branches multiply. The idle ones go to sleep on their own — growth stays tamed.
One terraform run stands up storage, Postgres, and the branching control plane — projects for every team, branches for every developer and agent. Every piece runs in your account, the control plane included.