Zettabranch Datasheet

A Database Copy Per Developer, CI Job, and Agent

Development, testing, CI, and AI agents all need realistic, isolated Postgres copies — but full clones are slow, expensive, and multiply your database bill. Hosted branching services fix the speed by putting your production data on their infrastructure.

Zettabranch gives every developer, CI job, and AI agent a full-size Postgres branch — created in seconds regardless of database size, woken on the first query, and parked on cheap object storage when idle.

It deploys as a single unit into your own cloud account on vanilla PostgreSQL, with copy-on-write branching done in the storage layer rather than the database — nothing proprietary to migrate onto, or off of.

Benefits

Branch in seconds — independent of database size
Idle branches park to object storage — bucket price at rest
Vanilla PostgreSQL — stable connection strings, nothing proprietary
Seed from any Postgres with inline PII masking
Runs in your own cloud account — full data sovereignty

Branching in the Storage Layer, Not the Database

Clients — Developers · CI Runners · AI Agents · Analysts

PostgreSQL wireone stable URL per branch vanilla Postgres — no proprietary driver

↓ ↓ ↓ ↓

Branching gateway Per-branch connection strings · wake-on-query · inline PII masking on ingest

CloudNativePG Orchestrates vanilla PostgreSQL · per-branch credentials · HA

MayaScale storage engine ZFS copy-on-write clones over NVMe-oF · branch time independent of size

Hot NVMe poolrunning & parked branches

Cold object poolevacuated branches — S3 / GCS / Blob

Operate & Deploy

Web consolelive branch tree · fork, sleep, delete

REST APIbranches · versions · sleep/wake

zettab CLIone static binary · CI & agents

Kubernetes CSIbundled k3s or your EKS/GKE/AKS

Branch like git, at storage speed

A branch is a copy-on-write clone of a version snapshot, taken in the storage layer — so creating one takes the same few seconds whether the parent is near-empty or a terabyte, and an idle one costs object-storage prices instead of a running database.

Copy-on-Write Branches — Size-Independent

A branch is a ZFS clone of a version snapshot, so branch-creation time is independent of database size. Name versions on any branch as fork points, fork from a version or as of a time without a restore job, and revert a branch in place while keeping its connection string.

Seed From Production — Masked on the Way In

Ingest from any existing PostgreSQL — RDS, Cloud SQL, Azure Database, self-hosted — straight into a branch through the gateway, applying deterministic masking during the load. Emails and names are replaced consistently and foreign keys still join; production PII never lands on the branch, and the source database is untouched.

Two-Depth Sleep — Why Waking Is Cheap

A parked branch turns compute off but keeps data on NVMe, so the next query wakes it in about two seconds — the gateway holds the connection while it comes up, so the client sees a slow first query, not an error. Evacuation is a deliberate step that releases the NVMe to the object pool, so routine idleness never costs a restore.

A Cold Tier That Is Still a Pool

Evacuated branches live on a second ZFS pool whose vdevs are object-storage buckets — read and written in place, not archived and restored. It runs on the same node, so there is no gateway VM to size, and every cold branch keeps a continuously replicated twin, so a drained node can be rebuilt from object storage.

Active-Active High Availability

Two-node active-active storage with automatic failover. Volumes stay exported through the surviving node, and branches keep serving on the same connection strings — no reconnection logic in the application.

Operate It Like Infrastructure

A web console with a live branch tree; a REST API and the single-binary zettab CLI for CI runners and agent images; a drain operation that evacuates a whole deployment behind a readiness gate before node replacement; Prometheus metrics with a hot/cold capacity split; and admin plus project-scoped access control.

Branch lifecycle — from production to a forked, sleeping copy

Zettabranch Architecture

Architectural Attribute	Description
Database	Vanilla PostgreSQL, orchestrated by CloudNativePG — nothing proprietary to migrate onto or off of.
Branching	ZFS copy-on-write clones over local NVMe, exported via NVMe-over-TCP; branch time is independent of database size.
Cold tier	A second ZFS pool whose vdevs are S3 / Google Cloud Storage / Azure Blob buckets — read and written in place, not archived and restored.
Two-depth sleep	Parked (compute off, data on NVMe, wakes in ~2s) or evacuated (NVMe released to the object pool, rehydrated on query).
Ingest	Snapshot load from any PostgreSQL, with deterministic PII masking applied inline during the load.
Availability	Single node, or two-node active-active with automatic failover; branches keep serving on the same connection strings.
Replicated cold twin	Every cold-tier branch keeps a continuously replicated twin, so a drained node can be rebuilt from object storage.
Kubernetes	Bundled single-node k3s, or your existing Amazon EKS / Google GKE / Azure AKS.
Storage integration	ZettaLane CSI driver — VolumeSnapshot, clone, and online expand.
Interfaces	Web console, REST API, single-binary `zettab` CLI, and Prometheus metrics.
Access control	Admin and project-scoped tokens; per-branch database credentials.
Clouds & deployment	AWS, Azure, and Google Cloud; one command provisions storage, control plane, and API together.
Sovereign by design	Storage nodes, Kubernetes, branching API, and console all run inside your own cloud account; data never transits a vendor backend.
Storage engine	Built on MayaScale — ZettaLane's NVMe-over-TCP block engine with object-backed cold tiering and active-active HA.

Branch Operations & Use Cases

Branch Operation	What it does
Copy-on-write branch	A full-size, writable branch as a ZFS clone of a version snapshot; creation time independent of size.
Versions	Named snapshots on any branch — the fork point for children.
Fork from a version	Instant child branch at any tagged point.
Fork as of a time	Point-in-time fork without a restore job.
Revert in place	Roll a branch back to a version, keeping its connection string.
Point-in-time recovery	Scheduled recovery points with configurable retention.
Stable connection string	One URL per branch, unchanged across sleep, wake, and promotion.

Fork time is independent of database size: the copy-on-write clone completes in milliseconds, and the few seconds you see are ordinary PostgreSQL startup, not data movement — so a terabyte-scale branch is ready as fast as an empty one. Idle branches park in seconds and wake on the first query.

Who Gets a Branch	Use case
Developers	A private, full-size copy per person or per feature branch — no shared staging contention.
CI / CD	An ephemeral branch per pipeline run, forked and torn down in seconds; idle overnight at bucket price.
AI agents	A database per agent to mutate freely, reverted or discarded after the task — zero risk to production.
Analysts & PITR	Fork as of a point in time for investigation or recovery, without a restore job.

Programs & Partnerships

Deploys into your own Amazon Web Services, Microsoft Azure, or Google Cloud account, via Terraform. sales@zettalane.com