Serverless, scale-to-zero Postgres with branching against fixed-size Postgres clusters on dedicated nodes: architecture, pricing, high availability, branching and how each fits development and production.

Neon and PlanetScale are both popular managed Postgres choices in 2026, and they come at the database from opposite directions. Neon, acquired by Databricks in 2025, split Postgres storage from compute, so a database can scale to zero, autoscale under load, and branch like a git repository in a second. PlanetScale built its name on MySQL with Vitess, launched Postgres in 2025, and runs it on dedicated nodes with replicas and, optionally, local NVMe drives.
Which one fits depends less on features than on the shape of your workload: idle most of the day with bursts and many short-lived branches, or busy around the clock with latency that has to stay flat. This guide compares the two on the points that decide it.
Neon runs Postgres compute as stateless processes that page data from a distributed storage layer. That makes compute cheap to start, stop and resize, which is what enables scale to zero and instant branches. The cost is a cold start when a suspended compute wakes, typically well under a second to a few seconds, and reads that miss the local cache go to the storage layer over the network.
PlanetScale runs each cluster on its own nodes. With Metal clusters, data lives on local NVMe drives on the primary and replicas, which gives low, steady I/O latency for write-heavy workloads, and streaming replication rather than shared storage provides durability. There is no idle state to wake from, which also means you pay for the cluster whether or not it is busy.
Neon's paid Launch plan bills compute at $0.106 per CU-hour, where one CU is about 4 GB of RAM, and storage at $0.35 per GB-month, with no monthly minimum; the free plan includes 100 CU-hours per project. A database that runs at 0.25 CU for eight hours a day costs about $6 a month in compute.
PlanetScale Postgres bills per cluster per month. The smallest size, PS-5 with 1/16 vCPU and 512 MiB, costs $5 as a single node or $15 as a three-node HA cluster, and a 1 vCPU, 8 GiB HA cluster costs $148 to $179 depending on architecture, plus storage, backups and egress, according to its pricing page in November 2026. Production-sized Neon computes that never sleep can cost more than the equivalent PlanetScale cluster, so model both with your expected hours.
Neon's branching creates a full copy of a database's data and schema almost instantly using copy-on-write, so a preview environment per pull request gets realistic data without a restore. Branches can reset to their parent and expire automatically.
PlanetScale Postgres branches are fully isolated databases with their own storage. A development branch starts on a single-node PS-DEV instance from about $5 a month, either empty or restored from a backup when you want schema and data, and PlanetScale advises against using production data in development branches. That is closer to a cheap staging database per branch than to a disposable copy.
PlanetScale's HA SKUs place a primary and two replicas in different availability zones, with failover handled by the platform, and offer an optional dedicated PgBouncer. Neon keeps data durable in its storage layer and restarts a failed compute quickly, offers read replicas as extra computes, and includes a built-in PgBouncer pooled endpoint, which matters for serverless functions that open many short connections.
Best fit: Neon for development databases, preview environments, side projects and spiky workloads where scale to zero and branching save money and time. PlanetScale for steady production load that needs replicas across zones and consistent I/O latency.
Encore brings infrastructure from code, and you declare a database in code without naming a provider. Where it runs is chosen per environment: RDS or Aurora on AWS, Cloud SQL on GCP, or Neon, which is a built-in option when you create an environment. Encore can create a new Neon project and branch, branch from another environment's Neon database, or import an existing branch, then runs your migrations on it.
package accounts
import (
"context"
"encore.dev/storage/sqldb"
)
// The same declaration runs on local Postgres, Neon, RDS or Cloud SQL,
// depending on how each environment is configured.
var db = sqldb.NewDatabase("accounts", sqldb.DatabaseConfig{Migrations: "./migrations"})
type Account struct {
ID string `json:"id"`
Email string `json:"email"`
}
//encore:api auth method=GET path=/accounts/:id
func Get(ctx context.Context, id string) (*Account, error) {
a := &Account{ID: id}
err := db.QueryRow(ctx, `SELECT email FROM accounts WHERE id = $1`, id).Scan(&a.Email)
return a, err
}
Preview environments can also branch from a Neon-backed environment, so each pull request gets its own copy of populated data. Use only a scrubbed, non-production source environment for this: previews run unreviewed pull-request code, and production data must never be copied into them. A common split is Neon for development and preview environments, and RDS or Cloud SQL in your own AWS or GCP account for production, all from the same code. PlanetScale is not a built-in option; to use it, connect as an external database with a pgx pool and the connection string stored as an Encore secret, and manage its migrations yourself.
When an agent changes the schema, it adds a migration file and runs it against local Postgres with encore run; the same migration then runs on whichever provider each environment uses.
Best fit: teams that want provider choice per environment, Neon branches for development and their own cloud account for production, without changing application code.
Pick Neon when databases sit idle much of the time, when you want a branch per pull request, or when you are starting small and want a free plan. Pick PlanetScale Postgres when the database is busy all day, you want replicas across zones from the start, and predictable monthly pricing matters more than scale to zero. If you build on Encore, Neon can be selected per environment with no code change, and PlanetScale works as an external database.
Neon separates storage from compute, so compute autoscales and can scale to zero, and branches are copy-on-write copies of a database. PlanetScale Postgres runs fixed-size clusters on dedicated nodes, either single-node or a primary with two replicas, with network-attached or local NVMe storage, billed monthly per cluster size.
For small or spiky workloads that sit idle, Neon is usually cheaper, since scale to zero stops compute charges and its usage-based plan has no monthly minimum. For steady production load, PlanetScale's fixed monthly clusters are easier to predict, starting at $5 a month for a single node and $15 for a three-node highly available cluster at the smallest size, per its pricing page in November 2026.
PlanetScale's HA clusters run a primary and two replicas across availability zones by default. Neon stores data redundantly in its storage layer and can restart compute quickly, and you can add read replicas, but a single compute endpoint is still one Postgres process. Check each provider's SLA for your plan.
Yes. Neon is a built-in database option: when you create an Encore environment you can choose Neon, and Encore creates or branches the Neon project for it. PlanetScale is not a built-in option, but you can connect to it as an external database with the connection string stored as an Encore secret.
Deploy to your cloud on AWS and Google Cloud
without managing infrastructure
Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.