Chaos and Order

💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

> "In 2026, your database no longer lives in one place. It lives next to your users, sleeps at zero, or both." — Cloudflare Developer Day keynote, April 2025

The explosion of edge computing and serverless workloads has outgrown the single-region RDS instance. Cloudflare Workers boot a V8 isolate within 5ms in 330 cities, but a round trip to fetch data from us-east-1 costs 250ms — and suddenly the value proposition of "function at the edge" disappears. To close this gap, a brand-new category of "edge databases" emerged in the early 2020s, and the landscape in May 2026 — after a wave of acquisitions, shutdowns, and consolidation — looks completely different from what it did just two years ago.

This post covers the full stack as of May 2026: Cloudflare D1, Hyperdrive, Workers KV, Durable Objects, R2, and Queues; Turso (libSQL); PlanetScale (Vitess); Neon; Supabase; Convex; Fauna; Xata; Tigris; Upstash; Momento; Vercel Postgres; MongoDB Atlas Serverless; DynamoDB; Aurora Serverless v2; CockroachDB Serverless; Spanner; Cosmos DB for PostgreSQL; OrioleDB. Pricing, latency, distribution strategy, and adoption in Korea and Japan included.

1. The 2026 Map — Five Coordinates of Edge and Serverless DBs

The cleanest classification uses two axes: **data model (SQL, KV, document, reactive)** and **distribution strategy (edge replica, single-region autoscale, global multi-region)**.

| Category | Representatives | Distribution |

|---|---|---|

| Edge SQLite | Cloudflare D1, Turso, LiteFS, Fly Postgres | Edge replicas, ms reads |

| Serverless Postgres | Neon, Supabase, Vercel Postgres, Aurora Serverless v2 | Single region, scale to zero, branching |

| Serverless MySQL | PlanetScale, Aurora Serverless v2 (MySQL) | Vitess sharding, branching |

| Global distributed SQL | CockroachDB Serverless, Spanner, YugabyteDB | Multi-region consensus |

| Reactive / full-stack | Convex, Supabase Realtime, InstantDB | Live subscriptions, sync |

| KV / Cache | Workers KV, Upstash Redis, Momento, Vercel KV, DynamoDB | Global cache, key-based |

| Document | MongoDB Atlas Serverless, Fauna (sunset), DynamoDB | Schemaless |

| Connection pooler + cache | Cloudflare Hyperdrive, AWS RDS Proxy, PgBouncer | Edge-side RDB acceleration |

The first decision branch is always: "is my workload read-heavy or write-heavy, global or regional?" Read-heavy global apps fit Turso/D1/Hyperdrive; write-heavy single-region fits Neon/Supabase/Aurora; strong-consistency global needs Spanner/CockroachDB; reactive subscriptions need Convex.

2. What "Edge Database" Means — Two Definitions

"Edge database" is a young term coined post-2020, so the definition isn't standardized. By 2026, the market has settled on two meanings.

**Narrow sense — Edge Replica**: read-only replicas pinned to PoPs near users, with writes routed to a single primary region. Turso's embedded replicas, Cloudflare D1's globally distributed read replicas (launched 2024), and PlanetScale's read-only regions all fit. Reads drop to 5–20ms; writes still round-trip to primary.

**Broad sense — Edge-runtime-compatible**: the database lives in one place, but the client SDK works inside edge function environments (Workers, Vercel Edge, Deno Deploy) on V8 isolates. Neon's serverless driver, the Supabase JS client, PlanetScale's serverless driver, and Upstash REST API all fit. Not truly edge, but it solves the very common "Postgres from Workers" scenario.

Understanding the edge runtime constraints is essential. Cloudflare Workers and Vercel Edge Runtime run on V8 isolates, not Node.js, so you cannot hold long-lived TCP connections, and `node:net` / `node:dns` are restricted. The traditional `pg` driver is out. You need **HTTP/WebSocket-based drivers**: Neon ships PgBouncer plus a WebSocket proxy, PlanetScale ships an HTTP-based serverless driver, and Upstash was REST-first from day one.

3. Cloudflare D1 — SQLite on Workers, GA in 2024

D1 was announced in May 2022 and went GA in April 2024. It's a SQLite-based edge database called directly from Workers via sub-ms bindings. Since 2025 it has automatic globally distributed read replicas.

**D1 specs as of May 2026**

| Item | Free | Paid (Workers Paid) |

|---|---|---|

| DB size | 5GB/DB | 10GB/DB |

| Row reads | 5M/day | 25M/day, then $0.001 per 1M rows |

| Row writes | 100K/day | 50M/day, then $1.00 per 1M rows |

| DB count | 10 | 50,000 |

| Backup | Time Travel 30 days | Time Travel 30 days |

Because D1 is called via Workers bindings, no separate connection pooler is needed (no Hyperdrive required). It supports the full SQLite SQL surface — JOIN, CTE, window functions, FTS5. The downside is SQLite's single-writer lock: concurrent writes queue.

// D1 usage from Workers

export default {

async fetch(req: Request, env: { DB: D1Database }) {

const { results } = await env.DB

.prepare('SELECT id, name FROM users WHERE active = ?')

.bind(1)

.all<{ id: number; name: string }>()

return Response.json(results)

}

Notable users include Cloudflare's own 1.1.1.1 domain registration service, OpenStatus monitoring data, and Resend's domain/email metadata. In Korea, some Toss side projects and NAVER WHALE's sync beta have used it.

4. Cloudflare Hyperdrive — Edge Accelerator for Postgres/MySQL

Hyperdrive went GA in April 2024 to solve two chronic pains of calling external Postgres/MySQL from Workers: **connection handshake cost** and **query result caching**. MySQL support was added in 2025.

The model is simple. Workers call the Hyperdrive binding; Hyperdrive queries the RDB from the PoP nearest the user using pooled connections. GET-shape queries are cached and returned in ms on subsequent calls.

**Pricing (May 2026)**: included in Workers Paid, no separate charge. A dashboard exposes cache hit/miss statistics.

Latency improvement from Cloudflare's own benchmark — direct Neon connection from Washington: 35ms p50, from Sydney: 280ms p50. Through Hyperdrive — Washington: 6ms (cache hit) / 38ms (miss); Sydney: 12ms (hit) / 285ms (miss). Cache hits give massive wins; on miss, it matches direct.

// Hyperdrive usage — Workers + Postgres

export default {

async fetch(req: Request, env: { HYPERDRIVE: Hyperdrive }) {

const client = new Client({ connectionString: env.HYPERDRIVE.connectionString })

await client.connect()

const { rows } = await client.query('SELECT * FROM products LIMIT 10')

await client.end()

return Response.json(rows)

}

Hyperdrive isn't a replacement for D1 — it's complementary. D1 for service metadata and user profiles, Hyperdrive in front of an external Postgres for large transactional or search workloads is the common pairing.

5. Workers KV, R2, Queues, Durable Objects — Cloudflare's Companion Stack

Cloudflare's data stack has four other key components beyond D1.

**Workers KV** — Global distributed key-value store. Writes propagate to all PoPs in roughly 60 seconds, so consistency is eventual. Values up to 25MB, keys up to 512B. Pricing: 10M reads free, then $0.50 per 1M; 1M writes free, then $5.00 per 1M. Ideal for session tokens, feature flags, A/B test variants — "write once, read often" data.

**Cloudflare R2** — S3-compatible object storage. The differentiator: zero egress traffic charges. Pricing: $0.015/GB-month storage, Class A (writes) $4.50 per 1M, Class B (reads) $0.36 per 1M. Compared to AWS S3, common reports cite media/log/backup/static-asset hosting bills cut by 80%+ thanks to free egress.

**Cloudflare Queues** — Message queue. Guaranteed delivery within 60s for all messages, retention up to 7 days. Pricing: $0.40 per 1M operations. Edge-friendly alternative to EventBridge/SQS.

**Durable Objects (DO)** — Stateful primitive providing strong consistency on a single instance. In 2025 the storage backend moved to SQLite, effectively enabling "per-user SQLite DB." Ideal for chat rooms, live-collab docs, game rooms, real-time counters. Pricing: $5 per 1M requests + $12.50/GB-month. Cloudflare's own Realtime meeting product, Linear live cursors, and Notion live blocks reportedly use DO.

These five services (D1, KV, R2, Queues, DO) are all callable via Workers bindings with no extra auth or DNS round trip, sub-ms. That's the core strength of the Cloudflare stack.

6. Turso — libSQL and the Invention of Embedded Replicas

Turso was founded in 2022 by Glauber Costa and team. Its core is **libSQL**, a fork of SQLite, and the breakthrough innovation of 2024 was **Embedded Replicas** — a model where a SQLite file lives inside the application process and syncs from the primary in the background.

**The effect of embedded replicas**: typical queries respond in sub-ms from memory/local SQLite, while data pulls from the primary every 5–60 seconds. Works on Vercel Edge, Bun, Node, anywhere. Reads run at local-disk latency (0.1ms); writes round-trip to primary.

**Turso plans, May 2026**

|---|---|---|---|---|---|

| Hobby (Free) | $0 | 500 | 1B/month | 25M/month | 9GB |

| Scaler | $299/mo | 100,000 | 100B/month | 5B/month | 1TB |

In 2025 Turso acquired Mooncake Labs and focused on **distributed libSQL Server builds**; in 2026 a beta multi-master sync engine was announced. Companies like Convex, Linear, and Cal.com have adopted the per-user database pattern on Turso.

// Turso with embedded replicas

const db = createClient({

url: 'file:local.db', // local SQLite file

syncUrl: 'libsql://my-db.turso.io', // primary URL

authToken: process.env.TURSO_AUTH_TOKEN!,

syncInterval: 60, // sync every 60s

})

// Read — sub-ms (local)

const users = await db.execute('SELECT * FROM users LIMIT 10')

// Write — local applies immediately, propagates to primary in background

await db.execute({ sql: 'INSERT INTO logs (msg) VALUES (?)', args: ['hi'] })

7. LiteFS (Fly.io) — Another Way to Distribute SQLite

LiteFS, announced by Fly.io in 2022, is a FUSE-based SQLite replication solution. It intercepts the SQLite WAL and streams every transaction to other nodes, enabling "write on primary, read anywhere."

In 2024 Fly sunset LiteFS Cloud, so the hosted option is gone, but **the open-source LiteFS itself remains maintained**, and "Fly Apps + LiteFS" self-managed deployments persist. The WAL-based approach offers stronger transactional consistency than Turso's sync model.

Adopters include Fly.io's own infrastructure, some Aha! modules, and parts of Crisp's customer support workload. By 2026, new adoption has nearly stopped; Turso and D1 have taken almost all of the share.

8. PlanetScale — Vitess and Non-Blocking Schema Changes

PlanetScale was founded to SaaS-ify Vitess (YouTube's MySQL sharding framework). Until 2024 it was the de facto standard for the modern stack. Its two differentiators: **branching (Git-like DB branches)** and **deploy requests (review schema changes like PRs)**.

In April 2024 PlanetScale **discontinued its free Hobby tier**, which shocked the Korean and Japanese developer communities. In November 2025 PlanetScale repositioned around Vitess maintenance, and by 2026 over 70 percent of its business comes from enterprise Vitess hosting.

**PlanetScale plans, May 2026**

|---|---|---|---|

| Scaler | $39/mo | 1B rows/month | 10GB |

| Scaler Pro | $59/mo | 100B rows/month | 100GB |

PlanetScale is less a true "edge DB" and more a SaaS that operates single-region MySQL extremely well. Read-only regions (US/EU/AP) reduce global read latency, and the HTTP serverless driver (`@planetscale/database`) works from Workers and Vercel Edge.

Adopters include Vercel (own data), Cash App, Square, Notion (some workloads), and parts of GitHub Copilot metadata. In Korea, parts of Toss analytics and Daangn Market search metadata are reported uses.

9. Neon — Serverless Postgres, Branching, and the Databricks Acquisition

Neon was founded in 2021 by Heikki Linnakangas (Postgres core committer). The breakthrough architecture **separates storage from compute** — compute can sleep at zero and wakes in 5 seconds, storage scales infinitely on S3-backed page servers.

Its strongest feature is **DB branching** — Git-style copy-on-write DB clones, so each PR can have an isolated DB. CI/CD pipelines creating a fresh branch per PR in a second and deleting it on merge has become standard practice.

In May 2025, **Databricks acquired Neon for around $1B**, and by 2026 it's integrated as the OLTP backend of Databricks Lakebase. Post-acquisition the standalone Neon service continues; the free tier was preserved.

**Neon plans, May 2026**

|---|---|---|---|

| Free | $0 | 191.9 h/month | 0.5GB |

| Launch | $19/mo | 300 h/month | 10GB |

| Scale | $69/mo | 750 h/month | 50GB |

| Business | $700/mo | 1,000 h/month | 500GB |

Neon also powers Vercel Postgres — Vercel partnered with Neon from 2023 and resells it as "Vercel Postgres." The partnership continues post-Databricks.

10. Supabase — Postgres + Auth + Storage + Realtime + Edge Functions

Supabase was founded in 2020 by Paul Copplestone, positioned as an "open-source Firebase." It bundles Postgres + GoTrue (Auth) + Storage (S3 wrapper) + Realtime (Postgres logical replication) + Edge Functions (Deno) + Vector (pgvector) on one platform.

The two biggest changes in 2026 are **Supabase Branching GA** (October 2024) and **Supabase Edge Runtime 2.0** (September 2025). Branching adopts the Neon-style DB branch model; Edge Runtime 2.0 upgrades from Deno 1.46 to Deno 2.x, cutting cold starts below 50ms.

**Supabase plans, May 2026**

| Plan | Price | DB | API |

|---|---|---|---|

| Free | $0 | 500MB | 50K MAU |

| Pro | $25/mo | 8GB | 100K MAU |

| Team | $599/mo | 100GB+ | Unlimited |

Supabase's strength is "everything you need for one product is in one SDK." Auth, RLS policies, file uploads, and live subscriptions can all be done with the same token, accelerating full-stack development. The weakness: it's deeply tied to PostgreSQL, making migration to non-Postgres backends hard.

Adopters include Mozilla AI, Resend, Trigger.dev, Cal.com, and many of Pieter Levels's indie products. In Korea, Daangn Market side projects and parts of Toss Payments developer tools use it.

11. Convex — A Reactive Full-Stack Serverless DB

Convex was founded in 2022 by Jamie Turner (former Dropbox engineering director). It's a "full-stack reactive DB" combining a custom transactional DB, a custom query engine, and a custom JavaScript runtime on a single platform. Clients subscribe to queries, and data is pushed automatically when it changes.

Its most interesting technical detail is **determinism** — all query/mutation functions are JavaScript, but run on a V8 isolate with syscalls blocked. The same input always produces the same output, enabling automatic retry on transaction conflicts.

// Convex query/mutation example

export const listPosts = query({

args: { authorId: v.id('users') },

handler: async (ctx, { authorId }) => {

return await ctx.db

.query('posts')

.withIndex('by_author', (q) => q.eq('authorId', authorId))

.collect()

})

export const createPost = mutation({

args: { title: v.string(), body: v.string() },

handler: async (ctx, args) => {

return await ctx.db.insert('posts', args)

})

**Convex plans, May 2026**

|---|---|---|---|

| Starter | $0 | 1M/month | 0.5GB |

| Pro | $25/mo | 25M/month | 50GB |

| Team | $500/mo | 250M/month | 500GB |

Convex's weakness is heavy lock-in — its custom query language and schema system make migration to other databases hard. But for full-stack indie development or rapid prototyping it's unbeatable. Adopters include many a16z portfolio companies, parts of Cursor, and MoonshotAI (which migrated some workloads in 2025).

12. Fauna — Service Sunset, May 2025

Fauna was founded in 2012 by Evan Weaver and Matt Freels (former Twitter engineers). A distributed NoSQL DB built around the Calvin consensus algorithm and FQL (a custom query language), it touted multi-region strong consistency and was one of the most ambitious distributed DB projects of the late 2010s.

In March 2025, Fauna announced **service end-of-life on May 30, 2025**. The official reason: failure to build a sustainable business model. Customers were given 90 days to migrate, with Convex, MongoDB Atlas, and Couchbase Capella recommended as alternatives.

Fauna's shutdown became a symbolic moment for the limits of the early-2020s "ambitious distributed NoSQL" category. The steep learning curve of FQL, the incomplete GraphQL interface, and a positioning squeeze between AWS DynamoDB and Spanner all compounded.

Migration recommendations by path — for strong consistency and distributed SQL: CockroachDB or Spanner; for full-stack reactive: Convex; for key-value/document: DynamoDB or MongoDB Atlas.

13. Xata — New Sign-Ups Closed, December 2025

Xata was founded in 2022 by Monica Sarbu (formerly of Elastic). A "Postgres + search + analytics" hybrid BaaS, it bundled Postgres and ElasticSearch under one schema, briefly popular with Vercel and SaaS startups.

In 2024 Xata rebuilt its backend on OrioleDB to become fully PostgreSQL-standard. Then, in December 2025, it abruptly announced **closure of new sign-ups**. Existing customers are guaranteed operation through the end of 2026, while the company pivoted to open-source projects like OrioleDB and pg-roll (a zero-downtime migration tool).

OrioleDB rewrites the Postgres storage engine as cloud-native (with separated storage). In 2025 Supabase acquired OrioleDB and hired its core engineers. In short, Xata's tech assets were absorbed into Supabase, and Supabase Postgres 2026 offers an OrioleDB-based option in beta.

14. Tigris Data — Globally Distributed Object + DB

Tigris Data was founded in 2022 by Ovais Tariq, Yevgeniy Firsov (former Uber distributed systems) and others. From 2024 onward it repositioned as a **globally distributed S3-compatible object storage** product — having started as a document DB and pivoted when AI workloads created demand for object storage.

Tigris's core value in 2026 is **automatic global replication** — objects written anywhere replicate automatically to the region nearest the user, with zero egress and an S3-compatible API. Ideal for AI model checkpoints, training datasets, and inference result caches. Pricing: storage $0.02/GB-month, Class A requests $0.005 per 1K, egress $0/GB.

Compared to Cloudflare R2 — R2 is single-region storage plus global cache; Tigris is true global replication. R2 started with free egress; Tigris extends free replication globally too. Adopters include Lambda Labs (AI GPU cloud), parts of Modal Labs, and several Y Combinator AI startups.

15. Upstash — Serverless Redis, QStash, and Vector

Upstash was founded in 2020 by Mehmet Dogan (former AWS), with the identity "serverless Redis that sleeps at zero and bills per request." The 2026 lineup looks like this.

**Upstash Redis** — Redis 7.x compatible, HTTP + WebSocket API, optional global replication. Pricing: $0.20 per 100K requests. The first-line tool for cache, session, and rate limit on Workers and Vercel Edge.

**Upstash Vector** — Vector DB launched in 2024. Alternative to pgvector and Pinecone. Pricing: $0.40 per 100K requests, $0.25/GB-month storage.

**Upstash QStash** — HTTP-based message queue and scheduler. Cron + retry + exponential backoff + signature verification in one SaaS. Pricing: $1 per 100K messages.

**Upstash Kafka** — sunset in late 2024. Upstash retired Kafka and focused on Redis, Vector, and QStash.

Upstash's big advantage is **zero fixed cost** — if there are no requests, you pay nothing. For side projects, indie hackers, and SaaS with volatile traffic, it's become the de facto standard for cache and rate-limit layers. Adopters include the original Vercel KV backend (migrated away in late 2024 to a self/Redis Cloud combo), Trigger.dev, Resend, and parts of Linear.

16. Vercel Postgres, KV, Blob, Edge Config — A Bundle of Partnerships

Vercel announced four products under the Vercel Storage umbrella starting in 2023 — all of them wrappers over external partners.

| Product | Backend | Note |

|---|---|---|

| Vercel Postgres | Neon | GA 2025, branching supported |

| Vercel KV | Upstash Redis (until ~2024) → Redis Cloud | Migrated away from Upstash in late 2024 |

| Vercel Blob | In-house (on AWS S3) | Global CDN, unlimited |

| Vercel Edge Config | In-house (own KV) | Build-time + runtime feature flags |

By 2026 Vercel has clearly de-prioritized building its own data infrastructure. Rather than constructing from scratch, it positions itself as a wrapper over Neon, Upstash, MongoDB and similar partners, focusing instead on developer experience. Billing consolidates to Vercel; dashboards integrate; the backend itself remains the partner's infrastructure.

This is Vercel's honest self-assessment in the data category — "we're not a DB company; we run frontend and edge functions" — bundling data services as packaged offerings. The exact opposite strategy from Cloudflare building D1, R2, and KV in-house.

17. MongoDB Atlas Serverless — Document Goes Serverless

MongoDB Atlas Serverless was announced in 2021 and GA'd in 2022. It doesn't sleep at zero, but is billed per request and per stored byte, and capacity scales automatically.

The two major changes for MongoDB Atlas in 2026 are **Atlas Vector Search GA** (2024) and **Atlas Search Nodes** (2025). Vector Search supports hybrid search (keyword + vector) and has grown popular as a RAG backend; Search Nodes separate search workloads from the main cluster.

Pricing: Read Processing Units (RPU) $0.10 per M, Write Processing Units (WPU) $1.25 per M, storage $0.25/GB-month. The free M0 tier remains for sandboxing.

The strengths of MongoDB Atlas Serverless are **document model + strong consistency + transactions**. The weakness: direct calls from a V8 isolate environment are difficult — you need either the Atlas Data API (HTTP) or Atlas App Services (the official wrapper). Adopters include Adobe, eBay, Lyft, Forbes, Toyota Connected, and many other large enterprises.

18. AWS DynamoDB and DynamoDB Streams — The Cloud KV King

DynamoDB launched in 2012 and remains AWS's dominant KV/document DB in its 14th year. The biggest changes through 2026 are **DynamoDB Standard-IA** (infrequent access, 60% storage discount), the stabilization of **PartiQL**, and **Global Tables multi active-active GA** in 2024.

Two pricing models — **On-demand** ($1.25 per M writes, $0.25 per M reads, $0.25/GB-month) or **Provisioned** (reserved WCU/RCU, cheaper but requires capacity management). On-demand pricing was cut by an average of 50% in November 2024, making it attractive again.

DynamoDB isn't an edge DB in the strict sense, but it serves sub-10ms p99 in a single region and supports multi-region active-active via Global Tables. In Korea, **Coupang** uses DynamoDB extensively for core order/delivery metadata (heavily documented in Coupang's engineering blog); in Japan, **Mercari** runs a DynamoDB + Aurora combination for transaction metadata and notification queues.

// DynamoDB called from Workers/Edge

const client = new DynamoDBClient({

region: 'ap-northeast-2',

credentials: { accessKeyId: env.AWS_KEY, secretAccessKey: env.AWS_SECRET },

})

const res = await client.send(new GetItemCommand({

TableName: 'users',

Key: { id: { S: 'u-1' } },

}))

19. Aurora Serverless v2 — Autoscaling Postgres and MySQL

Aurora Serverless v2 GA'd in 2022 as RDS Aurora's autoscaling option. Unlike v1, **it did not sleep at zero** (minimum 0.5 ACU). It scales ACU in 0.5-second increments to follow traffic. From August 2024, **Aurora Serverless v2 added scale-to-zero**, finally making it truly serverless.

Pricing: ACU (Aurora Capacity Unit, roughly 2GB RAM) at $0.12/hour. Cold start with scale-to-zero is around 15 seconds.

Aurora is not an edge DB in the strict sense, but it gives you the full RDS SQL surface and full transactional semantics while removing capacity management. Korea's **NHN Cloud** and **Kakao Enterprise** run Aurora-compatible services. Adopters include Slack, Robinhood, Samsung Electronics, and Roblox for large-scale operational DBs. In 2026 it's still the de facto standard for single-region transactional workloads.

20. CockroachDB Serverless — Distributed SQL Goes Serverless

CockroachDB was founded in 2015 by Spencer Kimball (formerly at Google, influenced by Spanner). It's a distributed SQL DB compatible with the Postgres wire protocol, offering multi-region strong consistency. CockroachDB Serverless was announced in 2021 and GA'd in 2022.

**CockroachDB Serverless pricing, May 2026**

| Item | Price |

|---|---|

| Free tier | 50M RU + 10GB storage + 1 region |

| RU (Request Unit) | $1.00 per 10M |

| Storage | $1.00/GB-month |

| Multi-region | Additional RU charges |

CockroachDB's strength is **true multi-region active-active** — writes in any region propagate to others with strong consistency, and a region failure triggers automatic failover. The weakness is cost: for the same workload, expect 2–3x more than a single-region Aurora.

In 2024 CockroachDB tightened the free tier and raised prices, dividing opinion among Korean and Japanese indie developers. But for global fintech, multinational SaaS, and game backends, it's almost impossible to replace. Adopters include DoorDash, parts of Netflix, Bose, Form3 (UK fintech), and Shipt.

21. Spanner — Google's Global SQL and PostgreSQL Interface

Spanner became public on GCP in 2017. It is Google's globally distributed SQL DB using the TrueTime API (atomic-clock-based clock sync) and Paxos consensus for multi-region strong consistency. It has 14 years of internal validation at Google, running core ad and payment systems.

The two biggest changes for Spanner in 2026 are **PostgreSQL Interface GA** (2023) and **Spanner Graph** (launched 2025). The PostgreSQL Interface lets you use Spanner with ANSI SQL plus Postgres dialect from the start; Spanner Graph supports SQL + graph queries in one system.

Pricing: $0.90/node-hour in US regions (the 2024 GA processing unit option offers finer granularity). Multi-region runs about 3x per node.

Spanner's strength is **proven global strong consistency and unlimited scale**. The weakness is cost and GCP lock-in. In Korea, **KakaoBank** is reportedly evaluating Spanner for some global workloads; in Japan, **LINE Yahoo** runs Spanner for ad inventory.

22. YugabyteDB, Cosmos for PostgreSQL, OrioleDB — Postgres-Compatible Distributed DBs

Beyond CockroachDB, multiple Postgres-compatible distributed DBs compete.

**YugabyteDB** — Founded in 2016 by Karthik Ranganathan (former Apache Cassandra at Facebook). PostgreSQL 11 compatible, with multi-region strong consistency. In 2024 the Yugabyte Cloud free sandbox closed; only a 14-day free trial remains. Strength: a battle-tested distributed storage layer from Cassandra heritage; weakness: slightly weaker Postgres compatibility than CockroachDB.

**Azure Cosmos DB for PostgreSQL** — Microsoft acquired Citus in 2022 and folded it into Cosmos DB. Emphasizes distributed Postgres sharding and hyperscale. Pricing starts at $0.27 per vCPU-hour. A natural choice for Microsoft-stack users.

**OrioleDB** — An open-source extension rewriting the Postgres storage engine as cloud-native (separated storage). In 2025 Supabase acquired OrioleDB and hired its core engineers; by 2026, Supabase Postgres ships it as a beta option. By bypassing the limits of the Postgres heap (WAL load, vacuum cost, freezing), it reports 5–10x throughput on the same workload.

OrioleDB is distinct because it's a **Postgres storage layer improvement** rather than a true distributed DB. Multi-region consensus still requires a separate layer (Patroni, a cache like Hyperdrive).

23. Momento — Truly Serverless Redis Alternative

Momento was founded in 2022 by Khawaja Shams (former AWS DynamoDB leader), claiming "more serverless cache than Redis." Compared to Upstash — Upstash is Redis-compatible; Momento offers its own API plus a Redis-compatible option.

Momento's differentiator is **zero fixed cost plus zero capacity planning**. Capacity scales automatically as traffic grows, and drops to zero when idle. Pricing: data transfer $0.50/GB (reads + writes combined), storage free.

In 2024 Momento GA'd **Momento Topics** (Pub/Sub) and **Momento Cache** (the main cache product); in 2025 it added a Storage (persistent K/V) beta. Adopters include The Wall Street Journal, Walgreens, Pulpify, and some AWS partner workshops.

Choosing between Momento and Upstash — if you already have Redis API compatibility and a working client, choose Upstash; if you want true zero-capacity management and pricing simplicity, choose Momento.

24. Drizzle ORM 0.40, Prisma 6 — The ORM Layer Competition

The rise of edge and serverless DBs reshaped the ORM landscape. Traditional Prisma (the standard of the early 2020s) ran a Rust-based query engine in a separate process — so it didn't work directly inside V8 isolates and was hard to use from Cloudflare Workers.

**Drizzle ORM**, released in 2022, builds the query builder in pure TypeScript and supports every driver (libsql, postgres-js, mysql2, planetscale, neon serverless), rapidly becoming the standard. As of May 2026, Drizzle 0.40 supports:

- TypeScript-first schema definitions (with automatic SQL DDL generation)

- D1, Turso, Neon, PlanetScale, Postgres, MySQL, SQLite, AWS Data API, Bun:sqlite

- Drizzle Kit (schema migration tool) and Drizzle Studio (GUI)

- Open-source even after Vercel acquired it in December 2025

**Prisma 6** (released September 2024) underwent a **Rust to TypeScript migration**, making it work on V8 isolates. In 2026 some drivers (D1, Cloudflare Workers) are not yet as smooth as Drizzle, but the schema-first development experience and rich ecosystem (Prisma Migrate, Prisma Studio, Prisma Pulse) remain strengths.

Choice: pick Drizzle if Workers and edge are first priorities; pick Prisma if standard Next.js with rich tooling is the goal. Drizzle share has grown sharply in both Korean and Japanese dev communities since 2024.

25. When Edge DBs Fit and When They Don't

Edge and serverless DBs aren't a universal solution. The selection criteria boil down to the following.

**Fits well**

- **Read-heavy global apps**: blogs, doc sites, marketing pages, social feed caches — Turso, D1, Hyperdrive

- **Single-region OLTP**: SaaS dashboards, payment transactions, user profiles — Neon, Supabase, Aurora Serverless

- **Full-stack reactive**: chat, live collab, game rooms — Convex, Supabase Realtime, Durable Objects

- **Global cache / rate limit**: Workers KV, Upstash Redis, Momento

- **Object storage + CDN**: R2, Tigris, Blob

- **AI embeddings / vector**: Upstash Vector, MongoDB Atlas Vector, pgvector on Neon/Supabase

**Doesn't fit**

- **High-write OLTP**: exchanges, ad-click logs, IoT telemetry — Aurora, Bigtable, or ClickHouse instead

- **Complex transactions + FKs + multi-step JOINs**: distributed SQL is universally slower than single-region RDBs — RDS/Aurora is the answer

- **PB-scale analytics**: BigQuery, Snowflake, ClickHouse, Databricks

- **Strong consistency + global**: pricey but essentially Spanner or CockroachDB only

The engineering question is "the read/write ratio of my workload, global vs. regional, consistency requirements." For more than 90 percent of SaaS, single-region Postgres + global cache (KV) is sufficient. Workloads that truly need global strong consistency are rare.

26. Pricing Comparison — Same Workload, Different Bills

A hypothetical workload — 10M API requests/month, average 5 reads + 1 write per request, 50GB stored, global users.

| Product | Estimated monthly cost | Notes |

|---|---|---|

| D1 + Workers (Paid) | $25–60 | 60M ops, all within Workers Paid bundle |

| Turso Starter | $29 + extras | 50M+10M = 60M rows fits Starter limit |

| Neon Launch + Workers | $19 + $5 (Workers) = $24 | Single-region Postgres, no cache |

| Supabase Pro | $25 | Fits 100K MAU limit |

| PlanetScale Scaler | $39 | 60M rows within limit |

| Aurora Serverless v2 (0.5 ACU avg) | ~$45 | 0.5 ACU × 720h × $0.12 |

| CockroachDB Serverless | $60–120 | 60M × 2 RU/request = 120M RU |

| DynamoDB On-demand | $40 | 60M reads + 10M writes |

The bill can swing 2–5x for the same workload. **For volatile traffic, scale-to-zero (Neon, Aurora v2)** wins; **for steady traffic, fixed plans (Supabase Pro, Turso Starter)** win. All prices as of May 2026; free-tier headroom and separate per-unit pricing may apply, so actual bills will differ.

27. Korean Adoption — Coupang, Toss, Daangn, NAVER, NHN Cloud

Database choices at major Korean companies as of 2026.

**Coupang** — DynamoDB used extensively for core order and delivery metadata. AWS + JVM stack consistency drives the choice. Aurora MySQL underpins almost all commerce master data. ElastiCache Redis covers sessions and real-time counters.

**Toss** — Core payments runs on self-managed Postgres + MySQL clusters. PlanetScale and BigQuery cover some analytics and experimentation workloads. Subsidiaries like Toss Securities and Toss Payments run their own stacks. Supabase and Neon adoption is widespread across side projects and experimental tools.

**Daangn Market** — Postgres + Redis at the core. PlanetScale powers search metadata; some global cache work being evaluated on Cloudflare KV. AI and vector workloads use pgvector + Pinecone.

**NAVER and NAVER Cloud** — Cubrid (in-house DB) + MySQL + Postgres. Cloud DB business sells managed PostgreSQL, MySQL, MongoDB, and Redis. Search and ads run on in-house distributed systems.

**NHN Cloud** — RDS-compatible (Postgres and MySQL) plus in-house distributed systems (Pinpoint, Dooray). Game Cloud DB for game backends.

Korean companies generally depend heavily on AWS (DynamoDB, Aurora, ElastiCache, OpenSearch), and edge DB adoption shows up most quickly in side projects and new SaaS startups.

28. Japanese Adoption — Mercari, LINE Yahoo, CyberAgent, DeNA

Database choices at major Japanese companies.

**Mercari** — Aurora MySQL + DynamoDB for core transactions. SQS + Lambda for notifications and queue workloads. Search runs on in-house ElasticSearch. AI recommendations rely on custom models with DynamoDB caching.

**LINE Yahoo (LY Corporation)** — Messaging runs on in-house distributed systems (custom NoSQL + Redis cluster). Spanner runs in a GCP Japan region for ad inventory and aggregations; Yahoo! ad systems use ClickHouse extensively.

**CyberAgent** — AbemaTV backend mixes CockroachDB and Aurora. Ad bidding uses in-house distributed KV plus DynamoDB. Each gaming subsidiary picks its own stack.

**DeNA** — Mobile game backends on Aurora + DynamoDB. Some horizontally sharded workloads on a self-managed Cassandra cluster. BigQuery + Vertex AI for AI recommendation.

**SmartNews** — News recommendations on DynamoDB + ElastiCache Redis + S3 + Athena. Content metadata on Aurora.

Japanese companies, like their Korean peers, use a lot of multi-cloud (AWS + GCP); Spanner and CockroachDB adoption for ad/media global workloads is more aggressive than in Korea.

29. Migration Scenarios — From Fauna to Convex or DynamoDB

The most common migration scenarios in 2025, driven by the Fauna shutdown, are as follows.

**Fauna to Convex**: a natural fit if the main use case was full-stack reactive apps. FQL becomes Convex TypeScript functions, Apollo Client stays for GraphQL dependencies, and Convex live queries replace real-time subscriptions.

**Fauna to DynamoDB**: for key-value/document workloads, DynamoDB wins on both cost and performance. Requires redesigning the data model around NoSQL access patterns. If global active-active is needed, Global Tables.

**Fauna to MongoDB Atlas Serverless**: keeps the document model, translates FQL into the MongoDB aggregation pipeline. The most straightforward 1:1 path.

**Fauna to CockroachDB or Spanner**: when strong consistency and global presence are the core needs. The downside is the paradigm shift to SQL.

After PlanetScale's free tier shutdown, the most common migration paths were **PlanetScale to Neon/Supabase** (for Postgres) or **PlanetScale to Aurora Serverless v2** (to stay on MySQL).

30. Outlook Beyond 2027 — AI Workloads and OrioleDB Will Reshape the Map

Predicting the 2–3 year trends from 2026:

**AI workloads redefine the data layer category** — competition between vector DBs (Pinecone, Weaviate, Qdrant) and pgvector-integrated Postgres (Supabase, Neon) intensifies. Multimodal embeddings, graph RAG, and embedded search converge in a single DB.

**OrioleDB and cloud-native Postgres storage engines standardize** — once Supabase-owned OrioleDB hits stable in 2027, a new generation of Postgres that bypasses heap limits (WAL load, vacuum, freezing) could become the standard.

**Edge DBs go full multi-write** — Turso and D1 are previewing multi-master writes; 2027 may bring true active-active edge DBs. CRDT-based sync engines become generalized.

**Database-as-Code standardizes** — tools like Drizzle Kit, Atlas, Snaplet, and Tinybird treat schema migrations, test data, and preview environments as code. DBs become first-class citizens in CI/CD pipelines.

**Pricing pressure resumes** — free-tier cleanups (Fauna, Xata, PlanetScale, Yugabyte) characterized 2024–2025, but from 2026 onward, intense competition is forcing prices back down. The DynamoDB on-demand price cut in November 2024 was the bellwether.

31. Conclusion — Workload Decides Everything

The world of edge and serverless DBs exploded in the six years after 2020. In 2024 and 2025 it saw the first category consolidation and shutdowns (Fauna, Xata, the Yugabyte free tier ending). As of May 2026 the market has settled into five large clusters.

1. **Cloudflare stack** — D1, Hyperdrive, KV, R2, Queues, DO. Workers-centric full stack.

2. **Postgres serverless cluster** — Neon, Supabase, Vercel Postgres, Aurora Serverless v2. The largest market.

3. **Edge SQLite** — Turso and D1. Optimal for global reads.

4. **Global distributed SQL** — CockroachDB, Spanner, YugabyteDB. Expensive but essential.

5. **Full-stack reactive** — Convex, Supabase Realtime. The new-paradigm opportunity.

The core engineering questions don't change — **read-heavy or write-heavy, global or regional, strong consistency needed, traffic volatility**. Answering these four questions honestly almost automatically determines which DB fits.

Finally, the most important lesson of 2026 — **ask "does my workload really need edge?" before adopting an "edge DB"**. For 90% of SaaS, single-region Postgres + global cache is enough. Even with global users, not every byte of data needs to be globally replicated. Honest workload analysis is the first step in reducing both cost and complexity.

References

- Cloudflare D1 official docs — https://developers.cloudflare.com/d1/

- Cloudflare Hyperdrive official docs — https://developers.cloudflare.com/hyperdrive/

- Cloudflare Workers KV — https://developers.cloudflare.com/kv/

- Cloudflare Durable Objects — https://developers.cloudflare.com/durable-objects/

- Cloudflare R2 — https://developers.cloudflare.com/r2/

- Turso official docs — https://docs.turso.tech/

- libSQL on GitHub — https://github.com/tursodatabase/libsql

- LiteFS (Fly.io) — https://fly.io/docs/litefs/

- PlanetScale official — https://planetscale.com/docs

- PlanetScale Hobby tier shutdown — https://planetscale.com/blog/planetscale-forever

- Neon official — https://neon.tech/docs

- Databricks acquires Neon announcement — https://www.databricks.com/blog/databricks-acquires-neon-helping-developers-deliver-ai-systems

- Supabase official — https://supabase.com/docs

- Supabase acquires OrioleDB — https://supabase.com/blog/orioledb-launch

- Convex official docs — https://docs.convex.dev/

- Fauna shutdown announcement — https://fauna.com/blog/announcing-the-end-of-life-of-fauna

- Xata roadmap change announcement — https://xata.io/blog/xata-postgres-saas-shutdown

- Tigris Data — https://www.tigrisdata.com/docs/

- Upstash Redis — https://upstash.com/docs/redis

- Upstash Vector — https://upstash.com/docs/vector

- Momento — https://docs.momentohq.com/

- Vercel Storage — https://vercel.com/docs/storage

- MongoDB Atlas Serverless — https://www.mongodb.com/docs/atlas/manage-clusters/

- DynamoDB pricing reduction (Nov 2024) — https://aws.amazon.com/about-aws/whats-new/2024/11/amazon-dynamodb-reduces-prices-on-demand-throughput/

- Aurora Serverless v2 scale to zero — https://aws.amazon.com/blogs/aws/amazon-aurora-serverless-v2-supports-scaling-to-zero-capacity/

- CockroachDB Serverless — https://www.cockroachlabs.com/docs/cockroachcloud/quickstart

- Spanner PostgreSQL interface — https://cloud.google.com/spanner/docs/postgresql-interface

- YugabyteDB — https://docs.yugabyte.com/preview/

- Azure Cosmos DB for PostgreSQL — https://learn.microsoft.com/en-us/azure/cosmos-db/postgresql/

- OrioleDB on GitHub — https://github.com/orioledb/orioledb

- Drizzle ORM — https://orm.drizzle.team/docs/overview

- Prisma 6 release notes — https://www.prisma.io/blog/prisma-6-release

- Standard Webhooks — https://www.standardwebhooks.com/