Copy-on-write storage
Using copy-on-write storage, each branch shares data with its parent and stores only changes instead of creating full copies.
The Postgres for agentic workloads
Create instant database clones with production-like data for every agent, workflow, and CI/CD pipeline.
Branches33 active
Production Postgres
V18 · Active
cursor/migrate-orders-3c1e
V18 · Active
claude/eval-run-7f3a
V18 · Active
codex/tune-query-2b9e
V18 · Hibernated
maria/add-index
V18 · Active
Used by agents and humans at
Modern development needs more than a single staging database.
Coding agents multiply the number of changes happening at once. A single shared database cannot safely support all those migrations, tests, and experiments.
With a shared staging database
Everyone modifies the same dataset at once
claude(db): fix migration
Pull request #1827
feat(onboarding): add billing
Pull request #3842
feat(settings): add permissions
Pull request #1237
chore(*): deploy
Preview deployment a7bde2
Schema changed when tests were running
With Xata
Every workflow gets its own isolated branch
claude(db): fix migration
Pull request #1827
feat(onboarding): add billing
Pull request #3842
feat(settings): add permissions
Pull request #1237
chore(*): deploy
Preview deployment a7bde2
Change schemas safely
Run migrations and test schema changes without affecting production or anyone else’s work.
Test with production-like data
Catch issues that empty databases, fixtures, and mocks cannot reveal before changes ship.
Work in parallel
Give every developer, agent, and preview an isolated database without waiting on shared staging.
Clone any Postgres database in seconds
Create isolated branches from production without copying the full database. Each branch gets its own schema, compute, and production-like data.
stg/main-preview-2a3ef
4 vCPU
16 GB
$0.19 / hr
Scale to zero
Run branches only when needed. When idle, they hibernate and use no compute.
Wake on the first query
Branches wake on first query and respond instantly: no connection timeouts, no spin-up delays.
Upstream Postgres
Branching happens in the storage layer, not through a custom Postgres fork, so you keep standard PostgreSQL, extensions, drivers, and tooling.
Created when work starts.
Removed when it ends.
Xata runs vanilla PostgreSQL with high-performance storage, isolation, and instant branching built in.
Pull Requests
Create a production-like database branch when a pull request opens. Run migrations and tests against it, then delete it after merge.
Coding Agents
Let agents create isolated branches through the API or MCP, safely modify schemas and data, and clean up when the task finishes.
Preview Deployments
Connect every preview to its own Postgres branch so the complete application, code, schema, and data, can be validated before publishing.
Adopt Xata without moving production.
Keep production where it is, or move it to Xata. Either way, every pull request and deployment preview gets its own isolated Postgres branch.
- Branches from a production clone
- Production data with built-in anonymization
- Continuously synced with production
Production-ready Postgres
Xata runs vanilla PostgreSQL with high-performance storage, isolation, and instant branching built in.
Vanilla Postgres
No forks and no compatibility issues.
High availability
Automatic failover to read-replicas.
PITR backups
Restore your database to any point
Premium storage
Low latency and high throughput.
Example
How much does a hundred pull requests cost?
Consider a company creating 100 pull requests per day against a 100 GB production database.*
With traditional database infrastructure, giving every pull request its own isolated database quickly becomes unsustainable.
With Xata Copy-on-Write, branches share unchanged data with production. Scale-to-Zero reduces compute usage by pausing idle branches.
*Assumes 3 GB of unique changes per branch, 24 hours of always-on compute per traditional copy, and 5 active minutes per Xata branch at equivalent compute size. Storage totals assume all 100 branches are retained. Production is excluded from both comparisons. Resource usage only; actual costs depend on rates and how long storage is kept.
Storage (TB)
Traditional DB
Compute (hours)
Traditional DB
Built for platforms
Add branch-native Postgres to your product
Xata runs vanilla PostgreSQL with high-performance storage, isolation, and instant branching built in.
Provision instantly
Create a new Postgres database in a second through a simple API.
Branch at any scale
Create a production-like branch in seconds, regardless of size. Scale to zero when idle and wake in 1s.
Scale to millions
Support large numbers of short-lived databases without duplicating storage or paying for idle compute.
Deploy on your terms
Use Xata Cloud or run in your own cloud with BYOC, private networking, and regional control.
Used by builders, engineers, and leaders worldwide
Xata is currently the best way to run the pg_duckdb extension in the cloud. The platform’s flexibility and API access make Xata the perfect PostgreSQL partner for us.
Jordan Tigani
CEO
Xata was an easy choice for our team because of how straightforward the entire platform is, while simultaneously providing a suite of adequate features that we need. The Xata team has also been super responsive and more importantly quick to resolve the hiccups that we brought upon ourselves.
Chris Windsor
Lead Software Engineer
By adopting Xata, we cut database costs vs. our RDS setup and got better help from Postgres experts.
Jignesh Chauhan
Co-founder
Xata was a no-brainer for our team. We get a lot of value out of the copy-on-write database branching and scale-to-zero features.
Ben Hubsch
Software Engineer
