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

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?

The serverless SQL database and backend ecosystem provides incredible options that separate compute from storage , allowing databases to scale down to zero when idle and eliminating manual infrastructure management.

The leading options for a serverless backend paired with a SQL database are organized by their ecosystem strengths:

PostgreSQL-Based Options

• Neon : A true serverless Postgres platform that cleanly separates storage and compute. It features instant scale-to-zero and Git-like database branching , which lets you spin up copy-on-write branches for preview environments or pull requests.
• Supabase : A full-stack open-source Firebase alternative built around PostgreSQL. Beyond the database, it automatically bundles authentication, auto-generated APIs, file storage, and real-time listeners, making it ideal for rapid MVPs.
• Prisma Postgres : A managed, serverless Postgres solution optimized specifically for the Prisma ORM ecosystem, featuring integrated connection pooling and fast cold starts.

MySQL & Distributed SQL Options

• PlanetScale : A serverless MySQL-compatible database powered by Vitess. It handles extreme horizontal scaling, provides non-blocking, zero-downtime schema migrations, and treats schema changes with Git-like workflows.
• Amazon Aurora Serverless (v2): AWS's native relational option supporting MySQL and PostgreSQL. It scales database capacity instantaneously based on application load without requiring manual partitioning or sizing.
• CockroachDB Serverless : A distributed SQL database with PostgreSQL wire compatibility. It is built for multi-region resilience, strong consistency, and features a perpetual free tier for low-to-moderate workloads.

Edge-Native SQL Options

• Turso : Built on libSQL (an open-source fork of SQLite), Turso lets you replicate your SQL database to dozens of global edge locations so reads happen in single-digit milliseconds right next to your users.
• Cloudflare D1 : Cloudflare’s native serverless SQL database, built on SQLite and designed to run seamlessly inside Cloudflare Workers right at the network edge.

User Experiences

Supabase vs Neon Experiences

“Go for Supabase. Never sleeps, has a generous free tier, real time api.”

“Neon is the best serverless Postgres for development workflows — instant branching, scale-to-zero, and affordable after Databricks-driven price cuts.”

If you can share:

• Your preferred frontend/backend language or framework (e.g., Next.js, Python, Node.js)
• Whether you need built-in auth and storage or just the database
• Your anticipated traffic patterns (spiky, steady, or brand-new MVP)

I can help narrow down the ideal match for your specific architecture.

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

My shortlist

1. Supabase — probably the easiest starting point

Supabase gives you a real PostgreSQL database, plus Auth, Storage, Realtime, APIs, and serverless Edge Functions in one platform.

A typical stack might be:

Next.js / React
       ↓
Supabase Edge Functions
       ↓
PostgreSQL
       ↓
Supabase Storage

It's particularly nice if your application has users, permissions, file uploads, and CRUD-heavy data. Supabase also provides a connection pooler specifically designed for serverless/edge workloads.

I'd choose it for: SaaS MVPs, dashboards, CRUD applications, mobile apps, startups.

---

2. Neon — best if you primarily want Postgres

Neon is essentially serverless PostgreSQL rather than a complete backend-as-a-service. Its architecture separates compute and storage and supports autoscaling, database branching, and scale-to-zero behavior.

You can pair it with almost any serverless compute:

Next.js / Vercel Functions
        ↓
      Neon
    PostgreSQL

or:

Cloudflare Workers
        ↓
      Neon
    PostgreSQL

I'd choose it for: applications where PostgreSQL is important and you don't want to commit to a larger BaaS abstraction.

---

3. Cloudflare Workers + D1 — excellent for edge applications

Cloudflare D1 is a serverless SQLite database designed to work directly with Cloudflare Workers. It provides SQL, automatic management, and an HTTP/Workers API.

Browser
   ↓
Cloudflare Worker
   ↓
D1 (SQLite)

It's very attractive for globally distributed, relatively straightforward applications. D1 is SQLite rather than PostgreSQL, so I'd be more cautious about choosing it if you expect complicated Postgres-specific functionality or eventually need to migrate to Postgres.

I'd choose it for: small-to-medium SaaS apps, edge applications, APIs, personal projects, and Cloudflare-heavy stacks.

---

4. Aurora Serverless — when you're already in AWS

Amazon Web Services Aurora Serverless v2 gives you managed, automatically scaling PostgreSQL or MySQL-compatible databases.

A common architecture is:

API Gateway
     ↓
AWS Lambda
     ↓
RDS Proxy
     ↓
Aurora Serverless

It's powerful and appropriate for serious AWS workloads, but it's substantially more infrastructure than I'd choose for a simple new project.

I'd choose it for: existing AWS environments, enterprise applications, complex networking/compliance requirements, or workloads that need Aurora's capabilities.

---

What I'd pick

If you're starting a new application today:

🥇 Supabase — if you want the whole backend handled for you.

🥈 Neon + Vercel/Cloudflare/etc. — if you want a clean, conventional PostgreSQL backend and flexibility over the rest of the stack.

🥉 Cloudflare D1 — if you're specifically building around Cloudflare Workers and SQLite is sufficient.

AWS Aurora Serverless — if AWS is already your ecosystem or you have enterprise requirements.

One important distinction: "serverless backend" doesn't necessarily mean the database has to be serverless. You can perfectly reasonably run serverless functions against a conventional managed PostgreSQL database, provided you use appropriate connection pooling. Supabase, for example, explicitly recommends transaction pooling for serverless/edge functions.

If you tell me your stack (e.g. Next.js, Python/FastAPI, React Native, Cloudflare Workers, Vercel) and roughly how much traffic/data you expect, I can narrow this down to 1–2 options and compare cost, latency, cold starts, SQL compatibility, auth, and vendor lock-in.

If you want a serverless backend with a SQL database, the best choice depends on whether you prioritize PostgreSQL compatibility, ease of development, edge deployment, or massive scale. These are the strongest options:

My usual recommendations

1. Building a SaaS, web app, or startup MVP → Supabase or Neon + a serverless API layer

Example stack:

• Frontend: Next.js / React
• Backend: serverless functions (Vercel Functions, Cloudflare Workers, etc.)
• DB: Postgres
• ORM: Drizzle or Prisma

Choose:

• Supabase if you want auth, file storage, and realtime features built in.
• Neon if you want a clean Postgres-first architecture.

---

2. Want the simplest possible serverless stack → Cloudflare Workers + D1

D1 is Cloudflare's managed serverless SQL database built around SQLite semantics and is designed to work directly with Workers. It is a good fit for lightweight applications, edge workloads, and apps that do not need every PostgreSQL feature.

Good for:

• internal tools
• prototypes
• small SaaS apps
• globally distributed read-heavy apps

Less ideal for:

• complex analytics
• heavy relational workloads
• applications needing advanced Postgres extensions

---

3. Serious production system with enterprise requirements → Aurora Serverless or distributed SQL

AWS Aurora Serverless and newer distributed SQL offerings are aimed at workloads where reliability, scaling, and cloud integration matter more than simplicity.

---

A practical decision tree

• Need auth + database + storage immediately → Supabase
• Want real PostgreSQL with serverless scaling → Neon
• Already using Cloudflare Workers → D1
• Need AWS enterprise infrastructure → Aurora Serverless
• Need multi-region transactional SQL → CockroachDB / Aurora DSQL

For most new applications in 2026, I would start with PostgreSQL (Supabase or Neon) unless there is a specific reason to choose SQLite/D1 or a distributed database. It keeps your options open and avoids outgrowing the database model early.

If you share your app type (SaaS, mobile backend, API, game, internal tool, etc.) and expected scale, I can narrow this down to a couple of choices.

The serverless SQL database landscape is robust, with distinct platforms tailored for specific workflows, scaling models, and hosting preferences.

Dedicated Serverless SQL Platforms

• Neon - A true serverless PostgreSQL database that completely separates compute from storage, allowing it to scale down to zero when idle. It stands out for its unique Git-like branching feature, letting you create instant copy-on-write branches of your database for preview deployments and testing.
• Supabase - Built on top of managed PostgreSQL, Supabase bundles your database with instant auto-generated APIs, built-in authentication, real-time subscriptions, and file storage. It functions as an open-source Firebase alternative for full-stack applications.
• PlanetScale - A serverless MySQL-compatible database powered by Vitess. It is built for massive horizontal scale and offers a developer workflow that treats database schema changes and non-blocking migrations with Git-like safety.
• Turso - A serverless SQL database built on libSQL (an open-source fork of SQLite). It is optimized for the "edge," allowing your database to replicate globally so that read queries execute close to your users with minimal latency.
• CockroachDB Serverless - A distributed SQL database with PostgreSQL wire compatibility. It is engineered for globally distributed, multi-region applications that require strong transactional consistency and high survivability.

Cloud Provider Native Options

• Amazon Aurora Serverless (v2) - An enterprise-grade, auto-scaling relational database from AWS that is compatible with both PostgreSQL and MySQL. It scales capacity transparently based on application load, though it operates best if your backend already lives heavily inside the AWS ecosystem.
• Azure SQL Database Serverless - Microsoft's auto-scaling tier for single databases running on the SQL Server engine, which pauses compute during inactive periods to save on costs.

User Experiences

Supabase Reliability

“Go for Supabase. Never sleeps, has a generous free tier, real time api”

“Open-source Firebase alternative built on PostgreSQL, Supabase includes real-time subscriptions, authentication, and storage-all fully accessible via an easy matter-of-fact API”

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

• What SQL dialect do you prefer (PostgreSQL vs. MySQL)?
• Are you pairing this with a specific frontend/backend framework (like Next.js, Cloudflare Workers, or AWS Lambda)?
• Do you need edge distribution or built-in authentication/auth features?