9 Neon Alternatives: $79 to $195 for the Same Database

The nine Neon alternatives below run the same 2 vCPU, 8 GB RAM, 100 GB Postgres database for anywhere between $79.19 and $195.00 a month. The clearest description of who this comparison is for was written by somebody else:

“I’m looking for a managed Postgres provider and not a full backend platform. Auth, object storage, APIs, and application hosting are already separate parts of my stack.

What I need from the database provider is automated backups, patching, basic monitoring, reliable uptime, and clearly allocated CPU, memory, and storage. I don’t use database branching, and scale to zero isn’t useful for this workload.”

r/PostgreSQL, August 2026

The same post asks which alternatives suit an “always running Postgres instance”, and the first thing a commenter asks back is “Why are you moving? Billing surprises?”

Google’s answers that query with Supabase, and its stated reason is the bundle he just ruled out: “Unlike Neon’s pure database focus, Supabase provides an entire backend ecosystem out of the box.”

Supabase CAN do this job: its Large instance is a dedicated 2-core with 8 GB, automated backups and monitoring. What it also carries is a $25/month platform fee for the auth, storage and realtime he has just said are already separate parts of his stack. That is the real shape of this decision. Most of the field will run his database perfectly well and charge him for a bundle he does not want.

We built Selfhost.dev to solve that: managed Postgres, no bundle, at $79.19 a month for the database above. That is $57.31 below Supabase and $70.81 below Crunchy Bridge.

No page ranking for Neon alternatives prices the same database at every vendor. That is the comparison he asked for, so that is what this is.

Every price was read in August 2026 from that vendor’s own calculator or console, in us-east-1, single node, no high availability, and always on, because always running is the requirement. Three vendors do not sell that shape at all, so both of their nearest options are quoted rather than whichever one flatters the argument. Read our own entry knowing we wrote the page, and check the $79.19 against the calculator rather than taking it from us.

Who this is not for: If you run a preview database on every pull request, or your workload genuinely idles most of the month, Neon is doing something no vendor here replaces. That case is the next section, and it is worth reading before the table.

Why are teams moving off Neon?

Three things, and only one is the sticker price. $187.64 a month is what Neon charges for the same 2 vCPU, 8 GB, 100 GB database priced throughout this page, and that figure appears nowhere on their official page. The other two are storage at $0.35 per GB-month, the highest rate here, and scale to zero, which an always-on workload pays for and never collects.

1. You cannot price your own database

Every other vendor here lets you pick a 2 vCPU, 8 GB machine from a list and shows you what it costs. Neon does not. Its spend widget offers preset scenarios rather than inputs, and the compute size cannot be changed. To find what Neon charges for that database, you have to work it out from their published rates:

And the presets Neon does show are quoted on a short month. Its “medium load, 10 GB” scenario reads $80 on Launch and $163 on Scale. Both back out to one compute unit running 720 hours, which is 30 days, while a calendar month averages 730. The real figures are $80.88 and $165.56.

2. Storage costs three times the rest of the field

Neon charges $0.35 per GB-month, the highest rate of any managed Postgres provider we priced.

Storage is the one cost that only ever grows.

3. Scale to zero only pays if you actually idle

Neon shuts the database down when nothing is using it, which is why an idle project costs almost nothing. The cost is that the next query waits for it to start again. Teams that cannot afford that wait either switch the feature off or send keep-alive traffic to stop it sleeping. Either way, they are back to paying for a database that runs all the time.

On the free tier, it is a stop rather than a delay. Three monthly limits apply: 100 CU-hours of compute, 0.5 GB of storage, 5 GB of egress. Hit any one and Neon suspends compute until the next billing month. It does not throttle you, and it does not bill you for the overage. It stops.

None of which applies to the workload in that Reddit post. A database that runs continuously never idles into the saving, so it pays usage-based rates for a benefit it cannot collect. That is the case Selfhost.dev is priced for: a fixed hourly rate drawn from a prepaid wallet, $79.19 a month for the 2 vCPU, 8 GB database above, whether traffic spikes or not.

Full rate card in our Neon pricing teardown.

Neon’s bill moves with your compute hours, so the figure you plan around is not the figure that arrives. Pick a region and a size on the Selfhost.dev calculator and it returns your exact number, no signup, no card.
Your exact monthly cost, in 30 seconds

When is Neon still the right choice?

Four things, and each is a reason to stay if it describes your workload: branching, scale to zero, a free tier that never expires, and SOC 2 with HIPAA on the Scale plan. If your database idles most of the day, or you open a preview environment on every pull request, Neon is doing something no vendor on this page replaces.

1. Branching, if you open a database per pull request

Neon clones a database in seconds without copying the data, and every Vercel preview deployment can get its own.

Nothing here is equivalent. Forking, which several vendors offer, including ours, copies the volume and takes minutes.

2. Scale to zero, if your workload genuinely idles

Neon bills almost nothing for idle hours. Ours is a manual pause.

A workload that runs four hours a day is genuinely cheaper on Neon than on any fixed tier here.

3. A free tier that never expires

0.5 GB, 100 CU-hours a month, three read replicas, no card.

No one else on this page matches that. Render’s free Postgres deletes itself after 30 days, and PlanetScale killed its free tier in April 2024. Aiven’s free tier does not expire either, though it powers off when unused and waits for a human to restart it. That is the pattern across the whole free field: every one of the six free Postgres tiers has its own stopping mechanism, and the mechanism decides whether a tier is usable far more than the storage number does.

4. Certification, if you need SOC 2 or HIPAA

The Scale plan carries SOC 2, ISO 27001, GDPR, HIPAA, and a 99.95% SLA, though that SLA covers compute endpoint availability rather than the whole platform.

Multi-AZ high availability, read replicas, and pooling to 10,000 connections are included on every plan. Only point-in-time restore costs extra, at $0.20 per GB-month.

The nine Neon alternatives, compared on cost to run

Ranked on what it costs to run the same database, not on feature count. That criterion is deliberate: features are easy to compare, and every page on this subject already does it, while a monthly total at a fixed configuration is the number that decides the migration and the number nobody publishes.

Two of the nine do not sell that shape, so both of their nearest options are quoted rather than whichever one suits us.

In cost order, that is: Selfhost.dev $79.19, Render $130.00, Supabase $136.50, Railway $137.50, AWS RDS $145.82, Crunchy Bridge $150.00, Aiven $195.00. Neon itself is $187.64 at the same 8 GB and 100 GB. PlanetScale and DigitalOcean sell Postgres in different units, so both of their nearest options are in the table above.

The nine fall into four groups, and which group you belong in matters more than which row is cheapest.

Which Neon alternatives charge one fixed price a month?

These three sell a database the way a landlord sells a flat: one number a month, and it does not move with how much you use it. If the meter is what you are leaving, this is your group, and the only question left is price level.

1. Selfhost.dev

Best for: Selfhost.dev suits a Postgres database that runs continuously, at $79.19/mo for t4g.large with 100 GB of gp3 in us-east-1: compute $66.23 at $0.0907/hr, storage $12.96, plus about $5 for an IPv4 address outside that total. It also sells Projects, Git-connected application servers billed the same way, from $14/mo in the EU for 2 vCPU, 4 GB and 40 GB, so the app and the database can both run on Selfhost.dev rather than on two vendors.

Key difference: Compute is a fixed hourly rate drawn from a prepaid wallet, so the line that swings on Neon does not swing here. Pooling, point-in-time recovery, backups, and Multi-AZ come with the database instead of as add-ons, and bring-your-own-cloud into your own AWS account is self-serve rather than sales-gated. The head-to-head against Neon has the full grid.

Two things Neon cannot do. Its bill moves with your compute hours, and the database runs on Neon’s hardware. Selfhost.dev is $79.19 a month fixed, drawn from a prepaid wallet that pauses at zero instead of billing you the overage, and the same database can run inside your own AWS account, self-serve, with no sales call. Same 2 vCPU, 8 GB, and 100 GB. $108.45 less than Neon, every month.

→ Start a Postgres whose bill cannot surprise you, no card

2. Render

Best for: Render suits shipping the app and the database from one Git push, at $130.00/mo for 2c-8g plus 100 GB at $0.30/GB. A workspace plan sits on top: Hobby free, Pro $25/mo, Scale $499/mo.

Key difference: Where Neon meters compute by the hour, Render prices a fixed instance per second and stops billing a stopped service. Paid Postgres carries point-in-time recovery on a 3 or 7 day window, plus read replicas and high availability, so this is a real managed database rather than a container with Postgres inside it.

The catch is the plan ladder rather than the database: autoscaling and full-stack previews need Pro, audit logs and SAML need Scale at $499/mo. And what Render calls a free Postgres is not a free tier in the usual sense.

It expires after 30 days and is then deleted after a 14-day grace period, which is not something their pricing page leads with. The line that separates Render from Selfhost.dev is storage: $0.30 per GB-month against $0.108 in us-east-1, close to three times, on the one cost that only ever grows.

3. Crunchy Bridge

Best for: Crunchy Bridge suits teams that want only Postgres, from people who work on Postgres. $150.00/mo for Standard-8, which is 2 cores and 8 GB at $140, plus 100 GB at $0.10. Hobby starts at $9/mo with no pooling, no high availability, and no SLA, so Standard is the real entry point.

Key difference: Egress. Crunchy charges $0/GB where Selfhost.dev charges $0.15, and Crunchy is the only managed Postgres provider in this comparison that does not meter data out at all. On a read-heavy API that gap outruns the difference in tier price.

Among Neon alternatives, Crunchy Bridge and Selfhost.dev give the most predictable bill for an always-running Postgres database. Both charge a fixed tier plus a flat rate per GB, so neither moves with traffic. The difference is what that predictability costs: $150.00 against $79.19 for the same 2 vCPU, 8 GB and 100 GB.

Which platforms include Postgres with the app?

Supabase and Railway are not database companies. Each sells a platform, and the Postgres comes as part of it. That is worth paying for if you want the rest of the platform, and it is money you do not need if you already have those pieces.

1. Supabase

Best for: Supabase suits teams that will use the whole backend bundle, not teams that need Postgres and inherit the rest. $136.50/mo: $25 Pro, a Large 2-core instance with 8 GB at $110 less the $10 compute credit, and 92 GB of billable disk at $0.125. The $25 is per organisation, so production and staging together is $35.

Key difference: Supabase ships auth, object storage, realtime, and edge functions alongside the database, with generated REST and GraphQL APIs on top. That used to be the entire reason to pick it over Neon. Then Neon shipped auth, object storage, functions, and a PostgREST-compatible Data API in July 2026, all in beta, so realtime is now the only piece Supabase has that Neon does not. Selfhost.dev is $57.31 a month cheaper at the same 2 vCPU and 8 GB. It also includes point-in-time recovery, which Supabase sells as a $100-a-month add-on for every 7 days of retention. Our Supabase comparison has the grid.

Not on their pricing page: a Supabase branch starts with no data in it. Their own docs say new branches “do not start with any data or storage objects from your main project”, so what you get is your schema on an empty database, not Neon’s clone of your actual data. It runs $0.01344 an hour on the default Micro compute, on Pro and above.

2. Railway

Best for: Railway suits full-stack apps that idle, where an app that sleeps most of the day costs very little. At the size priced here it works out to $137.50/mo: 2 vCPU at $40.58, 8 GB at $81.15, and a 100 GB volume at $15.77, with Pro at $20/mo required, and the plan fee acting as the usage credit rather than an addition to it.

Key difference: Railway bills per second for what a container actually consumes, rather than for a machine you reserved. Its scale to zero is genuine rather than a manual pause, and egress is $0.05/GB against Selfhost.dev’s $0.15. Selfhost.dev is a fixed $79.19 at the same size against Railway’s metered $137.50, and high availability comes with the database rather than being assembled from Patroni, etcd, and HAProxy by following a guide, which is what Railway’s docs ask of you. Our Railway comparison covers the rest.

What the pricing page does not say is that $137.50 is an estimate rather than a price. Railway bills measured usage at $20 per vCPU-month and $10 per GB-month, with no way to reserve a spec, and its own documentation calls the Postgres template unmanaged: “you have total control over their configuration and maintenance.”

What does AWS RDS actually charge for?

Best for: AWS RDS suits teams whose application already lives in AWS, or who need the PCI and FedRAMP certification no smaller vendor holds. $145.82/mo for db.t4g.large at $0.184/hr plus 100 GB of gp3 at $11.50, read from the AWS calculator, single-AZ, on demand.

Key difference: That $145.82 buys a bare database. Every operational feature is charged on top of it. Turning on Multi-AZ doubles the instance cost, each read replica adds another instance, RDS Proxy for connection pooling starts near $21.90/mo, and Enhanced Monitoring bills again. Our AWS RDS comparison prices those add-ons line by line, and the full RDS cost breakdown works through what they do to a real bill.

The figure AWS will never put on one page: at the identical instance class, Selfhost.dev is $79.19 against $145.82, which is 45.7% lower overall and 50.7% lower on compute alone, with pooling, backups, and point-in-time recovery already in the price. A one-year Reserved Instance commitment narrows that gap on the compute side.

Which providers sell Postgres in different units?

This is where the comparison stops being tidy, because the market does not agree on what a database is sold as. Aiven sells a bundle with the storage fixed. PlanetScale sells a ratio of CPU to memory. DigitalOcean sells fixed nodes off a ladder. None of that is wrong, and it is not a yardstick they failed. 2 vCPU with 8 GB and 100 GB is simply the shape five other vendors happen to sell identically, which is why we used it. Our own memory-optimised line has the same 8 GB-per-vCPU constraint PlanetScale does.

What it does mean is that you cannot line these three up against the others without choosing a bracket for them, and whichever bracket you choose flatters somebody. So both are published for each.

1. Aiven

Best for: Aiven suits teams needing Postgres plus a streaming or search engine from a single vendor. Its closest option is $195.00/mo: Startup-8 at 2 CPU and 8 GB on AWS us-east-1, bundling 175 GB, so it carries 75 GB more disk than every other figure here, and no 100 GB option exists.

Key difference: The rate bundles the VM, network, backups, and migration support into one hourly number, and that Startup tier carries a 99.99% SLA, the strongest uptime commitment of any Neon alternative here. The cheap tiers do not qualify. Aiven’s own documentation calls the $5 Developer plan non-production, and it cannot choose AWS at all. Priced at the 175 GB Aiven actually sells, Selfhost.dev is $87.29 against $195.00, or 55.2% lower, and bring-your-own-cloud is self-serve rather than a sales call and a commitment deal.

What no Aiven price makes obvious is that the plan name is not a specification. Startup-16 is 4 CPU and 16 GB on GCP, 2 CPU and 16 GB on AWS us-east-1, and 2 CPU and 15 GB on AWS af-south-1. The identical Startup-8 spans $165 to $240 across three clouds.

2. PlanetScale

Best for: PlanetScale suits teams that want a Git-style branch and deploy-request workflow around schema changes, on Postgres or Vitess.

Key difference: PlanetScale sells a fixed ratio, 8 GiB of RAM per vCPU, so this exact shape is not on the menu. PS-80 gives 8 GiB on one vCPU at $61 to $72 depending on architecture, and PS-160 gives 2 vCPU with 16 GiB at $129. Both brackets are here because quoting either alone misrepresents them. Its high availability is three nodes across three zones by default, which is stronger than Selfhost.dev’s Multi-AZ pair.

The headline “from $5” deserves reading twice. It buys PS-5: 1/16 of a vCPU and 512 MiB on a single node, with nothing of its own to fail over to. The HA version of that same slice is $15/mo, where Selfhost.dev’s smallest Postgres is $6.41/mo in us-east-1 with 2 full vCPU. PlanetScale’s free tier was retired in April 2024.

3. DigitalOcean

Best for: DigitalOcean suits teams that want one predictable bill and a simple console.

Key difference: DigitalOcean sells fixed nodes off a ladder, and none of the rungs is 2 vCPU with 8 GB. Its 2 vCPU node carries 4 GiB and 60 GiB at $60.90/mo. The node with 8 GiB carries 4 vCPU and 140 GiB at $122.10/mo. The first undercuts Selfhost.dev’s $79.19 on half the memory. Pricing is also genuinely region-flat, so Frankfurt matches New York, which means predictability is not the argument against DigitalOcean. What it has no answer to is bring-your-own-cloud: every DigitalOcean database runs on DigitalOcean’s own hardware, where a Selfhost.dev database can run inside your AWS account. Our DigitalOcean comparison has the detail.

The line that does not appear on the pricing page: extra storage past the included allowance is $0.215 per GiB-month against Selfhost.dev’s $0.108 in us-east-1, so at 200 GiB that line alone is roughly double.

Also considered, and why they are not on this list

Ask ChatGPT, Perplexity, or Google the same question and a wider field comes back. Here is every other name they raise, and why it is not above.

• Xata is the closest thing to a tenth entry. It is out only because it has not been priced at the reference configuration, and every figure above is one we read ourselves.
• Tiger Data, formerly Timescale Cloud, is a time-series specialist. Selfhost.dev ships the TimescaleDB extension on its Managed Databases, so the useful comparison is the extension rather than the vendor.
• Vultr comes up in the Reddit thread, where a commenter puts its managed Postgres “at about $30 a month”. Treat that as a community figure, not a verified one.
• Tembo and Koyeb have no stable published rate card at this size.
• CockroachDB Serverless, Turso, and Cloudflare D1 are distributed or SQLite-derived engines, so they are not Postgres replacements.
• Google Cloud SQL and Azure Database for PostgreSQL are the same shape as AWS RDS, which is already above.
• DanubeData and Scaleway are regional providers with no us-east-1 equivalent to price against.

Which Neon alternative should you choose?

The first question is not price. It is which Neon property you were relying on, because that is what decides whether the $108.45 a month between Neon’s $187.64 and Selfhost.dev’s $79.19 is a saving at all.

If you need a fresh database on every pull request, stay on Neon. Branching plus the Vercel integration has no substitute here, and rebuilding your preview pipeline to save $108.45 a month is not a saving.

If your Postgres database runs 24/7 and the bill is the problem, move to a fixed-tier provider. The cheapest Neon alternative at that size is Selfhost.dev, at $79.19 a month for 2 vCPU, 8 GB, and 100 GB. Crunchy Bridge at $150.00 and Render at $130.00 fix the same problem higher up the price ladder, and Crunchy adds free egress that matters on read-heavy traffic.

If a security questionnaire is blocking the deal, go to AWS RDS or Crunchy Bridge. RDS holds SOC 2, HIPAA, PCI, and FedRAMP, and Crunchy holds SOC 2 Type 2 and signs a HIPAA BAA. Both clear that review, so choose between them on the rest of the table.

If your workload genuinely idles, Railway is the cheapest Neon alternative and Neon itself the second cheapest, because every fixed-tier provider bills the full tier through the quiet hours. And if you need auth and realtime as well as Postgres, compare Supabase against Neon rather than against this list: Neon now ships four of those five in beta.

A database that runs around the clock does not need a meter. It needs a number. Selfhost.dev is $79.19 a month at the same 2 vCPU, 8 GB and 100 GB priced throughout this page, drawn from a prepaid wallet that pauses at zero rather than billing you the overage.

→ Price your own configuration, no account · or start a live database on $5 of credit, no card

How hard is it to migrate off Neon?

Not very. Neon exports as a standard Postgres database, so this is an ordinary dump and restore rather than a proprietary export, and moving a 50 GB database out costs about $4.50 in egress on the free tier. The difficulty is not the transfer. It is three specific things that break it, and each has a one-line fix.

Three things that break it

• Do not run pg_dump over the pooled connection string. Use the unpooled one.
• Match the client version of pg_dump and pg_restore to the project’s Postgres version.
• For logical replication, the destination tables must already exist with the same names and columns, so dump the schema first.

Which export method to use

pg_dump produces a custom-format dump any Postgres toolchain reads. For a low-downtime cutover, use logical replication. For a large database where downtime is acceptable, pgcopydb is fastest. Under 10 GB, Neon’s Import Data Assistant handles it.

What leaving costs

Egress is $0.10/GB above the 500 GB per-project allowance on Launch and Scale, so a move of that size costs nothing on either plan. On Free, only 5 GB is included, which is where the $4.50 for a 50 GB database comes from.

What it looks like on our side

The documented path is four steps: match the instance, replicate or dump and restore, test the restore, cut over. We publish no downtime window because it depends on your data size and your replication choice rather than on us.

A dump and restore is not the hard part. Being the person who runs it on production, once, with the site down for a window nobody can quote you, is. A Selfhost.dev engineer plans the move, tests the restore before the cutover, and runs it with you. No charge, on any plan size.

→ Hand the cutover to an engineer, at no charge

The decision

If your Postgres runs around the clock, the answer is Selfhost.dev at $79.19 a month, which is $108.45 less than Neon for the same 2 vCPU, 8 GB, and 100 GB. Pooling, point-in-time recovery, backups, and Multi-AZ sit inside that price, where Supabase sells recovery as a $100-a-month add-on and AWS charges from $21.90 for pooling alone.

If a security review needs a SOC 2 report, choose AWS RDS or Crunchy Bridge. Both clear it, and neither is a compromise on the database itself.

If you need a fresh database on every pull request, stay on Neon. Branching has no substitute on this page, and no monthly saving justifies rebuilding a preview pipeline.

And if your workload genuinely idles, stay on Neon. Every fixed tier here bills through the quiet hours. A meter does not.

That is the whole decision. Everything else on this page is detail.

Nobody leaves Neon over the database. They leave over not knowing what it will cost. Selfhost.dev is a fixed hourly rate drawn from a prepaid wallet, so the number you see before you start is the number that arrives, and when the wallet reaches zero, the server pauses instead of billing you for the overage. A live Postgres takes under two minutes, on $5 of free credit, with no card to enter and nothing to cancel.

→ Start the database whose price you already know

Frequently Asked Questions