Introduction
Neon started as serverless Postgres with database branching. In 2026 it sells a wider backend: managed auth, S3-compatible object storage, functions and an AI Gateway, all sitting next to the Postgres core. Neon is now part of the Databricks platform, where the database runs under the Lakebase name.
This review is based on Neon's pricing page, its documentation and the small amount of independent evidence available. scored.tools did not run Neon hands-on. Neon scores 7.4 out of 10 overall. The breakdown sits below, and it is uneven: high marks for ease of use, pricing and integrations, and middling marks where independent proof is thin.
| Criterion | Score | Basis |
|---|---|---|
| Ease of use | 9 | Free plan with no time limit and no card; docs list one-command setup and a full backend quickstart |
| Pricing value | 8 | 100 free projects; Launch plan at $0.106 per CU-hour, which Neon says typically comes to about $15/month |
| API and integration | 8 | MCP, CLI and SDK access, eight languages, Prisma, Drizzle and SQLAlchemy support, pg_dump and pgcopydb import |
| Output quality | 6 | Only independent data is 4 G2 reviews averaging 4.8, too small a sample to score higher |
| Problem fit | 6 | Vendor claims are strong; one low-confidence independent note (rfp.wiki) flags cold-start latency from suspended computes |
Key Features
Serverless Postgres with autoscaling
Neon separates storage from compute, so compute can grow, shrink and suspend on its own. Per the pricing page, Free autoscales up to 2 CU (8 GB RAM), while Launch and Scale go up to 16 CU (64 GB RAM). Scale also offers fixed sizes up to 56 CU (224 GB RAM). A suspended compute costs nothing, which is the main reason Neon suits side projects and bursty traffic.
Scale-to-zero has a cost too. On Free, compute suspends after 5 minutes and you cannot turn that off. On Launch you can disable it, and on Scale you can set it anywhere from 1 minute to always on. If your app wakes a cold database on the first request, expect some delay on that request. The rfp.wiki note above flags exactly this, so test it against your latency budget.
Branching
Branching is the feature most teams pick Neon for. A branch is a copy of the database you can use for a preview deploy, a migration test or a CI run, without dumping and restoring by hand. Free and Launch allow 10 branches per project and Scale allows 25. Extra branches on paid plans cost $1.50 per branch-month. Free does not allow extras, and hitting 10 blocks new branch creation.
Instant restore and snapshots
Neon lets you roll a database back to an earlier point after a bad migration or a stray DELETE. The history window is 6 hours (capped at 1 GB) on Free, up to 7 days on Launch and up to 30 days on Scale. On paid plans, instant restore is billed at $0.20 per GB-month. Free gets 1 manual snapshot; paid plans get 100, with scheduled snapshots at $0.09 per GB-month.
Auth, object storage and functions
The newer pieces turn Neon into a fuller backend. Auth is built on Better Auth, per the homepage, and the pricing page lists up to 60k monthly active users on Free and up to 1M on paid plans. Object storage is S3-compatible and branches along with the database, so a preview branch gets its own files. Free includes 5 GB per project; paid plans charge $0.023 per GB-month. Functions are billed by capacity-hours and invocations, with 1M invocations included on Free and $0.60 per million after that on paid plans.
AI Gateway and search
Neon lists an AI Gateway that puts frontier and open-source models behind one API. The database side supports vector, keyword and hybrid search, which covers retrieval for most RAG apps without a separate vector store. The tool data notes Neon is widely used as a backend for app-building agents, and the MCP server and CLI in the docs fit that use.
Pricing Breakdown
Neon has three plans. Paid plans are metered hourly and billed monthly, with no monthly minimum, and Neon does not collect invoices under $0.50.
| Free | Launch | Scale | |
|---|---|---|---|
| Price | $0 | Usage-based | Usage-based |
| Projects | 100 | 100 | 1,000 (more on request) |
| Compute | 100 CU-hours per project | $0.106 per CU-hour | $0.222 per CU-hour |
| Storage | 1 GB per project, 20 GB account total | $0.35 per GB-month | $0.35 per GB-month |
| Restore window | 6 hours | Up to 7 days | Up to 30 days |
| Public egress | 5 GB per project | 500 GB per project, then $0.10/GB | 500 GB per project, then $0.10/GB |
| Monitoring retention | 1 day | 3 days | 14 days |
| Support | Community | Billing support | Standard, Business or Production tiers |
The Free plan is generous on project count and tight on size. Run out of CU-hours or egress and compute suspends until the next billing period. Pass 1 GB in a project or 20 GB in total and writes are blocked. Neon says no data is deleted and upgrading lifts the limits at once, which is the right way to handle it.
Scale costs about twice as much per CU-hour as Launch. You pay that for features gated to Scale only: IP allow rules, private networking, metrics and log export, and an uptime SLA. Any team with a compliance checklist will likely end up on Scale.
Usage pricing is the main budgeting risk. A fixed instance gives you one number per month. With Neon, the bill moves with compute hours, storage, restore history, branches and egress. Set up spend alerts and model your expected CU-hours before you move production traffic.
Pros and Cons
Pros
- Branching gives every preview deploy or test run its own database copy with no manual clone.
- Free plan covers 100 projects at 1 GB each, with no time limit and no credit card.
- Scale-to-zero means idle databases cost nothing in compute.
- It is standard Postgres, so existing ORMs, pg_dump and migration tools work.
- Auth, object storage, functions and the AI Gateway can replace several separate vendors.
- MCP, CLI and SDK access in eight languages make it easy to wire into agent and CI workflows.
Cons
- Functions, object storage and the AI Gateway are newer and have less track record than the Postgres core.
- Databricks ownership may shape the roadmap and pricing in ways users cannot predict.
- Usage-based billing is harder to forecast than a fixed-price instance.
- 1 GB per project on Free is small for anything past a prototype.
- Cold starts from suspended compute can add latency, and Free cannot disable scale-to-zero.
- SLA, private networking and IP allow rules are locked to the pricier Scale plan.
- Independent reviews are scarce: four on G2 at time of writing.
Who Is It For
Neon fits developers and small teams who want Postgres without running servers, and who will use branching. If your workflow already spins up preview environments per pull request, branching maps onto it directly. It also fits builders running many small apps, or agents that create databases on demand, since 100 free projects and scale-to-zero keep idle costs near zero.
It is a weaker fit for steady, high-traffic workloads where a database runs flat out all month. There a fixed instance may cost less and be easier to budget. Teams that need an SLA from day one should price the Scale plan, not Launch.
If you mainly want a bundled backend, compare it with Supabase, which has offered Postgres plus auth and storage for longer. If you are choosing on branching and scale, PlanetScale is the other name to check.
Verdict
Neon earns its 7.4. The Postgres core, branching and free tier are strong, and the docs make setup easy. The two 6s reflect missing independent evidence rather than known failures, but they are a reason to run your own load and cold-start tests before you commit.
Recommendation: use Neon for new projects, preview environments and agent-built apps, starting on Free and moving to Launch when you outgrow 1 GB. Treat auth, storage, functions and the AI Gateway as useful extras rather than the reason to choose it, at least until they have a longer track record. For production, check the current pricing page against your expected CU-hours, and budget for Scale if you need an SLA.
