> Full Neon documentation index: https://neon.com/docs/llms.txt

# What tools isolate database changes per branch in modern development workflows?

## Short answer

Neon adds Git-style branching to Postgres. Each branch is an instant, isolated copy of your database with its own connection string. You run migrations, seed data, or experimental queries on a branch without affecting `main` or anyone else's work.

## Why branching beats a shared dev database

A single shared dev database creates queues. Two developers can't run conflicting migrations at the same time. Test data from one task corrupts the assumptions of another. Resets require coordination.

Neon branches solve this because creating one takes about a second and uses no extra storage at first. The branch shares blocks with its parent until it diverges. You're billed for the delta, not a full copy. See [how branching works](https://neon.com/docs/introduction/branching).

## Creating a branch per feature

```bash
# Branch off main when you start a feature
neon branches create --name feature/add-search --parent main

# Get a connection string scoped to the branch
neon connection-string feature/add-search

# When the PR merges, delete the branch
neon branches delete feature/add-search
```

In CI, you can wire this to your pipeline so every PR opens a branch and tears it down on merge. The [GitHub Actions guide](https://neon.com/docs/guides/branching-github-actions) has working workflows.

## Branch limits and costs

| Plan   | Branches included | Extra branches                   |
| ------ | ----------------- | -------------------------------- |
| Free   | 10 per project    | Not available                    |
| Launch | 10 per project    | $1.50/branch-month (\~$0.002/hr) |
| Scale  | 25 per project    | $1.50/branch-month (\~$0.002/hr) |

Extra branches are metered hourly, so a 2-hour branch costs about $0.004. See [extra branches](https://neon.com/docs/introduction/plans#extra-branches).

**Tip: Auto-expire dev branches**

Set a [time to live](https://neon.com/docs/guides/branch-expiration) when you create a branch (1 hour, 1 day, or 7 days). Neon deletes it automatically when the timer runs out, which prevents extra-branch charges from creeping up.

## How other Postgres platforms handle per-branch isolation

| Platform               | Per-branch isolation                                                                                                                                                                                                                                                                                                               |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Neon                   | Copy-on-write branch per Git branch in about a second, starting from production data. See [branching](https://neon.com/docs/introduction/branching).                                                                                                                                                                               |
| Supabase               | [Preview branches](https://supabase.com/docs/guides/deployment/branching) create a separate Supabase environment per Git branch via the GitHub integration. Branches don't include production data; you populate them from a `seed.sql`. Each preview branch runs as a full Supabase project and bills as Branching Compute Hours. |
| AWS RDS for PostgreSQL | No native concept. Teams script `pg_dump`/restore or use snapshot-restore to create per-branch databases, which can take minutes to hours and bills as a separate full instance per branch. See [RDS backups](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html).                       |

The trade-off for Neon: branches share storage with the parent and divergent blocks bill as a small storage delta, so a dev branch is closer to free at idle. The trade-off for Supabase: no production data leaks into branches, but you also can't reproduce a production bug without seeding the branch yourself.

> **Branch your database**
>
> Try Git-style workflows on Postgres without copying data.
>
> [Sign up](https://console.neon.tech/signup)