The main alternatives to PlanetScale's Postgres and Vitess databases, how they compare on pricing, where the database runs, branching and scaling, and how to run Postgres on RDS or Cloud SQL in your own cloud account.

PlanetScale built its name on Vitess, the MySQL sharding system that came out of YouTube, with branching and non-blocking schema changes on top, and since September 2025 it also sells managed Postgres. It gets harder to justify when the database is small and there is no free tier left, when the rest of the backend lives in AWS or GCP and the database sits in someone else's account, or when a Vitess app has to move to Postgres anyway.
This guide compares the main PlanetScale alternatives on pricing, where the database runs, branching and scaling, and shows how Encore runs Postgres on RDS or Cloud SQL in your own cloud account from a database declared in TypeScript.
PlanetScale prices are from its pricing page, checked November 17, 2026, for AWS us-east-1: Postgres starts at $5 a month for a single node with 1/16 vCPU and 512 MiB, $15 for a highly available PS-5 cluster with a primary and two replicas, and Vitess starts at $39 a month for a PS-10 cluster. Storage, backups and egress are billed on top. PlanetScale retired its free Hobby plan in April 2024.
Encore is a backend framework with built-in infrastructure for TypeScript and Go, and the database is one of those pieces: you declare it next to the code that queries it, encore run starts Postgres locally and applies your migrations, and each AWS or GCP environment gets Amazon RDS for PostgreSQL or Cloud SQL in your own account with the connection injected into your services. Encore supports Postgres only, so a Vitess app moves to Postgres on the way.
Run in your terminal to get started locally.
The orgs folder also gets an encore.service.ts that exports new Service("orgs"). The schema uses a foreign key and a composite primary key, the kind of constraints many apps left out on a sharded MySQL setup:
-- orgs/migrations/1_create_orgs.up.sql
CREATE TABLE orgs (
id BIGSERIAL PRIMARY KEY,
slug TEXT NOT NULL UNIQUE,
name TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE members (
org_id BIGINT NOT NULL REFERENCES orgs (id) ON DELETE CASCADE,
email TEXT NOT NULL,
role TEXT NOT NULL CHECK (role IN ('owner', 'admin', 'member')),
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (org_id, email)
);
The service creates an org and its owner in one transaction and lists members with a join:
// orgs/orgs.ts
import { api, APIError } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
// RDS for PostgreSQL on AWS, Cloud SQL on GCP, started locally by `encore run`.
const db = new SQLDatabase("orgs", { migrations: "./migrations" });
interface Org {
id: number;
slug: string;
name: string;
}
interface CreateOrgParams {
slug: string;
name: string;
ownerEmail: string;
}
interface Member {
email: string;
role: string;
}
// Creates the org and its owner in one transaction, so neither row
// exists without the other.
export const create = api(
{ expose: true, method: "POST", path: "/orgs" },
async (p: CreateOrgParams): Promise<Org> => {
const slug = p.slug.trim().toLowerCase();
if (!/^[a-z0-9-]{3,40}$/.test(slug)) {
throw APIError.invalidArgument("slug must be 3-40 lowercase letters, digits or dashes");
}
if (!p.ownerEmail.includes("@")) {
throw APIError.invalidArgument("valid ownerEmail required");
}
await using tx = await db.begin();
const org = await tx.queryRow<Org>`
INSERT INTO orgs (slug, name) VALUES (${slug}, ${p.name})
ON CONFLICT (slug) DO NOTHING
RETURNING id, slug, name`;
if (!org) {
throw APIError.alreadyExists(`slug ${slug} is taken`);
}
await tx.exec`
INSERT INTO members (org_id, email, role)
VALUES (${org.id}, ${p.ownerEmail.toLowerCase()}, 'owner')`;
await tx.commit();
return org;
},
);
export const members = api(
{ expose: true, method: "GET", path: "/orgs/:slug/members" },
async ({ slug }: { slug: string }): Promise<{ members: Member[] }> => {
const rows = await db.queryAll<Member>`
SELECT m.email, m.role
FROM members m
JOIN orgs o ON o.id = m.org_id
WHERE o.slug = ${slug}
ORDER BY m.created_at`;
return { members: rows };
},
);
A second POST with the same slug returns already_exists instead of a duplicate row, and if the member insert fails, await using rolls the transaction back so no org is left without an owner. The queries are tagged templates, so every ${} value is sent as a bind parameter rather than pasted into the SQL, and the database docs cover query, queryAll, exec and transactions. The SQL in this sample was checked against Postgres 17, including the conflict on the second insert, which returns no row.
On deploy, Encore applies the migrations and provisions the database in the cloud account you connected, as the infrastructure docs list per environment, and you can import an existing RDS instance instead of creating a new one. If branching is the PlanetScale feature you would miss, environments can also use Neon as the database provider and branch from another environment. An AI coding agent working in this repository writes the migration, the query and the endpoint in one change and tests them against the local Postgres before anything is deployed, with no connection string to look up or paste.
Best fit: TypeScript or Go backends on AWS or GCP that want Postgres in their own account, declared next to the code and running locally with encore run.
RDS runs Postgres, MySQL and MariaDB on instances you size yourself, with Multi-AZ standbys, read replicas and automated backups, and Aurora is AWS's own Postgres- and MySQL-compatible engine with storage that grows on its own and up to 15 low-latency read replicas. Aurora Serverless v2 bills per Aurora Capacity Unit and, since late 2024, can scale to zero and pause when idle, which covers part of what made PlanetScale and Neon attractive for small databases.
Aurora MySQL is the closest drop-in for a Vitess app that does not want to change engines, while RDS for PostgreSQL is the usual target for teams moving to Postgres. Both live in your VPC, so services on ECS, EKS or Lambda reach them over the private network, at the cost of setting up the VPC, subnets, security groups and parameter groups yourself or in Terraform. There is no branching, and schema changes are your migration tool's job.
Best fit: backends already on AWS that want the database in the same VPC and are fine owning the instance sizing and networking.
Cloud SQL runs managed Postgres, MySQL and SQL Server on GCP, with high availability across zones, read replicas and point-in-time recovery, and the Enterprise Plus edition adds faster maintenance and a data cache. Cloud Run and GKE connect over private IP or through the Cloud SQL Auth Proxy, and pricing follows the vCPUs and memory you provision, so a database costs the same at night as at peak.
For heavier Postgres workloads, AlloyDB is Google's Postgres-compatible engine with a columnar engine for analytics queries, priced higher than Cloud SQL.
Best fit: backends on Cloud Run or GKE that want Postgres or MySQL in the same Google Cloud project.
Neon is serverless Postgres with storage separated from compute, so a database can scale to zero after five minutes idle and branch in seconds as a copy-on-write fork of another branch, which is the closest match to PlanetScale's branching for Postgres. It was acquired by Databricks in 2025, and its pricing page, checked November 17, 2026, lists a Free plan with 100 projects, a Launch plan at $0.106 per CU-hour and $0.35 per GB-month, and a Scale plan at $0.222 per CU-hour.
The database runs on Neon's infrastructure, reached over the internet with TLS or through private networking on the Scale plan, and cold starts after scale to zero add latency to the first query.
Best fit: apps with spiky or low traffic and teams that want a database branch for every pull request.
Supabase gives each project a dedicated Postgres instance plus auth, file storage, realtime subscriptions and an auto-generated REST API. The Pro plan is $25 a month and includes $10 of compute credits, enough for one Micro instance with 1 GB of RAM, and larger instances run from $15 to several thousand dollars a month, according to its pricing page checked November 17, 2026.
For a team leaving PlanetScale only for the database, much of Supabase goes unused, but for an app that would otherwise add an auth provider and a storage service, having them in one place is the draw.
Best fit: apps that want Postgres together with auth, storage and a generated API from one provider.
TiDB is a distributed SQL database from PingCAP that speaks the MySQL protocol and scales horizontally without application-level sharding, which makes it the main option for Vitess users who need to stay on MySQL. TiDB Cloud Starter scales to zero with a free allowance of 5 GiB of row storage and 50 million request units a month per instance, Dedicated clusters start at $1,376 a month, and a bring-your-own-cloud option runs it in your account, from PingCAP's pricing page checked November 17, 2026.
TiDB's MySQL compatibility is broad but not complete, so stored procedures and some functions need checking before a move.
Best fit: large MySQL workloads that need to scale out without moving to Postgres.
Stay on PlanetScale if you run a large Vitess or Postgres workload that benefits from its sharding, Metal storage and support, and the price is small next to what the database does for you. Pick Aurora MySQL or TiDB Cloud when the app has to stay on MySQL, and RDS for PostgreSQL or Cloud SQL when you are moving to Postgres and want the database in the same cloud account as the rest of the backend. Pick Neon or Supabase for a hosted Postgres with a free tier and branching or built-in auth. Pick Encore when you want Postgres on RDS or Cloud SQL in your own account with the database, its migrations and the services that use it declared in TypeScript or Go and running locally with encore run.
For a backend on AWS or GCP, the most common alternative is managed Postgres in your own account: Amazon RDS or Aurora on AWS, or Cloud SQL on GCP. Neon and Supabase suit teams that want a hosted Postgres with a free tier, and TiDB Cloud suits teams that need to stay MySQL-compatible with horizontal scaling.
PlanetScale for Postgres became generally available in September 2025, next to its original Vitess databases for MySQL. Single-node Postgres starts at $5 a month and a highly available cluster with a primary and two replicas at $15 a month, and Neki, its sharded Postgres, is in platform preview. Prices checked November 17, 2026.
PlanetScale has had no free tier since it retired the Hobby plan on April 8, 2024, and the cheapest option today is a single-node Postgres database at $5 a month, while Neon, Supabase and TiDB Cloud Starter still offer free tiers.
With Encore you declare the database in TypeScript with new SQLDatabase("orgs", { migrations: "./migrations" }) and query it with tagged templates such as db.queryRow and db.exec. encore run starts Postgres locally and applies the migrations, and on deploy Encore provisions Amazon RDS for PostgreSQL in your AWS account, or Cloud SQL on GCP, and connects your services to it.
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.