--- title: "Run Production Postgres on Xata" description: "Start by connecting your existing Postgres — no migration required. When you are ready, move production to Xata for NVMe storage, instant branching, built-in anonymization, and a fully managed platform." source: "https://xata.io/use-cases/production-postgres" --- Run production on Xata ======= Start by connecting your existing Postgres — no migration required. But Xata is built to run your production database too. 100% vanilla Postgres, fully open source core, and a managed platform that grows with you. No fork, no lock-in, no games. [Get started](https://console.xata.io/signup)[Talk to us](https://cal.com/team/xata/xata-sales) ## Add this to your agent's context Give your AI agent the context it needs to work with Xata production Postgres. Connecting your existing Postgres to Xata gives you powerful branching and anonymization for development and staging. But Xata is designed to run your production database too. When production runs on Xata, branches become instant point-in-time forks with no replication lag, anonymization happens at branch creation with zero configuration, and a single platform manages every environment — dev, staging, and production — with the same CLI, the same API, and the same workflow. ## Not just branching — the whole stack Connecting an external Postgres gives you powerful branching and anonymization. Running production on Xata unlocks the full platform: purpose-built storage, instant native branching, end-to-end zero-downtime migrations, and a unified environment from development to production. ### NVMe-over-Fabrics storage Xata's storage engine — Xatastor — is a purpose-built distributed block storage system using NVMe/TCP and SPDK for ultra-low latency. This is not a managed wrapper around EBS or persistent disk. It was designed from scratch for Postgres workloads, with hot data on NVMe, warm data on SSD, and cold data on S3. The storage engine moves data between tiers automatically — you get high performance where it matters without paying for all-NVMe. ### Branching is native When production runs on Xata, branches are instant and free. There is no logical replication lag to wait for, no sync job to schedule, no snapshot window. Every branch is a **point-in-time fork** of the real thing — the moment you call the API, the branch exists and reflects production data exactly as it was at that instant. ### Anonymization at the source PII is detected and anonymized as branches are created — not after the fact, and not via a separate replication pipeline. When production is on Xata, there is no external replication to configure. Branches start clean by default, with sensitive fields replaced by realistic synthetic values that preserve data shape and distribution. ### Unified scale-to-zero Production stays always-on. Dev and staging branches scale to zero automatically when idle and reactivate on the first connection. One platform manages both — no separate infrastructure for pre-production environments, no split billing, no context switching between tools. ### Smart storage tiering Hot data lives on NVMe, warm data on SSD, cold data on S3. Xatastor moves data between tiers automatically based on access patterns. You do not need to configure tiering rules or manually archive old data — the storage engine handles it, so you pay for the performance level you actually use. ### BYOC or fully managed Run in your own AWS, GCP, Azure, or Hetzner account with Bring Your Own Cloud — or let Xata manage everything. Either way, you get the same performance, the same branching workflow, and the same API. BYOC is particularly relevant for data residency requirements or enterprise procurement constraints. ## Start connected, grow into production Most teams start by connecting their existing database. The move to Xata-hosted production happens naturally — when you are ready and on your terms. The first step is connecting your existing RDS, Aurora, or Cloud SQL instance. Xata replicates to a staging environment with built-in anonymization. Production stays exactly where it is. Zero risk, zero disruption. From there, your team starts using the workflow: creating branches, running tests against production-like data, running zero-downtime schema migrations with pgroll. Development gets faster without touching the production infrastructure. At this stage you are getting most of the value — but you can feel the edge: branch creation waits on replication lag, snapshots are periodic rather than instant, and anonymization happens in the replication pipeline rather than at branch creation. You are getting 80% of the platform. When you are ready, migrating production to Xata storage takes the workflow to its full potential. Branches become instant point-in-time forks. Anonymization happens at branch creation with zero configuration. pgroll runs end-to-end across production and branches with zero downtime. The full platform, no compromises. ## What changes when production runs on Xata Both modes — connected external Postgres and production on Xata — use the same CLI, the same API, and the same branching workflow. The difference is in what becomes possible and how much friction remains. Branch creation with a connected Postgres takes seconds and depends on the latest replica. With production on Xata, it is instant and reflects a point-in-time fork of live data. Data freshness shifts from replication lag (seconds to minutes) to real-time. Anonymization moves from a replication pipeline step to a zero-config branch creation default. Schema migrations with pgroll apply to branches when connected externally, but run end-to-end — including production — when Xata hosts everything. The storage engine changes from your provider's default (EBS, Persistent Disk) to Xatastor NVMe-over-Fabrics. ## Vanilla Postgres. Open source. Portable. address_standardizer address_standardizer_data_us amcheck auto_explain autoinc bloom btree_gin btree_gist citext cube dblink dict_int dict_xsyn earthdistance file_fdw fuzzystrmatch hll hstore hypopg intagg intarray insert_username ip4r isn lo ltree moddatetime pageinspect pg_buffercache pg_cron pg_freespacemap pg_hint_plan pg_partman pg_prewarm pg_repack pg_surgery pg_trgm pg_visibility pg_walinspect pgrowlocks pg_stat_statements pg_stattuple pgaudit pgcrypto pgrouting pglogical pgtap plpgsql postgres_fdw postgis postgis_raster postgis_sfcgal postgis_tiger_geocoder postgis_topology prefix refint seg sslinfo tablefunc tcn tsm_system_rows tsm_system_time unaccent uuid-ossp vector wal2json xml2 ![PostgreSQL](/images/oss/postgres.svg?dpl=dpl_9CN1jpPdsajpk49Q4iQ5r4XYVNLZ) Xata runs unmodified Postgres — not a fork, not a custom engine with proprietary extensions. Every tool, ORM, and extension that works with standard Postgres works with Xata unchanged. The tooling that manages your data — pgroll, pgstream, and Xata Agent — is all Apache 2.0 open source. You can inspect the code that runs against your database. Migration in happens via logical replication with zero downtime. Migration out, if you ever need it, is the same process in reverse — `pg_dump` and go. That portability is not a concession or a disclaimer. It is the point. A database platform you can trust is one you could leave if you needed to. ## Let's scope it for your team. See how Xata fits your stack, your scale, and your security requirements. [Get in Touch](https://cal.com/team/xata/xata-sales)