Prisma
Back to blog

Serverless Postgres compared (2026): Neon, Supabase, Amazon RDS/Aurora and Prisma Postgres

Martin Janse van Rensburg
Martin Janse van Rensburg
July 9, 2026
Updated November 6, 2026

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. 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. Prisma's figures come from Prisma's own pricing page and docs, the same kind of source used for every other provider. Neon's Free plan figures were re-checked on 2026-10-05, after Neon raised the storage limit.

The providers at a glance

Rows in alphabetical order; checked 2026-10-12; we make Prisma Postgres.

Bills forScale-to-zeroCold startFree tierPaid entry
Amazon Aurora Serverless v2ACU-hours, billed per second, plus storage and I/OOptional: with a 0-ACU minimum, pauses after 5 min to 1 day idle~15 s; 30 s or more after a day pausedAWS 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 + storageNo: the instance bills while it runsNot applicable (provisioned instance)AWS Free plan credits (new accounts): db.t3.micro or db.t4g.microdb.t4g.micro $0.016/hour (~$11.68/month) + $0.115/GB-month, US East
NeonCU-hoursAfter 5 min idle; fixed on FreeA few hundred ms100 CU-hours and 1 GB per project, 100 projects, 20 GB totalLaunch: pay as you go, no monthly minimum, $0.106/CU-hour
PlanetScale PostgresCluster size + storage, backups, egressNot documentedNot documentedNone listed$5/month single node
Prisma PostgresOperations (queries)Not documentedNot documented200k operations, 2 GB, 50 databases$10/month (1M operations, 10 GB)
SupabasePlan + compute billed hourly per projectFree projects pause after 1 week idle; paid never pauseNone on paid; a paused Free project must be restored from the dashboard2 active projects, 500 MB$25/month Pro, with $10 compute credits

For the operational side of this choice, see choosing managed Postgres for a small team, including ownership, development access and recovery handoff.

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 v2Free 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-pauseRestore to any point in retention; up to 15 Aurora Replicas; automatic failover to a reader in another AZ
Amazon RDS for PostgreSQLFree plan credits for new AWS accounts on db.t3.micro or db.t4g.micro; no idle pause, the instance bills while it runsdb.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
NeonFree: 100 CU-hours and 1 GB per project; scales to zero after 5 min, fixed on FreeLaunch: pay as you go, no monthly minimum, $0.106/CU-hour; restore window up to 7 days; pooling on every planScale: 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 PostgresNo free plan; its docs don't describe scale-to-zero, and a cluster bills for the time it runsSingle 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 separatelyPoint-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 PostgresFree: 200k operations, 2 GB, 50 databases, no backupsStarter $10: 1M operations, 10 GB, PgBouncer pooling, daily snapshots kept 7 days; Pro $49: 10M operations, 50 GB, snapshots kept 7 daysBusiness: snapshots kept 30 days. Point-in-time recovery is not available yet; it is coming in November 2026. Prisma Postgres docs list neither read replicas nor high availability (checked 2026-10-12)
SupabaseFree: 2 active projects, 500 MB; paused after 1 week of inactivityPro from $25 (8 GB disk, $10 compute credits); daily backups kept 7 days; shared pooler on every plan, dedicated pooler on paid plansPITR add-on, $100/month per 7 days; asynchronous read replicas; high availability not listed on the pricing page, uptime SLAs on Enterprise only

Choose by workload

Walk the tree, or read the guidance beneath it.

Find your provider in five questions or fewer
What are you choosing a database for?Q1
The same decision tree as text

What are you choosing a database for?

  • A side project or prototype:

    Prisma Postgres. 200k operations, 2 GB and 50 databases per month free, with no card. Grows into $10/month for 1M operations. Prisma publishes this guide.

    Neon. Each of up to 100 projects gets its own free 100 CU-hours a month and 1 GB of storage, up to 20 GB across all projects, with scale-to-zero after 5 minutes idle. First query after idle takes a few hundred milliseconds. Supabase's free tier also works if week-idle pausing is acceptable.

  • A production workload:

    Do you want the platform to bundle more than the database?

    • Yes, batteries included:

      Supabase. The bundle is auth, storage, realtime and edge functions around Postgres, from $25/month with a Micro instance covered by credits. The economics are instance-shaped: paid projects are always-on, and serverless behaviors are not what you are buying.

      Prisma Postgres + Compute. A different bundle: database, ORM, and TypeScript app hosting designed together, with one schema and one config, and the app deployed next to the database. S3-compatible object storage buckets live in the same project. End-user auth and realtime are not part of this bundle; that is Supabase's territory.

    • No, I need Postgres:

      Which best describes the workload?

      • Steady and high-throughput, rarely idle:

        Is your infrastructure already committed to AWS?

        • Yes, deep in AWS:

          Aurora, sized for the load. At sustained throughput you want dedicated capacity inside the ecosystem you already run: IAM, VPC peering, global databases. Skip auto-pause for this workload shape; it is built for idle periods you do not have.

        • No:

          PlanetScale. Dedicated clusters from $5/month (single node) or $50/month on Metal, billed for the time they run, prorated to the millisecond. At sustained load, paying by the hour beats metering. There is no free tier, and its docs don't describe scale-to-zero; a cluster bills for the time it runs.

      • Real idle periods (nights, weekends, bursts):

        Can the first query after an idle stretch afford to be slow?

        • Yes (cron jobs, internal tools, dev/test):

          Neon. Scale-to-zero was built for exactly this: idle time costs storage only, and a few hundred milliseconds of wake-up is invisible to a cron job. If the workload later becomes user-facing, revisit; cold starts stop being free when someone is watching.

          Aurora auto-pause (on AWS). Set minimum capacity to 0 ACUs and instances pause after a configurable idle interval, with no compute charge while paused. Resume takes about 15 seconds, and an attached RDS Proxy prevents pausing entirely.

        • No, users are waiting on it:

          Roughly how many queries a month?

          • Up to about 10 million:

            Prisma Postgres. Operation-based billing fits this shape: idle time costs nothing extra, and up to about 10M queries a month stays inside the plan allowances ($10 covers 1M, $49 covers 10M). Prisma publishes this guide, so hold this recommendation to the same skepticism as the rest. Past roughly 24M queries a month the guide's own worked example shows an always-on Neon compute becomes cheaper.

          • More than that:

            A dedicated instance. Neon with auto-suspend disabled runs about $77/month per CU ($0.106 × 730 hours); PlanetScale starts at $5/month single node or $50/month Metal; paid Supabase is $25/month with a Micro covered. No per-query component. The worked example in the pricing-models section shows the ~24M crossover against the $49 operations plan.

            Prisma Postgres, higher tier. $1 per million operations at the top tier ($129/month with 50M included). Compare against the dedicated-instance options at your exact query count. Prisma publishes this guide.

      • A fleet of many small databases (per-tenant, per-user, per-agent):

        Prisma Postgres. Operations are metered account-wide across up to 1,000 databases in a workspace, so a fleet of small databases shares one allowance. Prisma publishes this guide; the account-wide metering claim is from our pricing page.

        Neon. Per-project allowances stretch far for fleets of prototypes: each of up to 100 projects brings its own free 100 CU-hours a month. This pattern is growing: Neon's telemetry had AI agents creating over 80% of databases on its platform as of May 2025.

  • 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 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). Prisma Postgres bills per query instead, and idle time adds nothing to its bill. The cost comparison 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 (TypeScript app hosting), S3-compatible object storage and the ORM as one platform.

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?

The category has three billing models, and the model matters more than any single feature.

ModelWho uses itYou pay forFavors
Compute-timeNeon, Aurora Serverless v2Hours or seconds of compute, sized to load, plus storageBursty or idle-heavy workloads that scale to zero
OperationsPrisma PostgresEach query, regardless of compute time, plus storageA bill that tracks traffic, not clock time
InstancesPlanetScale, SupabaseA dedicated instance, prorated by the time it runsSustained 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?

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: its docs don't describe scale-to-zero or a wake time; it bills per operation, not for compute time.

On compute-time platforms, cold starts are the price of the savings: eliminate them and you're paying for idle time again.

Provider profiles

Same attributes for each, so you can scan across them.

Prisma Postgres

Managed Postgres on unikernels in microVMs. (Disclosure: Prisma publishes this guide.)

  • Best for: apps that want the bill to track query traffic, and fleets of many small databases.
  • Bills for: operations, the one per-query model among the serverless Postgres options here. The pricing page counts one operation per create, read, update or delete, whether it is a simple write or a query with several joins. The Prisma Postgres FAQ adds that query duration does not change the price, and that with Prisma ORM each Prisma Client query is one operation, while with another client each SQL query over the direct connection is one (checked 2026-10-21).
  • Idle behaviour: Prisma Postgres docs don't describe scale-to-zero or a wake time (checked 2026-10-20).
  • 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 other than the default one 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).

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 now call its database Lakebase Postgres, which also runs on Databricks as Lakebase, and describe Neon as the version built for developers, startups and agent platforms, a positioning worth weighing for long-horizon bets.

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.
  • 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.
  • 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

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

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 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

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

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 compute autoscaling, no scale-to-zero, and none of them calls the product serverless. Railway is the edge case: it bills usage per second 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.

Moving a local SQLite app is a separate decision from choosing a PostgreSQL plan. The SQLite-to-Postgres hosting guide covers type conversion, a small import rehearsal and checks before inviting customers.

Frequently asked questions

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).

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 neither do Prisma Postgres docs.

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.

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 now call its database Lakebase Postgres, the same database Databricks offers as Lakebase. As of October 2026, Neon operates under its own brand with active pricing and docs, built for developers, startups and agent platforms. Those are stated intentions rather than guarantees, which is worth weighing for long-horizon platform bets.

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 second and offers an opt-in sleep feature for idle services, though its docs leave unstated whether volume-backed Postgres services can sleep.

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 makes total query volume the number to watch.

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? Prisma Postgres.

To try the operation-based model, spin up a Prisma 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.

About the author

Martin Janse van Rensburg
Martin Janse van Rensburg

Martin is a member of the Prisma team who has spent his career at the intersection of people, growth, and technology. He writes about the trends and news in the developer tools industry.

Keep reading

Build your next app with Prisma

Start free. Scale when you’re ready.

Try Prisma
Share this article