What are some good options for a serverless backend with a SQL database?

When building a serverless backend with a SQL database, the modern ecosystem leans toward databases that separate compute from storage , scale down to zero when idle, and provide HTTP/edge-friendly drivers so you don't exhaust connection pools from serverless functions (like AWS Lambda or Vercel/Netlify functions).daily.dev

The top options span managed Postgres/MySQL engines, specialized edge SQL databases, and full backend-as-a-service (BaaS) platforms.daily.dev+1

1. Dedicated Serverless SQL Databases

• Neon : A fully managed serverless PostgreSQL database that decouples storage and compute, allowing it to scale to zero. It features incredible developer-experience tools like database branching (instant copy-on-write branches for staging/preview environments tied to Git PRs).daily.dev
• PlanetScale : A serverless platform powered by MySQL (built on Vitess). It excels at horizontal scaling, handling massive traffic spikes, and offering unique features like zero-downtime schema migrations through a branching workflow reminiscent of GitHub.daily.dev
• Turso : Built on libSQL (an open-contribution fork of SQLite), Turso is designed for the edge. It replicates your SQLite database globally to locations close to your users, making read latencies remarkably low. It pairs exceptionally well with edge functions.daily.dev+1
• Cloudflare D1 : Cloudflare's native serverless SQLite database. If your compute already lives on Cloudflare Workers, D1 lets you query a relational database instantly without configuring external connections or worrying about regional latency.devopsness.com

2. Cloud-Native & Enterprise Serverless SQL

• Amazon Aurora Serverless v2 : If you are already deeply embedded in the AWS ecosystem (Lambda, API Gateway), Aurora Serverless v2 automatically scales database compute capacity up and down instantly based on application load. It doesn't scale to zero (it maintains a tiny baseline capacity), but it offers enterprise-grade PostgreSQL and MySQL compatibility with high availability.devopsness.com

3. Complete Backend-as-a-Service (BaaS)

• Supabase : An open-source Firebase alternative built entirely on top of PostgreSQL . It gives you a real-time serverless Postgres database, auto-generated instant APIs, built-in authentication, edge functions, and file storage. You get direct SQL access alongside a ready-to-use backend layer.daily.dev

Community Perspectives

Developers frequently weigh the choice between maintaining a raw connection to a serverless Postgres/MySQL versus using an edge-optimized SQLite solution:

I found Neon to be a lifesaver for standard Postgres needs because the branching feature works just like Git branches for your database schema.

For pure edge speed with zero configuration in serverless functions, using Turso or Cloudflare D1 with SQLite feels lightning fast compared to traditional connection pooling.

If you'd like to narrow this down, let me know:

• Where your serverless compute is hosted (e.g., AWS Lambda, Cloudflare Workers, Vercel)
• Your preferred SQL flavor (Postgres, MySQL, or SQLite)
• Whether you need built-in auth/storage or just a database

I can help you pick the best pairing for your stack.

If you want a serverless backend with a relational SQL database, there are several good choices. The main distinction is whether you want PostgreSQL/MySQL compatibility or an edge-oriented SQLite database.

1. Neon

Neon is probably the most straightforward choice if you specifically want serverless PostgreSQL. It separates compute from storage and supports compute scaling to zero, branching, and serverless/HTTP database connections.Layerbase+1

I'd consider it when: you're building an API with Next.js, Vercel, Cloudflare, AWS Lambda, etc., and want essentially normal PostgreSQL without managing a database server.

2. Supabase

Supabase gives you PostgreSQL plus authentication, storage, realtime features, APIs, and server-side functions. Its database can be accessed from serverless functions through pooling or its API layer.Supabase

I'd consider it when: you want something closer to "Firebase, but PostgreSQL-based."

3. Cloudflare D1

Cloudflare D1 is a managed serverless SQLite database designed specifically for Cloudflare Workers. It integrates directly with Workers and supports read replication and point-in-time restoration.Cloudflare Docs+1

I'd consider it when: your backend is already running on Cloudflare Workers and you don't need PostgreSQL-specific functionality.

One important distinction: D1 is SQLite, not PostgreSQL, so migration/ORM compatibility is different.

4. PlanetScale

PlanetScale supports both MySQL- and PostgreSQL-compatible offerings and is particularly interesting if you value database branching and schema-management workflows. Cloudflare also supports connecting to PlanetScale from Workers.Cloudflare Docs

I'd consider it when: you're coming from MySQL or want a database workflow built around branching/deploying schema changes.

5. AWS Aurora Serverless

If you're already heavily invested in AWS, Aurora Serverless is worth considering. It provides managed PostgreSQL/MySQL-compatible databases with automatic capacity adjustment, although its serverless model isn't identical to a database that completely scales to zero.Layerbase

I'd consider it when: the rest of your infrastructure is Lambda + API Gateway + S3 + SQS + VPC/etc. and you want the database inside that ecosystem.

What I'd narrow it down to

• Normal web app + PostgreSQL: Neon
• Postgres + auth/storage/realtime: Supabase
• Cloudflare Workers: D1
• AWS-centric application: Aurora Serverless
• MySQL ecosystem: PlanetScale
• Edge/local-first SQLite: Turso

If you tell me your frontend/backend framework (e.g. Next.js, Python/FastAPI, Go, Cloudflare Workers), expected traffic, and whether you need auth, I can narrow this to 2–3 architectures and show what the actual stack would look like.

If you want a serverless backend with a relational SQL database, there are several strong choices. The main distinction is whether you want “database + functions” or a more complete Backend-as-a-Service (BaaS).

My practical shortlist

• Supabase — probably the easiest choice if you want a whole backend. You get managed PostgreSQL along with authentication, file storage, realtime functionality, APIs, and serverless/edge functions.Supabase
• Neon — excellent if you primarily want Postgres and intend to put your application logic in something like Next.js/Vercel, Cloudflare, or another serverless runtime. Cloudflare specifically lists Neon among the PostgreSQL-compatible serverless databases it supports.Cloudflare Docs
• Cloudflare D1 — particularly attractive if you're already using Cloudflare Workers. D1 is SQLite-based, integrates directly with Workers, and supports global read replication.Cloudflare+1
• Serverless — the option I'd investigate when you're already deep into AWS or need a more traditional enterprise relational database. It supports both PostgreSQL- and MySQL-compatible editions and automatically adjusts capacity.

What I'd choose

For a new SaaS/web application, I'd generally narrow it to:

Supabase → if you want authentication, storage, realtime, database, and backend functions bundled together.

Neon + your preferred serverless runtime → if you want a clean separation between your application/backend and PostgreSQL.

Cloudflare Workers + D1 → if edge execution and global distribution are central to the architecture.

One important consideration is PostgreSQL vs. SQLite. If you expect sophisticated relational queries, extensions, or want maximum compatibility with the broader SQL/Postgres ecosystem, I'd lean toward Postgres (Supabase/Neon/Aurora). D1 is SQLite-based and is particularly compelling for applications designed around the Cloudflare ecosystem.Cloudflare Docs+1

If you tell me your stack (e.g. Next.js, React, Python, Go, mobile) and approximate scale, I can narrow these down to 2–3 architectures and show what the actual backend would look like.

Yes. If by serverless backend + SQL you mean “I want to deploy API/backend code without managing servers, and I want a relational SQL database,” these are the options I’d consider first:

1. Neon + Vercel/other serverless functions

Neon gives you essentially managed, serverless PostgreSQL. It supports scale-to-zero and database branching, which is particularly nice for preview deployments and development environments.Tech Bytes+1

A typical stack would be:

Next.js → Vercel Functions → Neon Postgres → Drizzle/Prisma

I'd pick this if you want “normal PostgreSQL, but without running a database server.”

2. Supabase

Supabase is more than a database: you get PostgreSQL plus authentication, storage, realtime functionality, APIs, and server-side/edge functions.Tech Bytes+1

Typical architecture:

Frontend → Supabase → Postgres

This is probably the easiest choice if you're building an app and don't want to assemble authentication, database APIs, file storage, etc. yourself.

The tradeoff is that you're buying into a larger backend platform rather than just getting a database.

3. Cloudflare Workers + D1

Cloudflare D1 is SQLite-based SQL integrated directly with Cloudflare Workers. Cloudflare positions it specifically as a relational database for applications running on its edge/serverless platform.Cloudflare

Workers → D1

This is especially attractive if you're already using Cloudflare Workers and want your backend and database tightly integrated.

The major consideration is that D1 is SQLite, not PostgreSQL, so I'd choose it because SQLite fits the application—not simply because it's cheap or serverless.

4. Turso

Turso is another SQLite/libSQL option, with an emphasis on distributing databases closer to users. Its architecture is particularly interesting for read-heavy applications and applications where individual tenants/users can have isolated databases.Tech Bytes+1

I'd consider it for things like:

• globally distributed apps
• read-heavy applications
• per-user/per-tenant databases
• applications where very low edge read latency matters

It's less compelling if you specifically need the breadth of the PostgreSQL ecosystem.

5. AWS Lambda + Aurora Serverless

If you're already deeply invested in AWS, Lambda + Aurora Serverless is the more enterprise-oriented answer.

You get conventional PostgreSQL or MySQL with AWS's huge ecosystem around it. The downside is that AWS gives you considerably more infrastructure to understand and configure than something like Neon or Supabase.

I'd choose it when AWS integration, networking, IAM, compliance, or enterprise infrastructure matters more than simplicity.

What I'd choose

For a new project, my default decision tree would be:

• Want PostgreSQL? → Neon
• Want PostgreSQL + auth + storage + realtime + APIs? → Supabase
• Already building on Cloudflare Workers? → D1
• Need SQLite at the edge / unusual per-tenant architecture? → Turso
• Already an AWS shop or have serious enterprise infrastructure requirements? → Aurora Serverless
• Specifically need MySQL/Vitess? → PlanetScale

For most new SaaS/web applications, I'd start with Neon + a serverless runtime + Drizzle. PostgreSQL gives you a very capable relational foundation, while Neon avoids most of the connection-management and server provisioning headaches associated with traditional Postgres in serverless environments.BuildPilot+1

If you tell me your stack (e.g. Next.js, Python/FastAPI, Go, Cloudflare Workers, AWS Lambda) and whether you're building an MVP, SaaS, or high-traffic app, I can narrow this down to 2–3 choices.

Building a serverless backend with a SQL database typically involves pairing a serverless compute layer (like AWS Lambda, Cloudflare Workers, or Vercel Functions) with a modern serverless SQL database that handles scaling, connection pooling, and pay-per-use compute.

Top options are categorized below by their ecosystem and architecture:

1. Developer-First & Specialized Serverless SQL

• Neon (Serverless PostgreSQL): Separates storage and compute completely, allowing it to scale down to zero when idle. It stands out for features like database branching (instant copy-on-write clones for staging and preview deployments).daily.dev+1
• Supabase (Open-Source Firebase Alternative): Built on top of PostgreSQL, Supabase gives you a complete backend stack including auto-generated APIs, real-time listeners, built-in authentication, and file storage alongside your SQL database.daily.dev+1
• Turso (Edge SQLite): Built on libSQL, Turso replicates your SQLite database to locations globally at the edge. It's exceptionally fast and cost-effective if you want ultra-low latency reads close to serverless functions or edge workers (like Cloudflare Workers).devopsness.com
• PlanetScale (Serverless MySQL): Powered by Vitess, it offers massive horizontal scalability and zero-downtime schema changes. Note that while it scales query traffic seamlessly, its compute tiers are typically always-on rather than scaling entirely to zero.daily.dev+2

2. Hyperscaler Enterprise Serverless SQL

• Amazon Aurora Serverless (AWS): Automatically scales compute capacity up and down based on application load. Recent iterations can scale all the way down to zero when inactive, making it a robust, enterprise-grade choice if your stack lives natively in AWS.founden.ai+2
• CockroachDB Serverless (Distributed SQL): A distributed, PostgreSQL-compatible SQL database designed for high availability and multi-region resilience. It automatically distributes data and scales compute up and down cleanly.dbvis.com+2
• Serverless (Azure): Automatically pauses compute during inactive periods (billing only for storage) and auto-resumes compute when activity returns, tailored specifically for unpredictable workloads on Azure.

Community Perspectives

If u want serverless Postgres, Neon is the obvious one to compare. Turso can work if SQLite/libSQL fits your use case, and PlanetScale is another option to look at.

To help narrow down the best fit, tell me:

• Which cloud provider or hosting platform (e.g., AWS, Vercel, Cloudflare) are you using for your compute?
• Do you have a preferred SQL flavor (PostgreSQL, MySQL, SQLite)?

If you want serverless compute + a relational SQL database, there are several very good choices. The right one mostly depends on whether you want Postgres compatibility, edge deployment, or an all-in-one backend.

My top picks

• Supabase — Probably the easiest overall. You get managed PostgreSQL plus authentication, storage, APIs, realtime functionality, and serverless/edge functions. Supabase explicitly supports connecting to Postgres from serverless functions.Supabase
• Neon — Excellent if you specifically want Postgres and are building with Next.js/TypeScript. It is particularly attractive when paired with Vercel.
• Cloudflare Workers + D1 — Great if you want everything at the edge. D1 is Cloudflare's managed serverless SQL database and uses SQLite semantics; Workers can access it directly through bindings. Cloudflare Docs Cloudflare Docs D1 also supports read replication and point-in-time recovery.Cloudflare Docs

What I'd choose

For a new project, I'd narrow it down to:

Want the simplest full backend: Supabase Want PostgreSQL + modern serverless deployment: Neon + Vercel Want edge-first architecture: Cloudflare Workers + D1 Want AWS/enterprise: Aurora Serverless

One important distinction: D1 is SQLite, not PostgreSQL. That makes it wonderfully simple for many applications, but if you expect to depend on PostgreSQL-specific features, I'd choose Supabase, Neon, or Aurora instead. D1 currently has a 10 GB maximum database size on paid Workers plans.Cloudflare Docs

If you tell me your frontend/framework (Next.js, React, Python, etc.), expected scale, and whether you need auth, I can recommend one architecture and stack rather than giving you a menu.