# Serverless Postgres compared (2026): Neon, Supabase, Amazon RDS/Aurora and Prisma Postgres URL: https://www.prisma.io/blog/serverless-postgres Published: 2026-07-09 Updated: 2026-10-14 Authors: Martin Janse van Rensburg Tags: prisma-postgres, platform Description: Serverless and managed Postgres compared for 2026: Neon, Supabase, Amazon RDS and Aurora Serverless v2, Prisma Postgres and PlanetScale on billing, scale-to-zero, cold starts, free tiers and what each adds as an app grows. Serverless Postgres is PostgreSQL you never provision or manage: the platform allocates compute on demand and bills you for usage, not for a server size you picked up front. One label, though, covers very different products, and they differ on two things that decide your cost and your latency: **what they bill for**, and **whether compute sleeps when idle**. We make Prisma Postgres. This guide leads with the comparison and a way to choose, then explains the reasoning. It compares serverless behavior and pricing, plus a by-stage table of free tiers, backups, restore options, read replicas and high availability as each vendor documents them. Extensions, regions and compliance stay out of scope. For healthcare workloads, see [HIPAA compliant Postgres on Prisma Postgres](https://www.prisma.io/postgres/hipaa). The two tables were checked against each provider's own pages and price lists on 2026-10-12, and the rest of the guide, including the provider profiles, in July 2026 unless dated; PlanetScale's billing and idle behaviour were rechecked throughout on 2026-10-12. Vendor claims (including Prisma's) are labeled as such. Neon's Free plan figures were re-checked on 2026-10-05, after Neon raised the storage limit. ## The providers at a glance [#the-providers-at-a-glance] Rows in alphabetical order; checked 2026-10-12; we make Prisma Postgres. | | Bills for | Scale-to-zero | Cold start | Free tier | Paid entry | | ----------------------------------------------------------- | -------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------------- | | **Amazon Aurora Serverless v2** | ACU-hours, billed per second, plus storage and I/O | Optional: with a 0-ACU minimum, pauses after 5 min to 1 day idle | \~15 s; 30 s or more after a day paused | AWS Free plan credits (new accounts): up to 4 ACUs, 1 GiB per cluster | $0.12 per ACU-hour + $0.10/GB-month storage, US East | | **Amazon RDS for PostgreSQL** (provisioned, not serverless) | Instance hours + storage | No: the instance bills while it runs | Not applicable (provisioned instance) | AWS Free plan credits (new accounts): db.t3.micro or db.t4g.micro | db.t4g.micro $0.016/hour (\~$11.68/month) + $0.115/GB-month, US East | | **Neon** | CU-hours | After 5 min idle; fixed on Free | A few hundred ms | 100 CU-hours and 1 GB per project, 100 projects, 20 GB total | Launch: pay as you go, no monthly minimum, $0.106/CU-hour | | **PlanetScale Postgres** | Cluster size + storage, backups, egress | Not documented | Not documented | None listed | $5/month single node | | **Prisma Postgres** | Operations (queries) | No (stays ready; vendor claim) | None (by design; vendor claim) | 200k operations, 2 GB, 50 databases | $10/month (1M operations, 10 GB) | | **Supabase** | Plan + compute billed hourly per project | Free projects pause after 1 week idle; paid never pause | None on paid; a paused Free project must be restored from the dashboard | 2 active projects, 500 MB | $25/month Pro, with $10 compute credits | ## By stage: prototype, first paying users, growth [#by-stage-prototype-first-paying-users-growth] What each provider documents as an app moves from a free prototype to its first paid plan and then grows. Each cell comes from the vendor's own pricing page or docs; nothing is inferred. Rows in alphabetical order; checked 2026-10-12; we make Prisma Postgres. | | Prototype (free tier, idle rule) | First paying users (entry paid plan, backups, pooling) | Growth (restore options, read replicas, high availability, as documented) | | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Amazon Aurora Serverless v2** | Free plan credits for new AWS accounts: up to 4 ACUs, 1 GiB per cluster; with a 0-ACU minimum it pauses when idle, \~15 s to resume | $0.12 per ACU-hour + storage; continuous backups kept 1–35 days; pooling through RDS Proxy ($0.015 per ACU-hour, 8-ACU minimum), which stops auto-pause | Restore to any point in retention; up to 15 Aurora Replicas; automatic failover to a reader in another AZ | | **Amazon RDS for PostgreSQL** | Free plan credits for new AWS accounts on db.t3.micro or db.t4g.micro; no idle pause, the instance bills while it runs | db.t4g.micro $0.016/hour, Single-AZ; automated backups kept up to 35 days (7 by default in the console); pooling through RDS Proxy ($0.015 per vCPU-hour, 2-vCPU minimum) | Restore to any point in retention (logs every 5 min); asynchronous read replicas; Multi-AZ with one or two standbys | | **Neon** | Free: 100 CU-hours and 1 GB per project; scales to zero after 5 min, fixed on Free | Launch: pay as you go, no monthly minimum, $0.106/CU-hour; restore window up to 7 days; pooling on every plan | Scale: restore window up to 30 days; read replicas on every plan, billed as CU-hours; multi-AZ storage on every plan, uptime SLA on Scale | | **PlanetScale Postgres** | No free plan; its docs don't describe scale-to-zero, and a cluster bills for the time it runs | Single node from $5/month (1/16 vCPU, 512 MiB, 10 GB storage included); backups every 12 hours, kept 2 days, with backup storage of 2x disk size included; local PgBouncer on every database, dedicated PgBouncer billed separately | Point-in-time recovery within backup retention (2 days by default; longer with custom backups, which can cost extra); high availability from $15/month: 1 primary + 2 replicas across 3 AZs with automatic failover; extra and dedicated read replicas billed separately | | **Prisma Postgres** | Free: 200k operations, 2 GB, 50 databases, no backups | Starter $10: 1M operations, 10 GB, PgBouncer pooling, daily snapshots kept 7 days; Pro $49: 10M operations, 50 GB, snapshots kept 7 days | Business: snapshots kept 30 days. Point-in-time recovery is not available yet. Prisma Postgres docs list neither read replicas nor high availability (checked 2026-10-12) | | **Supabase** | Free: 2 active projects, 500 MB; paused after 1 week of inactivity | Pro from $25 (8 GB disk, $10 compute credits); daily backups kept 7 days; shared pooler on every plan, dedicated pooler on paid plans | PITR add-on, $100/month per 7 days (needs Small compute or larger); asynchronous read replicas; high availability not listed on the pricing page, uptime SLAs on Enterprise only | ## Choose by workload [#choose-by-workload] Walk the tree, or read the guidance beneath it. * **Side project, prototype, or agent-generated app:** you want a generous free tier and zero setup. Prisma Postgres (200k operations, 50 databases, no card), Neon (100 CU-hours per project, up to 100 projects), or Supabase (2 projects, if week-idle pausing is acceptable). * **Spiky or scheduled workloads (cron jobs, internal tools, dev/test fleets):** compute-time billing with scale-to-zero was built for this. Neon, or Aurora if you're already on AWS and can tolerate \~15-second resumes. * **User-facing apps that go idle but have latency-sensitive users:** this is where cold starts hurt. Either keep the database always ready and pay per query (Prisma Postgres), disable auto-suspend on Neon, or run a small instance on PlanetScale ($5 single node; its docs don't describe scale-to-zero) or paid Supabase ($25; paid projects never pause). The [cost comparison](#the-cost-crossover) below shows how to pick between them. * **Steady, high-throughput production:** dedicated capacity wins on price-per-query at sustained load. PlanetScale (from $5 single node, $50 Metal), or Aurora sized for the load. * **Many small databases (per-tenant, per-user, per-AI-agent):** account-level metering across a fleet beats per-database pricing. Prisma Postgres meters operations across all databases in a workspace; Neon's per-project free allowance also stretches far. * **You want more than a database:** for auth, storage, and realtime out of the box, Supabase. For app hosting alongside the database, Prisma pairs Prisma Postgres with [Prisma Compute](https://www.prisma.io/docs/compute) (TypeScript app hosting, generally available since August 2026) and the ORM as one platform. ## The two decisions that matter [#the-two-decisions-that-matter] Everything else follows from two questions. Answer them and the shortlist above nearly picks itself. ### 1. What do you pay for? [#1-what-do-you-pay-for] The category has three billing models, and the model matters more than any single feature. | Model | Who uses it | You pay for | Favors | | ------------ | -------------------------- | -------------------------------------------------------- | ------------------------------------------------------ | | Compute-time | Neon, Aurora Serverless v2 | Hours or seconds of compute, sized to load, plus storage | Bursty or idle-heavy workloads that scale to zero | | Operations | Prisma Postgres | Each query, regardless of compute time, plus storage | A bill that tracks traffic, not clock time | | Instances | PlanetScale, Supabase | A dedicated instance, prorated by the time it runs | Sustained load where dedicated capacity beats metering | * **Compute-time rewards idleness.** A database that sleeps 20 hours a day costs a fraction of an always-on one. A workload that never idles loses the whole advantage. * **Operations track traffic.** The plans are flat monthly tiers with allowances, so the floor is the plan price rather than zero, with no idle-versus-active math. The catch: the query count *is* the bill, so chatty patterns (N+1, polling) cost more. * **Instances are the most predictable.** A fixed monthly rate for as long as the instance runs. ### 2. What happens when the database is idle? [#2-what-happens-when-the-database-is-idle] Serverless databases separate compute from storage, so compute can stop while your data stays put. What each provider does with that idle time is what your users feel: * **Scale-to-zero** suspends compute after an idle period, so an unused database costs storage only. * **Cold start** is the price of that nap: the first query after a suspension waits for compute to wake. Where a provider suspends, the wake time below is from its own docs; where it doesn't, or its docs don't say, that is stated instead: * **Neon:** activating from idle "typically takes a few hundred milliseconds" (Neon's docs). Paid plans can disable auto-suspend. * **Aurora Serverless v2:** resume from 0 ACUs takes "approximately 15 seconds," or 30+ after a pause over 24 hours (AWS's docs). * **Supabase:** paid projects never pause (no cold start); free projects pause after a week and need a restore. * **PlanetScale:** its docs don't describe scale-to-zero or a wake time; a cluster bills for the time it runs, prorated to the millisecond. * **Prisma Postgres:** always ready, so no cold start, by architecture rather than by paying for idle time. This is our own claim about our own product (see the [architecture write-up](https://www.prisma.io/blog/prisma-postgres-the-future-of-serverless-databases)) and isn't independently benchmarked; hold it to the same skepticism as any vendor claim. On compute-time platforms, cold starts are the price of the savings: eliminate them and you're paying for idle time again. ## Provider profiles [#provider-profiles] Same attributes for each, so you can scan across them. ### Prisma Postgres [#prisma-postgres] Managed Postgres on unikernels in microVMs, designed so databases are always ready. (Disclosure: Prisma publishes this guide; the no-cold-start claim is ours and is documented but not independently benchmarked.) * **Best for:** apps that want the bill to track query traffic, and fleets of many small databases. * **Bills for:** operations, defined on the [pricing page](https://www.prisma.io/pricing) as "each time you interact with your database, no matter the compute time. We count the Prisma ORM queries you make, not the SQL statements you run." Check the pricing docs for how non-ORM queries count. * **Idle behaviour:** no scale-to-zero and no cold starts; databases stay ready. * **Free / entry:** 200,000 operations, 2 GB, and 50 databases, no card; paid from $10/mo (1M operations, 10 GB, then $0.008 per 1,000) to $129/mo (50M operations). Allowances are account-wide, not per database. * **Watch out for:** no copy-on-write database copies yet (separate databases are the substitute: on Prisma Compute, every pushed branch gets a preview with its own services and, for databases declared in the Prisma Composer module, its own new database; production data is not copied); less operational track record than Aurora or Supabase; at sustained high query volume the per-operation math can exceed always-on billing (see the [cost comparison](#the-cost-crossover)). ### Neon [#neon] The reference implementation of the compute-time model, and the provider that popularized serverless Postgres. * **Best for:** bursty or idle-heavy workloads that can tolerate a sub-second wake. * **Bills for:** compute in CUs (1 CU = 1 vCPU + 4 GB), $0.106/CU-hour on Launch, $0.222 on Scale, storage $0.35/GB-month. Pay-as-you-go, no monthly minimum. * **Idle behaviour:** suspends after 5 minutes; wakes in "a few hundred milliseconds." Paid plans can disable auto-suspend for zero cold starts. * **Free / entry:** per project: each of up to 100 projects gets 100 CU-hours a month and 1 GB of storage, with storage capped at 20 GB across all projects. * **Watch out for:** Databricks agreed to acquire Neon in May 2025; Neon's docs say it continues as a standalone platform positioned alongside Databricks Lakebase, which is a stated intention worth weighing for long-horizon bets. ### Aurora Serverless v2 [#aurora-serverless-v2] AWS's elastic Postgres (and MySQL), billing capacity in ACU-seconds within a range you configure. * **Best for:** teams already deep in AWS who need its ecosystem (IAM, VPC peering, global databases). * **Bills for:** ACU-seconds (1 ACU ≈ 2 GB RAM), per second, varying by region; model it on the [AWS pricing page](https://aws.amazon.com/rds/aurora/pricing/). * **Idle behaviour:** optional scale-to-zero at a 0-ACU minimum (since late 2024); resume "approximately 15 seconds," 30+ after a 24-hour pause, per [AWS's docs](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2-auto-pause.html). * **Free / entry:** new AWS accounts get a credits-based Free plan that includes Aurora PostgreSQL serverless with up to 4 ACUs and 1 GiB of storage per cluster (checked 2026-10-12); otherwise standard AWS billing. * **Watch out for:** an attached RDS Proxy, logical replication, or being the writer in a global database each silently keeps instances awake and defeats auto-pause. ### Supabase [#supabase] A backend platform (auth, storage, realtime, edge functions) with Postgres at its center, rather than a pure database service. * **Best for:** teams who want the bundled backend more than serverless behavior. * **Bills for:** an instance plus usage; $10/mo of credits covers one Micro (2-core ARM, 1 GB RAM), with dedicated instances from $15 to $3,730/mo billed hourly. * **Idle behaviour:** paid projects never pause (no cold starts); free projects pause after a week of inactivity. * **Free / entry:** 2 projects at 500 MB each; paid entry $25/mo. * **Watch out for:** measured against the serverless behaviors above, it shows the fewest of the five, which matters only if serverless behavior is what you came for. ### PlanetScale Postgres [#planetscale-postgres] Long a MySQL/Vitess platform; it entered Postgres in 2025 and takes a different position from Neon: it bills a cluster by size and running time. * **Best for:** sustained production workloads where predictable dedicated performance justifies paying every hour. * **Bills for:** a dedicated instance per branch, by size, prorated to the millisecond. * **Idle behaviour:** PlanetScale's docs don't describe scale-to-zero or cold starts; a cluster bills for the time it runs (checked 2026-10-12). * **Free / entry:** no free tier; from $5/mo (single node), $15/mo (highly available), and $50/mo for the Metal tier (locally attached NVMe, storage included). * **Watch out for:** you pay for every hour the cluster runs. (Postgres reached GA on September 22, 2025; Metal on December 15, 2025. The Drizzle ORM team joined PlanetScale in March 2026, with Drizzle stated to stay an independent open source project.) ## The cost crossover [#the-cost-crossover] The operations-versus-compute question has a crossover point, and it's worth doing the arithmetic once. Take an app running 30M queries a month: * **Operations (Prisma Postgres):** about **$89** on the $49 plan (10M operations included, 20M overage at $0.002 per 1,000). * **Compute (Neon):** about **$77/mo** for a dedicated, always-on 1-CU compute ($0.106 × 730 hours), with no per-query component. Below that crossover, operation billing keeps you off always-on costs; above it, a dedicated instance is cheaper per query. A companion post breaks Prisma Postgres and Neon pricing down line by line. ## Secondary considerations [#secondary-considerations] Beyond billing and idle behavior, a production choice touches a few more things. They rarely decide the shortlist, but they can break a tie: * **Branching.** Copy-on-write storage lets several providers fork a database like a Git branch for previews or migration tests. Neon includes 10 branches per project free; Supabase bills $0.01344 per branch-hour; PlanetScale runs each branch as its own billed cluster. Prisma Postgres has no copy-on-write copies yet; its substitute is separate databases (50 free, 1,000 on paid). * **Connection pooling.** Serverless functions open connections fast, and Postgres tolerates a limited number. Prisma Postgres, Neon, and Supabase build in a pooler. On Aurora the answer is RDS Proxy, a separately billed service that holds connections open and, as a result, prevents auto-pause from ever engaging. * **Ecosystem.** Aurora buys into the full AWS stack; Supabase bundles auth, storage, and realtime; PlanetScale brings its Vitess and Metal operational heritage. ## Other providers you may encounter [#other-providers-you-may-encounter] The five above cover the main shapes. Most of the rest of the managed-Postgres market isn't serverless at all, and knowing which is which is half the value of the label. All checked against vendor pages in July 2026. **Serverless-adjacent:** * **Xata** relaunched in 2025 around copy-on-write branching ("one Postgres, thousands of branches"), with idle branches hibernating and waking in about a second. Billing is hourly per instance (from $0.012/hour) plus $0.28/GB-month; no permanent free cloud tier ($100 in 14-day credits), and its core is Apache 2.0 as of 2026. * **Nile** is serverless Postgres for multi-tenant apps: every tenant is a virtual database in one Postgres, billed in query tokens (free tier 50M tokens and 1 GB; Pro from $15/mo). Its bet is multi-tenant compute that never pauses. * **Tembo** pivoted in May 2025 to running AI coding agents and no longer markets a Postgres product. Worth knowing if you shortlisted it from an older comparison. **Managed instances (not serverless):** DigitalOcean (from $15.15/mo), Render (from $6/mo, billed per second), and Heroku Postgres (from $5/mo) all sell instance sizes you pick and resize yourself: no autoscaling, no scale-to-zero, and none of them calls the product serverless. Railway is the edge case: it bills usage per minute and offers opt-in sleep for idle services, though its docs don't say whether volume-backed Postgres can sleep. **Hyperscalers:** Aurora Serverless v2 (above) is the only hyperscaler Postgres that auto-suspends. Amazon RDS for PostgreSQL is provisioned managed Postgres: you pick an instance class and pay by the hour it runs, with automated backups and point-in-time restore inside a 1–35 day retention period (0 days turns automated backups off), read replicas and Multi-AZ standbys (checked 2026-10-12). Google Cloud SQL and AlloyDB, and Azure Database for PostgreSQL Flexible Server (from \~$12/mo), all use fixed compute with manual stop at most, and none is branded serverless by its own vendor. The test that sorts the field: if you pick an instance size and the vendor never suspends it for you, that's managed Postgres, which may be exactly what you need. ## Frequently asked questions [#frequently-asked-questions] ### What is serverless Postgres? Serverless Postgres is PostgreSQL run by a platform that allocates compute on demand and bills for usage instead of a provisioned server. Implementations differ: some meter compute time and suspend when idle (Neon, Aurora Serverless v2), some bill per query with compute fully abstracted (Prisma Postgres), and some sell managed instances billed for the time they run (PlanetScale, Supabase). ### Do all serverless Postgres databases have cold starts? No. Cold starts only exist where compute suspends: Neon takes a few hundred milliseconds to activate from idle (its own docs' figure), and Aurora Serverless v2 takes about 15 seconds to resume from 0 ACUs. Paid Supabase projects avoid cold starts by never pausing, which you pay for as always-on instances; PlanetScale's docs don't describe scale-to-zero or cold starts; and Prisma Postgres states its unikernel architecture has no suspended state at all (a vendor claim, ours). ### Which serverless Postgres is cheapest for a side project? For most side projects, a free tier covers it entirely: Prisma Postgres includes 200,000 operations, 2 GB and 50 databases per month with no credit card, and Neon includes 100 CU-hours and 1 GB of storage per project, for up to 100 projects and 20 GB of storage in total. The first paid dollar differs by model: $5/month buys a single node on PlanetScale, $10/month buys 1M operations on Prisma Postgres, and Neon bills pure usage with no minimum. ### Is Neon still maintained after the Databricks acquisition? Yes. Databricks agreed to acquire Neon on May 14, 2025 (reported at about $1 billion) and committed to continued investment in the platform; Neon's own docs describe it as continuing as a standalone serverless Postgres platform. As of July 2026, Neon operates under its own brand with active pricing and docs, positioned as complementary to Databricks Lakebase. Those are stated intentions rather than guarantees, which is worth weighing for long-horizon platform bets. ### Are DigitalOcean, Render, Heroku, Railway, Cloud SQL, or Azure Postgres serverless? Mostly no. DigitalOcean, Render, Heroku, Cloud SQL, and Azure Flexible Server sell instance sizes you pick, with no compute autoscaling and no automatic suspension, and none of their vendors calls these products serverless. Cloud SQL and Azure support stopping an instance manually (Azure restarts stopped servers automatically after 7 days), which saves money but is not scale-to-zero. Railway is the group's exception: it bills actual usage per minute and offers an opt-in sleep feature for idle services, though its docs leave unstated whether volume-backed Postgres services can sleep. ### What is the difference between scale-to-zero and no cold starts? Scale-to-zero means compute suspends when idle so you stop paying for it; the cost is a cold start when traffic returns. No cold starts means the database is always ready; on an instance that never pauses, such as paid Supabase, you achieve it by paying for idle time. Operation-based billing moves the question instead of splitting it: you pay per query rather than for compute time in either state, which removes cold starts from the equation but makes total query volume the number to watch. ## The bottom line [#the-bottom-line] Pick by the shape of your workload: * **Can sleep, tolerant of a sub-second wake?** Neon. * **Dedicated capacity you want to be predictable?** PlanetScale, or paid Supabase if you also want the bundled backend. * **Already committed to AWS?** Aurora Serverless v2. * **Want costs tied to query traffic, with no cold starts?** Prisma Postgres. To try the operation-based model, spin up a [Prisma Postgres](https://www.prisma.io/docs/postgres) database in seconds with `npx create-db` (no account; temporary until you claim it), or use `npx prisma dev` for a local instance. For the money side in depth, a companion post breaks Prisma Postgres and Neon pricing down line by line.