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

Finding a serverless backend with a SQL database usually comes down to pairing a serverless compute layer (like AWS Lambda, Cloudflare Workers, or Vercel) with a modern serverless SQL database that separates compute from storage and supports scaling down to zero.

Top options span specialized modern serverless databases and fully integrated backend platforms:

Dedicated Serverless SQL Databases

• Neon : A fully managed, serverless PostgreSQL database that separates compute from storage. It auto-scales up with traffic and scales to zero when idle, making it a favorite for standard Postgres compatibility without managing connection limits.
• PlanetScale : A serverless MySQL-compatible database built on Vitess. It brings horizontal sharding capabilities, robust branching workflows (like Git for your database), and smooth scaling for high-traffic applications.
• Turso : A distributed edge database based on SQLite. It allows your database to replicate globally to close the distance to your users, offering ultra-low latency reads paired with libSQL.
• Amazon Aurora Serverless v2 : AWS's native relational option that scales database compute instantly and granularly based on application demand, supporting both PostgreSQL and MySQL editions.

All-in-One Serverless Backends (BaaS) with SQL

• Supabase : An open-source Firebase alternative built completely on top of PostgreSQL. It gives you a serverless Postgres database alongside auto-generated APIs, authentication, real-time subscriptions, and edge functions out of the box.
• Xata : A serverless data platform that acts as a database and backend service with a rich TypeScript SDK, built-in search/vector capabilities, and PostgreSQL under the hood.

To help narrow down the best fit, tell me:

• What programming language or compute platform (e.g., Next.js, AWS Lambda, Cloudflare Workers) are you using for your backend?
• Do you have a preference for PostgreSQL, MySQL, or SQLite?

For a serverless backend with a SQL database, the best choice depends on whether you want a full backend platform, a pure database, edge deployment, or enterprise-scale infrastructure. Good options:

Cloudflare Docs## My usual recommendations by project type

Building a startup MVP

Pick:

• Supabase if you want the most features quickly: - Database
• Authentication
• File storage
• Realtime subscriptions
• APIs

Building a serious SaaS product

Pick:

• Neon + your own API layer if you want a clean architecture: - Next.js/Vercel/serverless functions
• PostgreSQL
• Prisma/Drizzle
• Separate frontend/backend concerns

Building an app on the edge

Pick:

• Cloudflare Workers + D1 if your workload fits SQLite: - Lots of reads
• Global users
• Simple relational data
• Low operations burden D1 is designed to integrate directly with Cloudflare Workers.

Enterprise / high scale

Pick:

• Aurora Serverless (AWS ecosystem)
• CockroachDB Serverless (global distributed SQL)
• Google Cloud Spanner (very large-scale systems)

A common modern stack

A lot of teams end up with something like:

• Frontend: Next.js / React
• Backend: Serverless functions (Vercel, AWS Lambda, Cloudflare Workers)
• Database: Neon or Supabase Postgres
• ORM: Drizzle or Prisma
• Auth: Supabase Auth, Auth.js, Clerk, or custom OAuth

My default shortlist

If I were starting a new project today:

1. Supabase — fastest path from idea → working product.
2. Neon Postgres — best "traditional backend" feel without managing servers.
3. Cloudflare D1 — best when you are already committed to Cloudflare's edge platform.
4. Aurora Serverless — best when you expect AWS enterprise needs.

The biggest architectural decision is usually Postgres vs SQLite-style edge databases, not the serverless compute provider. Postgres gives you a richer ecosystem; edge SQLite gives you simplicity and geographic distribution.

When building a serverless backend paired with a SQL database, the modern landscape separates compute (your API/functions) from storage (the relational database) to achieve scale-to-zero pricing and instant elasticity.

The best options vary depending on whether you want an all-in-one Backend-as-a-Service (BaaS), a dedicated serverless database to plug into serverless functions (like AWS Lambda or Vercel), or an edge-optimized SQL database.

1. All-in-One Backend-as-a-Service (BaaS)

Best if you want instant authentication, auto-generated APIs, real-time subscriptions, and a Postgres database without wiring up the boilerplate.

• Supabase
  • The Vibe: The open-source Firebase alternative powered by PostgreSQL.
  • Why it’s great: It gives you a full Postgres database alongside instant REST and GraphQL-like APIs, built-in row-level security (RLS), user authentication, and edge functions.
  • Best for: Rapid development and solo devs or small teams who want a complete backend ecosystem out of the box. Check it out on Supabase.

2. Dedicated Serverless PostgreSQL

Best if you love standard Postgres, want advanced features like database branching (like Git for your data), and just need a rock-solid connection string.

• Neon
  • The Vibe: Purpose-built serverless Postgres with true scale-to-zero and branching.
  • Why it’s great: Neon separates storage and compute completely. It lets you spin up instant database branches for pull requests/preview deployments, and it auto-scales smoothly under load.
  • Best for: Modern web apps using ORMs (like Prisma or Drizzle) deployed on platforms like Vercel or Netlify. Learn more at Neon.
• Amazon Aurora Serverless v2
  • The Vibe: AWS's enterprise-grade, auto-scaling relational database.
  • Why it’s great: Unlike basic serverless tiers that drop to zero and suffer from cold starts, Aurora Serverless v2 scales compute capacity up and down in fractions of a second based on load, maintaining high performance under heavy traffic.
  • Best for: Production applications deeply entrenched in the AWS ecosystem (Lambda, ECS, API Gateway). Explore it via AWS Aurora Serverless.

3. Edge & Distributed SQL Databases

Best for applications deployed globally at the edge (Cloudflare Workers, Deno Deploy) needing ultra-low latency reads.

• Turso
  • The Vibe: SQLite, distributed globally on the edge.
  • Why it’s great: Built on LibSQL (an open-source fork of SQLite), Turso allows your database to live close to your users anywhere in the world while remaining a true relational SQL database with very low latency.
  • Best for: Edge-heavy architectures and lightweight, high-performance APIs. Check out Turso.
• Cloudflare D1
  • The Vibe: Serverless SQLite native to the Cloudflare Workers ecosystem.
  • Why it’s great: If you are already building your serverless functions on Cloudflare Workers, D1 integrates seamlessly with zero configuration and scales across Cloudflare's massive edge network.
  • Best for: Jamstack sites and edge-native serverless functions on Cloudflare. Read more on Cloudflare D1.

If you want to narrow this down, tell me:

• What frontend/backend framework or cloud host (e.g., AWS, Vercel, Cloudflare) are you planning to use?
• Do you need built-in user authentication and file storage , or just the database?

If you want serverless compute + SQL, there are several good choices. The biggest decision is whether you want PostgreSQL or are happy with SQLite/libSQL.

My shortlist

What I'd choose

For a typical new web app: Supabase or Neon.

• Supabase is particularly nice if you want an integrated backend: Postgres, authentication, storage, realtime features, APIs, etc.
• Neon is a great choice if you want essentially "serverless Postgres" and want to keep your application architecture relatively unopinionated.

If you're using Cloudflare Workers: D1 is very compelling. It's a managed serverless SQL database with SQLite semantics and direct Workers integration. Cloudflare also supports connecting Workers to conventional Postgres/MySQL through Hyperdrive.

If you want edge-oriented SQLite: Turso is worth considering. Its serverless client uses fetch, so it works naturally in serverless and edge runtimes including Cloudflare Workers and Vercel Edge Functions.

For serious AWS-scale distributed workloads: Aurora DSQL is the more heavyweight option. It's a serverless, distributed, PostgreSQL-compatible relational database designed for high availability and automatic scaling.

A simple rule of thumb

• Need Postgres + auth/storage/etc. → Supabase
• Need clean serverless Postgres → Neon
• Already on Cloudflare → D1
• Want SQLite at the edge → Turso
• Deeply invested in AWS / huge distributed workload → Aurora DSQL

If you tell me your frontend/runtime (Next.js, Cloudflare Workers, AWS Lambda, etc.) and expected scale, I can narrow this down to the 2–3 best architectures.

• Supabase is particularly nice if you want an integrated backend: Postgres, authentication, storage, realtime features, APIs, etc.
• Neon is a great choice if you want essentially "serverless Postgres" and want to keep your application architecture relatively unopinionated.

If you're using Cloudflare Workers: D1 is very compelling. It's a managed serverless SQL database with SQLite semantics and direct Workers integration. Cloudflare also supports connecting Workers to conventional Postgres/MySQL through Hyperdrive.

If you want edge-oriented SQLite: Turso is worth considering. Its serverless client uses fetch, so it works naturally in serverless and edge runtimes including Cloudflare Workers and Vercel Edge Functions.

Yes. If by serverless backend + SQL database you mean “I don't want to manage servers, but I still want relational SQL,” there are several strong choices in 2026.

1. Neon — my default recommendation

Neon is essentially serverless PostgreSQL: compute and storage are separated, with autoscaling, database branching, and scale-to-zero capabilities.

It's particularly attractive if you're building with:

• Next.js / Vercel
• Node.js
• Python
• Drizzle or Prisma
• REST/GraphQL APIs
• SaaS applications
• AI applications needing Postgres + pgvector

Why I'd pick it: you get essentially normal PostgreSQL without having to operate a Postgres server, and database branching is excellent for development/preview environments.

2. Supabase — best if you want more than a database

Supabase gives you PostgreSQL plus authentication, APIs, storage, realtime functionality, and other backend services.

It also has a transaction-mode connection pool specifically intended for serverless and edge functions, which is important because short-lived serverless functions can otherwise create too many Postgres connections.

I'd choose Supabase if you want:

Frontend → Supabase → Postgres

rather than assembling your own backend infrastructure.

It's especially nice for prototypes, CRUD-heavy applications, dashboards, internal tools, and products that need user authentication quickly.

3. Cloudflare D1 — great for Cloudflare Workers

D1 is Cloudflare's serverless SQLite database, integrated directly with Workers. Cloudflare positions it for SQL applications running at the edge, and Workers can access it through native bindings.

I'd use D1 when your architecture is:

Cloudflare Workers + D1 + R2 + Queues

It's wonderfully simple and can be very cheap, but SQLite isn't a drop-in replacement for PostgreSQL. If you expect sophisticated Postgres features or a conventional relational backend, Neon/Supabase are safer choices.

4. PlanetScale

PlanetScale is worth considering if you have a strong preference for MySQL or want a database workflow centered around branching/development environments.

It's more compelling for a substantial application than for a tiny project where Neon or Supabase can get you running faster.

5. AWS Aurora Serverless

If you're already using AWS extensively, Aurora Serverless v2 can be a very good choice. You get managed PostgreSQL or MySQL while AWS handles capacity scaling.

The tradeoff is complexity: Aurora is considerably more "AWS infrastructure" than Neon or Supabase. I'd generally choose it when AWS integration, networking, IAM, compliance, or enterprise infrastructure is more important than simplicity.

---

What I'd choose

For a new SaaS/web application:
→ Neon + your preferred serverless compute (Vercel Functions, AWS Lambda, Cloudflare Workers, etc.)

For an app where you want the backend mostly built for you:
→ Supabase

For a Cloudflare-first application:
→ Cloudflare Workers + D1

For a serious AWS-native application:
→ Aurora Serverless v2

For globally distributed/edge-oriented lightweight applications:
→ D1 or Turso

The biggest architectural decision is actually Postgres vs. SQLite. If you don't have a specific reason to choose SQLite, I'd start with Postgres, which makes Neon my overall pick. It gives you a conventional SQL database while retaining the serverless operational model.

If you tell me your stack (e.g. Next.js + TypeScript, Python/FastAPI, Cloudflare Workers, etc.) and expected scale, I can narrow this down to 2–3 options and compare pricing, cold starts, connection handling, auth, ORM support, and vendor lock-in.

The serverless SQL ecosystem has evolved past the days of wrestling with always-on VMs and connection-pooling limits . By separating compute from storage, modern serverless SQL options let you scale down to zero when idle and auto-scale instantly under load.

The top options depend heavily on your preferred SQL flavor and architecture:

• Supabase (PostgreSQL) — Excellent if you want an all-in-one Backend-as-a-Service (BaaS). It gives you a full Postgres database per project bundled with auto-generated APIs, built-in authentication, and real-time subscriptions.
• Neon (PostgreSQL) — A purpose-built, pure serverless Postgres platform that features true scale-to-zero compute and database branching (letting you spin up instant preview branches of your database for Git/PR workflows).
• PlanetScale (MySQL) — Built on top of Vitess, it's designed for high-scale MySQL workloads. It offers Git-like schema branching and non-blocking, zero-downtime migrations, making it a favorite for production-heavy applications.
• Turso (SQLite / libSQL) — An edge-hosted, serverless SQLite database. It allows your database to replicate globally, providing ultra-low read latency by placing data physically close to your users at the edge.
• Amazon Aurora Serverless v2 (PostgreSQL / MySQL) — The go-to choice if you are already deeply embedded in the AWS Ecosystem . It scales database capacity seamlessly in fine-grained increments based on application demand.
• CockroachDB Serverless (Distributed SQL / Postgres-compatible) — Ideal for globally distributed applications that require strong multi-region consistency and high availability without managing infrastructure nodes.

Developer Perspectives

“Supabase is a standard, easy-to-use, and relatively cheap managed PostgreSQL host. Neon is a serverless option that can scale to zero and separates compute and storage, potentially leading to better performance.”

“PlanetScale is a great dashboard and uses Vitess for scalability, but it lacks a free tier and might be overkill for indie hackers.”

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

• What programming language or framework are you using for your functions?
• Do you need global edge distribution or just a single primary region?
• Are you leaning toward PostgreSQL or MySQL?

If you want a serverless backend + SQL, there are several good choices. The biggest decision is whether you want Postgres compatibility or something more tightly integrated with an edge/serverless platform.

My picks

1. Supabase — easiest overall

I'd pick this if you want authentication, database, APIs, storage, realtime features, and serverless functions without assembling everything yourself. Its database is PostgreSQL, and Supabase provides transaction-mode connection pooling specifically for serverless and edge functions.

Good for: SaaS, CRUD apps, dashboards, startups, prototypes that may become production apps.

---

2. Neon — best if you primarily want Postgres

Neon is a particularly nice choice if you want serverless PostgreSQL without adopting a whole backend platform. It provides autoscaling and database branching, and it works well with serverless runtimes.

Pair it with something like Vercel Functions, AWS Lambda, Cloudflare Workers, or your preferred backend framework.

Good for: Next.js apps, APIs, TypeScript, Prisma/Drizzle, teams that want standard Postgres.

---

3. Cloudflare Workers + D1 — best edge-native option

D1 is Cloudflare's serverless SQL database built around SQLite. It's deeply integrated with Workers, supports global read replication, and is particularly attractive for read-heavy applications distributed around the world.

The important caveat is that D1 is SQLite, not Postgres. Individual databases currently have a 10 GB maximum, so I'd choose it when that model fits the application rather than simply because it's cheap.

Good for: Edge applications, lightweight SaaS, content-heavy sites, globally distributed read-heavy apps.

---

4. Aurora DSQL — interesting for large/global systems

AWS's newer Aurora DSQL is a serverless distributed SQL database that's PostgreSQL-compatible and designed for very high availability and multi-region workloads. AWS describes it as scaling automatically without provisioning database infrastructure.

Good for: Large systems, multi-region applications, workloads where availability and global writes matter.

For a typical startup, though, I'd start with Supabase or Neon rather than jumping here.

What I'd choose

• "I want the easiest complete backend" → Supabase
• "I want proper Postgres and maximum flexibility" → Neon
• "I'm building on Cloudflare Workers and want everything at the edge" → D1
• "I need serious multi-region/enterprise infrastructure" → Aurora DSQL

If you tell me what you're building (e.g. Next.js SaaS, mobile app, API, AI app, marketplace, etc.), I can narrow this down to 2–3 choices and compare pricing, auth, ORM support, scaling, cold starts, and vendor lock-in.

Choosing a serverless SQL database comes down to your preferred SQL flavor (Postgres vs. MySQL vs. SQLite), how you want to handle scaling, and whether you need an all-in-one backend platform or just a raw connection string.

The top options are categorized below by their strengths:

PostgreSQL Options

• Neon : A true serverless Postgres platform that cleanly separates compute from storage. It features instant auto-scaling, scale-to-zero capability, and unique database branching (letting you spin up a branch of your production database for every Git pull request or preview environment).
• Supabase : More than just a database, this is an open-source Firebase alternative that bundles a managed PostgreSQL database with auto-generated APIs, real-time sync, and built-in authentication. Ideal if you want a complete backend out of the box.
• CockroachDB : A distributed SQL database with PostgreSQL wire compatibility. It is built for multi-region resilience and horizontal scaling, making it great for globally distributed apps that require strong consistency.

MySQL Options

• PlanetScale : A serverless MySQL-compatible platform powered by Vitess. It handles massive scaling, non-blocking schema changes, and a Git-like workflow for managing database migrations.
• Amazon Aurora Serverless (v2): The go-to choice if you are deeply embedded in the AWS ecosystem (using AWS Lambda or API Gateway). It scales database capacity instantaneously based on application load.

SQLite & Edge Options

• Turso : Built on libSQL (an open-source SQLite fork), Turso lets you replicate your SQL database to multiple edge locations globally, delivering single-digit millisecond read latencies for users no matter where they are located.
• Cloudflare D1 : Cloudflare's native serverless SQLite database, designed to run right alongside Cloudflare Workers with minimal latency.

Developer Opinions

I've been using Neon for a project with intermittent traffic, and the scale-to-zero feature is fantastic—it drops usage costs to basically nothing when nobody is using the app.

Supabase feels like cheating when building an MVP. Getting auth, storage, and a real Postgres instance wired up in 10 minutes saves an immense amount of boilerplate.

To help narrow down the best fit, tell me:

• What frontend/backend framework or language are you building with?
• Do you need built-in authentication and file storage , or just a pure SQL database?
• Are you targeting users in a single region or globally distributed across the edge?

If you want serverless compute + SQL, there are several very good choices. The biggest decision is whether you want PostgreSQL/MySQL compatibility or a more tightly integrated edge/serverless database.

1. Supabase — easiest full backend

Supabase gives you PostgreSQL plus authentication, storage, realtime features, APIs, and other backend functionality.

It's a particularly good choice if you want something like:

Next.js → Supabase → PostgreSQL

rather than assembling a dozen separate services.

Cloudflare's current documentation also lists Supabase among the serverless databases that can be accessed from Workers.

Choose it if: you're building a conventional SaaS, web app, mobile backend, or MVP and want lots of functionality out of the box.

---

2. Neon — my pick for serverless PostgreSQL

Neon is focused specifically on serverless Postgres.

It's attractive when you want real PostgreSQL without managing database servers, particularly for applications deployed on platforms such as Vercel or other serverless environments. Cloudflare supports Neon through both its serverless driver and Hyperdrive integration.

Choose it if: your application is primarily a serverless application and you want PostgreSQL with minimal infrastructure management.

---

3. Cloudflare D1 — excellent for Workers

Cloudflare D1 is a managed SQLite-based serverless SQL database designed specifically for Cloudflare Workers and Pages.

The architecture is very clean:

Cloudflare Worker → D1

You don't have to deal with database connection pooling in the traditional way, and D1 integrates directly with Workers.

Choose it if: you're already building on Cloudflare Workers and don't specifically need PostgreSQL.

Caveat: SQLite isn't PostgreSQL. For a sophisticated relational application, I'd generally prefer Postgres.

---

4. Amazon Aurora Serverless — for serious AWS workloads

Amazon Web Services Aurora Serverless supports PostgreSQL and MySQL and automatically adjusts database capacity according to demand. Current Aurora Serverless can scale down to zero capacity in supported configurations.

Choose it if: you're already heavily invested in AWS, need sophisticated networking/security/compliance, or expect the database to eventually become a major production system.

The downside is that it's considerably more AWS infrastructure than something like Neon or Supabase.

---

What I'd choose

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

• Supabase → you want an all-in-one backend.
• Neon → you want excellent serverless PostgreSQL and will build the rest yourself.
• D1 → you're building primarily on Cloudflare Workers.
• Aurora Serverless → you're building an AWS-centric production system.

My default recommendation today: Neon + a serverless compute platform if you want architectural flexibility; Supabase if you want the fastest route to a complete backend.

If you tell me what you're building (e.g. Next.js SaaS, Python API, mobile app, AI app, high-traffic API), I can narrow this to 2–3 choices and explain the tradeoffs in terms of cost, cold starts, scaling, connection pooling, and vendor lock-in.

Finding a solid serverless backend that pairs well with a SQL database usually comes down to combining a serverless function platform (or Backend-as-a-Service) with a serverless-friendly, scalable SQL database.

Here are the top options broken down by architecture style:

Complete Serverless Platforms (BaaS with Built-in SQL)

• Supabase : An open-source Firebase alternative built entirely around PostgreSQL. It gives you an instant auto-generated REST/GraphQL API, real-time subscriptions, authentication, and a fully managed Postgres database with a serverless scaling mindset.
• Xata : A serverless data platform that acts as a database and a backend API layer, providing a Postgres-backed data store with built-in search, branching, and TypeScript/JavaScript SDKs.
• PocketBase : An open-source Go backend that packs an embedded SQLite database, real-time subscriptions, and built-in auth. While it runs on a single server rather than natively distributed multi-region serverless, its extreme lightweight nature makes it a favorite for serverless-style single-binary deployments.

Serverless Compute + Serverless SQL Database

If you prefer decoupling your compute functions from your database, these combinations offer true pay-per-request scaling on both ends:

• Vercel / Netlify Functions + Neon / PlanetScale (Postgres/MySQL) : You host your API routes or serverless functions on Vercel or Netlify, and connect them to Neon (a serverless, branching Postgres database) or PlanetScale (serverless MySQL, though they also offer PostgreSQL support). They handle connection pooling natively, which is critical for serverless environments.
• AWS Lambda + Amazon Aurora Serverless v2 : The enterprise-grade heavy hitter. AWS Lambda provides the serverless compute, while Aurora Serverless automatically scales database capacity up and down based on application load.
• Cloudflare Workers + Cloudflare D1 : Cloudflare's ultra-fast edge workers paired with D1 , their serverless SQL database built on SQLite. This runs globally across Cloudflare's edge network with near-zero cold starts.

To help narrow down the best fit, could you tell me:

• What programming language or framework do you plan to use?
• Do you prefer a fully managed Backend-as-a-Service (like Supabase) or custom serverless functions with a standalone DB?