Cloudflare D1

Short answer: the “best” serverless database depends on your app, but the products people actually use are: Neon, Supabase, AWS DynamoDB, Google Firestore, MongoDB Atlas, AWS Aurora Serverless, PlanetScale, Azure Cosmos DB, Cloudflare D1/Turso, and Upstash Redis. I’d pick from these rather than obscure “cool” options.

Best serverless databases by use case

My practical ranking

1. Neon — best pure serverless Postgres

Choose Neon if you want Postgres, SQL, Prisma/Drizzle compatibility, preview databases, branching per PR, and scale-to-zero. It’s one of the cleanest answers for “I’m building a SaaS/web app and want serverless Postgres.” (neon.com)

2. Supabase — best Postgres + backend platform

Choose Supabase if you want Postgres plus built-in Auth, Storage, Realtime, Edge Functions, APIs, and dashboard tooling. It’s often the fastest route from idea to working app. (supabase.com)

3. Amazon DynamoDB — best AWS-native serverless NoSQL

Choose DynamoDB if you are on AWS and need huge scale, predictable key-value/document access, low latency, and minimal ops. Avoid it if you need rich ad-hoc SQL queries or lots of relational joins. (docs.aws.amazon.com)

4. Google Firestore / Firebase — best mobile and realtime app DB

Choose Firestore if you’re building mobile apps, collaborative apps, simple web apps, or Firebase-based products. It’s very productive, but its document model and query constraints mean you should design your data model carefully. (docs.cloud.google.com)

5. MongoDB Atlas — best serverless-ish MongoDB option

Choose MongoDB Atlas if your app naturally fits documents, your team knows MongoDB, or you need MongoDB ecosystem compatibility. It’s a safer mainstream choice than niche document databases. (mongodb.com)

6. Amazon Aurora Serverless — best enterprise/serverless relational on AWS

Choose Aurora Serverless when you want familiar MySQL/Postgres-compatible SQL in AWS with automatic capacity scaling. It’s more “enterprise cloud database” than indie-developer serverless DB, but it’s a serious production choice. (docs.aws.amazon.com)

7. PlanetScale — best for MySQL/Vitess scale and safe schema workflows

Choose PlanetScale if you want managed Vitess/MySQL-compatible scaling, branching, safe migrations, and strong operational ergonomics. It’s especially attractive for teams that know MySQL or need serious relational scale. (planetscale.com)

8. Azure Cosmos DB Serverless — best for Azure-native NoSQL

Choose Cosmos DB Serverless if you are already in Azure and want consumption-based NoSQL with multiple API models. It’s less likely to be my first pick for a greenfield startup unless the team is already Microsoft/Azure-heavy. (learn.microsoft.com)

9. Cloudflare D1 / Turso — best SQLite/edge choices

Choose Cloudflare D1 if your app runs on Cloudflare Workers and needs lightweight relational SQL. Choose Turso if you like SQLite-compatible databases, per-tenant/per-user database patterns, or edge/local-first-style architectures. (developers.cloudflare.com)

10. Upstash Redis — best serverless Redis companion

Choose Upstash for Redis use cases: cache, sessions, rate limits, queues, pub/sub-ish patterns, and fast serverless/edge access. It’s usually a complement to Postgres/DynamoDB/Firestore, not a full replacement. (upstash.com)

If I had to recommend only 3

1. Neon — best default if you want serverless Postgres.
2. Supabase — best if you want a full backend platform.
3. DynamoDB — best if you’re serious about AWS-native serverless scale.

For most new SaaS or web apps, I’d start with Neon or Supabase. For mobile/realtime apps, I’d seriously consider Firebase/Firestore. For AWS-heavy production systems, DynamoDB and Aurora Serverless are the safest mainstream bets.

The term serverless database is used loosely, but generally means a database that:

• Requires no server setup or maintenance
• Scales automatically (or near-automatically)
• Bills based on usage (requests, storage, compute) rather than a fixed server cost

Here are the most widely used serverless databases, grouped by type, with honest pros/cons.

---

🥇 Top NoSQL serverless databases

1. AWS DynamoDB

The OG serverless database. Fully managed, massive scale, millisecond latency.

• Best for: High-traffic apps, real-time use cases, AWS-native stacks
• Pricing: Pay per read/write request + storage
• Cons: Querying is limited; you need to design your access patterns in advance
• Used by: Snapchat, Lyft, Twitch, countless startups

2. MongoDB Atlas (Serverless tier)

MongoDB's fully managed serverless offering. You get the familiar document model with auto-scaling.

• Best for: Teams already using Mongo, flexible document data
• Pricing: Pay per read/write operations and storage (with free tier)
• Cons: Serverless tier has some limitations vs. dedicated clusters; connection scaling can be tricky
• Used by: SEGA, EA, Coinbase

3. Google Cloud Firestore

NoSQL document database that syncs well with Firebase and Google Cloud.

• Best for: Mobile apps, Firebase projects, real-time sync
• Pricing: Pay per read/write/delete + storage
• Cons: Data structure can be quirky; scaling analytics is not its strength
• Used by: The Economist, Niantic, Payoneer

4. Azure Cosmos DB

Microsoft's global, multi-model database (SQL, Mongo, Cassandra, Gremlin, Table APIs).

• Best for: Global multi-region apps, if you’re in the Azure ecosystem
• Pricing: Pay per request units (RU) + storage
• Cons: Can be expensive if not tuned carefully
• Used by: Expedia, KPMG, ASOS

---

🥇 Serverless relational databases (Postgres/MySQL)

5. Supabase

Open-source Firebase alternative built on PostgreSQL. You get a Postgres database with auth, storage, and realtime subscriptions.

• Best for: Full-stack apps, developers who love Postgres/SQL
• Pricing: Free tier available; paid plans scale compute and storage
• Cons: Still evolving; not ideal for heavy, complex relational workloads at massive scale
• Used by: Notion (they use it internally?), many indie hackers and startups

6. Neon

Serverless Postgres with autoscaling, branching, and instant database forking. Built for the cloud-native era.

• Best for: Branching for dev/test, autoscale with low latency
• Pricing: Free tier; paid plans based on compute + storage
• Cons: Not as battle-tested as PlanetScale or traditional RDS
• Used by: Vercel, Netlify, Comet

7. PlanetScale

Serverless MySQL, owned by the MySQL creators (Vitess). It’s a drop-in MySQL replacement with horizontal sharding built in.

• Best for: MySQL shops, high-write apps, Rails/Django apps
• Pricing: Free tier; paid plans scale based on compute
• Cons: No backend jobs/triggers in some plans; branch-based schema changes take getting used to
• Used by: GitHub (they use it internally?), many SaaS startups

8. Turso (libSQL)

A SQLite-based serverless database designed for edge deployment. Supports branching and replication to edge locations.

• Best for: Edge functions, read-heavy workloads, simple SQLite apps
• Pricing: Generous free tier; pay for edge replicas
• Cons: Write scalability is limited compared to Postgres/MySQL
• Used by: Cloudflare, Vercel ecosystem, many serverless apps

---

🥇 Edge/serverless DBs with unique models

9. Cloudflare D1

Cloudflare's serverless SQLite database, integrated with Workers.

• Best for: Cloudflare Workers projects, globally distributed reads
• Pricing: Pay per read/write + storage (very cheap)
• Cons: Relatively new; not meant for complex joins or heavy writes yet
• Used by: Cloudflare ecosystem apps

10. Fauna

A fully-managed, document-relational database with GraphQL, FQL, and a globally distributed model. Often called "the serverless database."

• Best for: Apps that need global data with minimal ops
• Pricing: Pay per compute + storage (free tier available)
• Cons: Vendor lock-in; FQL has a learning curve
• Used by: Netlify, Domo

---

Quick recommendation guide

---

Final word

There’s no single “best” serverless database. It depends on your data model (relational vs. document), your cloud provider, your team’s experience, and your traffic patterns. For a new project, starting with Supabase or Neon (if you want

The top serverless databases in active use (as of 2026) are Neon, Supabase, Turso, PlanetScale, AWS DynamoDB, and Google Cloud Firestore, along with strong options like Cloudflare D1 and MongoDB Atlas Serverless. These stand out in developer comparisons, adoption signals (e.g., GitHub stars, production mentions), and real-world recommendations for variable workloads, edge apps, and serverless/edge architectures.

Serverless databases automatically scale compute/storage (often with scale-to-zero for idle periods), use usage-based pricing, and eliminate server management. They suit spiky or unpredictable traffic, SaaS/multi-tenant apps, and modern stacks (e.g., Next.js/Vercel). Traditional always-on options like some Supabase setups or Aurora Serverless v2 are sometimes grouped here but differ in true serverless behavior.

Top Recommendations by Category and Popularity

Here are the most recommended and used options, grouped by strengths:

Postgres-Focused (Most Popular for General Web/Modern Apps)

• Neon: Frequently cited as the default or best overall serverless Postgres in 2026 comparisons. It separates compute from storage for true scale-to-zero, offers excellent database branching (schema + data copies for previews/CI-CD), strong Vercel/Next.js integration, and a generous free tier (e.g., 0.5 GB storage). Ideal for variable workloads, AI apps (pgvector support), and developer productivity. Cold starts are typically 500 ms–2 s. Many sources call it the top pick for most developers starting new projects.
• Supabase: Extremely popular all-in-one Postgres platform (86k+ GitHub stars) with built-in auth, storage, realtime subscriptions, edge functions, and pgvector. Strong free tier and open-source roots. Not always "pure" serverless (compute often stays on), but excellent for full-stack apps where you want one vendor. Great for MVPs and teams needing more than raw DB.

Edge/SQLite-Focused (Lowest Latency, Global Reads)

• Turso (libSQL/SQLite fork): Excels at edge deployment with replicas across 30+ regions, instant/low-latency reads (often sub-50 ms cold), and strong multi-tenancy (per-tenant DBs). Generous free tier and HTTP drivers suit embedded/edge runtimes. Top choice for content platforms, global apps, or SQLite users wanting production parity.
• Cloudflare D1 (SQLite): Cheapest and simplest for Cloudflare Workers/edge ecosystems, with solid free allowances and automatic scaling. Best for lightweight, read-heavy workloads in that ecosystem.

MySQL-Focused (Scale and Schema Safety)

• PlanetScale (Vitess-powered, MySQL-compatible; Postgres support expanding): Praised for zero-downtime schema migrations/branching, horizontal scaling, and high write throughput. Popular for teams already on MySQL or needing robust production workflows. Free tier was removed/limited, so it's more for paid/production use.

NoSQL/Key-Value/Document (Established Production Use)

• AWS DynamoDB: One of the most widely used serverless databases overall, especially in AWS ecosystems. Instant scaling, global tables, HTTP API, and strong for key-value patterns with predictable access. Extremely reliable for high-scale apps; often compared favorably for cold-start speed and AWS integration.
• Google Cloud Firestore: Mature document database with realtime sync, strong Firebase/mobile/web integration, and serverless scaling. Popular for apps needing flexible schemas and cross-platform support.
• MongoDB Atlas Serverless: Flexible document model with a dedicated serverless tier. Good balance of features and scaling for document-oriented workloads.

Other Notable Mentions

• CockroachDB Serverless: Distributed Postgres-compatible with strong global consistency and multi-region defaults. Good for enterprise/global SaaS needing ACID guarantees.
• Upstash (serverless Redis): Best for caching, sessions, queues, or KV needs with low latency.

Quick Decision Guide

• General web apps/Next.js/Vercel — Start with Neon (or Supabase for extras).
• Full backend (auth/storage/realtime) — Supabase.
• Edge/global low latency — Turso or D1.
• MySQL + safe migrations at scale — PlanetScale.
• AWS-heavy or high-scale KV — DynamoDB.
• Mobile/realtime documents — Firestore.
• Existing MySQL/Postgres teams — Match the dialect (PlanetScale/Neon) and test branching/scale-to-zero.

Key Considerations

Pricing varies widely (free tiers are generous on Neon/Supabase/Turso/D1 but usage-based after; PlanetScale is more paid-focused). Test cold starts, connection pooling (e.g., via Drizzle/Prisma), and your workload—many support ORMs well. Branching (Neon/PlanetScale) is a game-changer for dev workflows.

Adoption favors Postgres options (Neon/Supabase) for new projects due to ecosystem/tooling, while DynamoDB and Firestore remain staples in their clouds. Always benchmark with your data patterns, as "best" depends on SQL dialect, latency needs, multi-region requirements, and budget. Check current pricing and docs, as features evolve quickly.