Neon vs Supabase in 2026: Branching, RLS & SaaS TCO
Engineering and 36-month TCO teardown of Neon vs Supabase in 2026: post-Databricks serverless Postgres vs dedicated BaaS VMs, copy-on-write branching, Turso vs Neon, Supavisor vs HTTP drivers, and RLS.

On this page

If you're building a Next.js, Node.js or AI-agent backend on PostgreSQL in 2026, you'll hit the Neon vs Supabase decision sooner or later. Some teams arrive at it as Supabase vs Neon, after outgrowing a Backend-as-a-Service bundle, and some as Turso vs Neon, when they're weighing edge SQLite against serverless Postgres. Whichever way you search it, the answer depends on duty cycle and auth more than on Postgres features.
Neon, which Databricks announced it would acquire in May 2025 when AI agents were already creating over 80% of new Neon databases, split PostgreSQL's compute from its storage. Stateless Compute Units (CUs) scale independently of multi-tenant Safekeepers and Pageservers backed by cloud object storage. That's what makes near-instant copy-on-write (CoW) branches and scale to zero possible. Neon's docs and pricing page now also carry Databricks' Lakebase Postgres branding. Supabase kept standard PostgreSQL on a dedicated instance per project and wrapped it in an open-source BaaS suite: Supabase Auth (GoTrue), Supavisor pooling, Elixir Realtime WebSockets, S3 Storage, Deno Edge Functions and PostgREST.
At Idealogic, our SaaS development, JavaScript development and custom software development teams run Neon, Supabase and owned AWS RDS clusters for regulated fintech and healthtech products. What follows is our 2026 teardown of both systems, where Turso fits, and a worked 36-month SaaS TCO model for 1,500 active B2B workspaces, 350 GB of PostgreSQL and pgvector state, and 25 CI preview branches.
The short version
- Serverless Postgres vs integrated BaaS. Neon is disaggregated serverless Postgres. You pair it with external auth (Clerk, Better Auth, or the enterprise SAML/SCIM providers compared in WorkOS vs Auth0) and a TypeScript ORM (Drizzle vs Prisma). Supabase is a dedicated Postgres instance with Auth, Realtime, Storage and PostgREST bundled in.
- Neon is the better fit for CI branching, bursty load and AI sandboxes. A copy-on-write branch of a 350 GB database appears almost instantly with close to zero duplicate storage, and idle dev or agent computes suspend to $0 after 5 minutes.
- Supabase is the better fit when you want warm caches and a fast MVP. Paid projects run 24/7, so there are no scale-to-zero cold starts, and under 100,000 MAUs you skip the Auth and Realtime integration work.
- Turso (
libSQL) is for micro-sharded SQLite. Pick it for sub-millisecond embedded reads or thousands of tiny per-tenant SQLite files. Stay on Neon or Supabase for full PostgreSQL joins,FORCE ROW LEVEL SECURITYandpgvector. - Sustained 24/7 scale favors owned RDS. At 8 sustained CUs (8 vCPU / 32 GB RAM), 350 GB of disk, 160k MAUs and 25 CI branches under SOC 2 controls, our model puts owned Multi-AZ AWS RDS Postgres 17 with PgBouncer and Drizzle at $63,000 over 36 months. That's $32,700 less than Supabase Team 2XL ($95,700) and $41,100 less than Neon Scale with external B2B auth ($104,100, before per-MAU auth vendor fees).
Neon vs Supabase architecture: disaggregated Pageservers vs dedicated Postgres VMs
Neon splits Postgres into stateless compute and a shared storage layer, while Supabase gives each project one dedicated Postgres instance with its own disk. That one difference explains most of the Neon vs Supabase trade-offs: how branches get made, what happens when a database sits idle, and how the Write-Ahead Log (WAL) and RAM caches behave under production load.
1. Neon (a Databricks company): stateless Compute Units, Safekeepers & CoW database branching
Standard PostgreSQL ties its query executor and shared_buffers cache to a local block disk, which makes cloning 350 GB slow and expensive. Neon splits Postgres across three tiers:
- Stateless compute nodes (CUs). One CU is 1 vCPU plus 4 GB RAM. On Scale, autoscaling goes up to 16 CU and fixed sizes up to 56 CU (224 GB RAM), per Neon's plans page. Compute holds no authoritative state, so Neon autoscaling resizes CPU and RAM without a restart, and idle dev or preview computes suspend to 0 CU after 5 minutes.
- Paxos consensus Safekeepers. Committed WAL records stream to redundant Safekeepers, which reach quorum before acknowledging
COMMIT. Your data survives even if a compute VM dies mid-query. - Pageservers and object storage. Safekeepers ship WAL to Pageservers. These materialize 8 KB Postgres pages on demand, compact immutable layers into cloud object storage, and serve reads back to compute through a local NVMe Local File Cache (LFC).
Pageservers store immutable log-structured deltas, so Neon database branching behaves like git checkout -b on live data. Creating a child branch records a Log Sequence Number (LSN) pointer, which Neon's docs describe as instant. Production and 25 pull-request branches share every unchanged parent block, and you pay storage ($0.35 per GB-month) only for the bytes a branch changes. The same primitive is behind AI agent sandboxes, migration checks in CI and instant Point-in-Time Restore (PITR).
The cost is cold starts. A suspended compute wakes within a few hundred milliseconds, and the first queries after that fetch pages over the network from Pageservers until shared_buffers and the LFC warm up. In practice, production B2B APIs turn scale to zero off on main (a minimum of 2 or 4 CU) and leave it on for preview and staging branches.
2. Supabase: dedicated Postgres VMs + open-source BaaS mesh
Supabase runs unmodified PostgreSQL on a dedicated single-tenant instance per project. Sizes start at the shared-CPU Micro (1 GB RAM, $10/mo, covered by the Pro/Team $10 credit) and run through dedicated-vCPU Large (2 vCPU / 8 GB, $110/mo), XL (4 vCPU / 16 GB, $210/mo) and 2XL (8 vCPU / 32 GB, $410/mo), up to 16XL (64 vCPU / 256 GB).
Around that instance Supabase bundles the rest of a backend: PostgREST for instant HTTP and GraphQL APIs, Supabase Auth (auth.users lives in your Postgres catalog, with 100,000 MAUs included on Pro and Team), Elixir Realtime over WAL, S3 Storage and Deno Edge Functions. We compare that bundle with Firestore in Supabase vs Firebase and with deterministic reactive TypeScript sync in Convex vs Supabase.
What you give up is elastic resizing and copy-on-write branching. Changing compute size restarts the database, usually for under 2 minutes and sometimes longer, and there's no vertical CPU autoscaler. Supabase Branching boots a separate Micro VM per Git branch and runs migrations/*.sql plus seed.sql. It doesn't share your 350 GB of production blocks.
Turso (libSQL) vs Neon: edge-replicated SQLite vs serverless Postgres
Turso vs Neon comes up whenever a team looks at serverless databases for Edge runtimes or AI agents. The choice is between micro-sharded SQLite (libSQL) and one unified PostgreSQL 17 database.
Turso sells a hosted version of libSQL, an open-source SQLite fork that adds HTTP and WebSocket transport, native vector columns (F32_BLOB) and embedded local replicas inside Node, Rust, Go or mobile apps. The Developer plan is about $4.99/mo billed annually for 9 GB of storage and 2.5B row reads. Scaler is about $24.92/mo annual, or $29/mo monthly, for 24 GB and 100B row reads. Both include unlimited databases with no per-database fee, which is why database-per-tenant isolation, where each workspace or agent gets its own SQLite file, is cheap on Turso.
Across multi-tenant SaaS reviews, our Turso vs Neon rule is simple:
- Pick Turso (
libSQL) when each tenant owns small, isolated state (5 MB to 2 GB), you don't need cross-tenant SQL joins, sub-millisecond local reads matter, or you manage thousands of mostly dormant agent memory files. Unlimited SQLite databases with no idle fee beat dedicated Postgres clusters there. - Pick Neon or Supabase PostgreSQL when concurrent transactional writes hit SQLite's single-writer lock, or when you need one ACID relational catalog for financial
NUMERICledgers,SELECT ... FOR UPDATE SKIP LOCKEDqueues,TSTZRANGEconstraints, recursive CTEs,pgvectorHNSW joins and centralized data pipelines.
Neon vs Supabase connection pooling and Supabase row level security portability
Both vendors pool connections in transaction mode, Neon through built-in PgBouncer and Supabase through Supavisor, and both will leak tenant context if you set it per session. So when you run Vercel Functions, AWS Lambda or Cloudflare Workers against Postgres, two things can go wrong in production: you exhaust TCP/TLS sockets, or the transaction pooler leaks Row-Level Security state between tenants.
- Neon transport. Neon's serverless driver (
@neondatabase/serverless) gives youneon()over HTTPfetch()for single-round-trip Edge queries, andPool/Clientover WebSockets for interactiveBEGIN ... COMMITORM transactions. Behind it sits Neon's built-in PgBouncer, which accepts up to 10,000 client connections in transaction mode. - Supabase transport. PostgREST (
supabase-js) runs over HTTPS and injects JWT claims for you. Backend Node.js and Next.js ORMs connect through Supavisor on port 6543 (transaction mode) or port 5432 (session mode).
Hardcoding Supabase Row-Level Security helpers like auth.uid() ties your SQL migrations to Supabase Auth, which is vendor lock-in. The opposite mistake is just as bad: a session-level SET app.workspace_id over Neon's -pooler endpoint or Supavisor :6543 leaks tenant state across pooled sockets. We write standard PostgreSQL Row-Level Security (RLS) with Drizzle ORM RLS (pgPolicy) and a transaction-local set_config(..., true) instead.
The schema side comes down to four decisions:
Wrap every query in db.transaction so PostgreSQL resets app.workspace_id on COMMIT or ROLLBACK. We keep one small helper, withWorkspaceRls, that validates the workspace ID as a UUID, opens a transaction, sets app.workspace_id with a transaction-local set_config(..., true), and then runs the caller's queries. On Neon it sits on the WebSocket Pool; on Supabase Supavisor :6543 or RDS PgBouncer you swap the driver to drizzle-orm/node-postgres with pg.Pool, or postgres-js with { prepare: false }, and the helper itself doesn't change. Callers pass a workspace ID they've already verified against the session, and every query inside sees only that tenant's rows.
Add ALTER TABLE workspace_documents FORCE ROW LEVEL SECURITY; to your migrations so table-owner roles can't bypass isolation in staging (see our multi-tenant SaaS architecture guide).
Neon vs Supabase cost: worked 36-month SaaS TCO for 1,500 workspaces
A 36-month Neon vs Supabase TCO for 1,500 B2B workspaces comes to about $104,100 on Neon Scale with external auth and $95,700 on Supabase Team 2XL, against $63,000 on owned AWS RDS. Those totals assume 8 vCPUs sustained 24/7, and they move a lot with duty cycle and auth pricing, so check the assumptions first:
- Workload: a SOC 2 Series A/B B2B SaaS with 1,500 active workspaces, 160,000 MAUs and 8 Compute Units (8 vCPU / 32 GB RAM) sustained 24/7.
- Data: 350 GB of primary PostgreSQL 17 and
pgvectorstate, 75 GB/mo of 7-day restore history and 555 GB/mo of uncached egress. - 25 CI preview branches, open all month (160 combined branch CU-hrs/mo on Neon). Real preview branches are short-lived and billed hourly, so this is Supabase's worst case.
- Auth on Option A is an illustrative $650/mo budget that leaves out per-MAU vendor list fees (see the note under Option A).
- Option C runs on a 4 vCPU / 32 GB RDS instance: half the vCPUs of Options A and B, the same RAM.
- Vendor prices are November 2026 list prices.
Engineering labor uses Idealogic's $75/hr senior CEE rate against a $165/hr US rate. For context on that gap, see the Eurostat hourly labor cost dataset (lc_lci_lev) and the O*NET occupation profile for Software Developers (15-1252.00).
- Option A: Neon Scale serverless Postgres + external B2B auth
- Initial setup (80 hrs at $75/hr = $6,000): Drizzle schema,
FORCE RLS, Neon CoW GitHub Actions CI and external SSO sync. - Neon Scale DB ($1,475/mo = $53,100 over 36 months): SOC 2 and HIPAA features are on Scale ($0.222/CU-hr, 25 branches included, per Neon's plans page). 5,840 prod CU-hrs (8 x 730) plus 160 preview CU-hrs is 6,000 CU-hrs x $0.222 = $1,332.00/mo. Add 350 GB x $0.35 = $122.50 storage (branches add no copy cost), 75 GB x $0.20 = $15.00 instant-restore history and 55 GB x $0.10 = $5.50 egress (500 GB included), and you get $1,475/mo. A startup that doesn't need SOC 2 yet pays $801.50/mo on Neon Launch, including $22.50 for 15 branches above Launch's 10-branch allowance.
- External auth & realtime ($650/mo = $23,400 over 36 months): an illustrative budget for 1,500 B2B orgs, 160k MAUs and managed WebSockets (see Clerk vs Auth0). Fair warning: list prices can run far higher. Clerk's Pro plan is $25/mo with 50,000 users included and $0.02 per extra monthly retained user, so 160,000 users is about $2,225/mo before SSO add-ons. That alone would lift Option A to roughly $160,800. With 8 hrs/mo of ops ($21,600), the modeled total is $104,100.
- Initial setup (80 hrs at $75/hr = $6,000): Drizzle schema,
- Option B: Supabase Team (SOC 2) + 2XL dedicated compute + overages
- Initial setup (64 hrs at $75/hr = $4,800): the fastest v1, because Auth, Storage and Realtime come bundled.
- Supabase Team DB & branching ($1,375/mo = $49,500 over 36 months): Team ($599/mo) + 2XL compute (8 vCPU / 32 GB, $410 less the $10 credit = $400/mo) + 342 GB disk overage ($42.75) and provisioned IOPS ($32.25, subtotal $75/mo) + 25 preview VMs open all month (about $10/mo each for Micro compute and seeding, $250/mo) + 305 GB uncached egress ($27.45) and CDN overages ($23.55, subtotal $51/mo). Before SOC 2, the $25/mo Pro plan drops this to $801/mo.
- MAU overages & PITR ($325/mo = $11,700 over 36 months): 60k extra MAUs (60,000 x $0.00325 = $195/mo) + 7-day PITR ($100/mo) + SMTP ($30/mo). With 11 hrs/mo of Supavisor and seed ops ($29,700), the total is $95,700.
- Option C: owned AWS Multi-AZ RDS PostgreSQL 17 + HA PgBouncer + Drizzle RLS (Idealogic)
- Initial setup (120 hrs at $75/hr = $9,000): Terraform IaC, RDS, PgBouncer, self-hosted auth and
FORCE RLS. - Owned cloud DB & hybrid CI ($600/mo = $21,600 over 36 months): a 1-year Reserved Multi-AZ
db.r7g.xlarge(4 Graviton3 vCPUs / 32 GB RAM, about $465/mo; check current AWS RDS for PostgreSQL pricing for your region) + 350 GB Multi-AZ gp3 and 7-day PITR (about $95/mo) + masked Neon Launch or Testcontainers PR sandboxes ($40/mo). If you need 8 vCPUs, adb.r7g.2xlargeroughly doubles the instance line (about $16,700 more over 36 months). - Self-hosted Better Auth + Redis/WebSocket pods ($150/mo = $5,400 over 36 months, no per-MAU fee): with 10 hrs/mo of ops ($27,000), the total is $63,000, in line with our cloud migration cost benchmarks.
- Initial setup (120 hrs at $75/hr = $9,000): Terraform IaC, RDS, PgBouncer, self-hosted auth and
The duty-cycle crossover: when Neon flips cheaper than Supabase
Option A's DB bill ($53,100) is higher than Option B's ($49,500) for one reason: we modeled 8 CU running flat out, 24/7. It doesn't take much idle time to flip the Supabase vs Neon comparison. Neon's non-compute charges come to $143/mo, so its database bill matches Supabase's $1,375 at about 5,550 CU-hrs, roughly 92% of the modeled 6,000. Below about 85% to 90% sustained utilization, Neon is the cheaper of the two.
Take average utilization down to one-third (a regional EU B2B SaaS that's idle overnight, or an AI-agent platform averaging 2,000 CU-hrs/mo across 6,000 scale-to-zero sandboxes). Neon Scale compute falls from $1,332/mo to $444/mo, which cuts Neon's 36-month DB spend by $31,968 while Supabase's dedicated 2XL stays fixed. At continuous 24/7 load past Series A, owned Reserved Multi-AZ RDS beats both.
Teams moving to AWS also weigh Amazon Aurora PostgreSQL Serverless v2 ($0.12 per ACU-hour, standard configuration) against Reserved Multi-AZ RDS. Aurora separates compute from six-way replicated storage much like Neon does, though without Neon's branch-per-PR workflow. The catch is price: 16 sustained ACUs (32 GB RAM) cost $1,401.60/mo before I/O or storage charges, about triple the roughly $465/mo for a 1-year Reserved db.r7g.xlarge Multi-AZ pair. Unless you need cross-region failover through Aurora Global Database or storage that auto-expands to 128 TB, we'd take Reserved Multi-AZ RDS PostgreSQL 17 with HA PgBouncer and masked Neon Launch CI branches. For terabyte-scale local NVMe OLTP and Neki sharding, see PlanetScale vs Neon.
2026 PostgreSQL build & hybrid migration costs (CEE vs US)
Our custom software development and JavaScript development teams deliver fixed-milestone PostgreSQL builds at a blended senior CEE rate of $75/hr, against US agency benchmarks of $165/hr:
Inside the worked 840-hour ($63,000 CEE vs $138,600 US) Postgres build & RDS graduation
The $63,000 here is the price of the 840-hour migration build, a separate figure from the $63,000 36-month run cost of Option C above.
- 1. Schema,
pgvector& portableFORCE RLS(30% / 252 hrs / $18,900 CEE vs $41,580 US): We replace vendorauth.uid()helpers with portablecurrent_setting('app.workspace_id', true)policies, then add B-Tree/HNSW indexes and BOLA test suites. - 2. Zero-downtime logical CDC (
PUBLICATION/SUBSCRIPTION) (25% / 210 hrs / $15,750 CEE vs $34,650 US): WAL streams from Neon or Supabase into Multi-AZ RDS Postgres 17 with sequence sync and a cutover under 30 seconds. - 3. HA PgBouncer, Auth decoupling & Realtime port (20% / 168 hrs / $12,600 CEE vs $27,720 US): Password hashes migrate without forcing resets. This phase also covers transaction-pooled Drizzle wrappers and the S3 bucket policy cutover.
- 4. Masked Neon CoW CI branching & Terraform IaC (15% / 126 hrs / $9,450 CEE vs $20,790 US): Anonymized snapshots sync to Neon Launch for near-instant PR branches while production runs on Reserved Multi-AZ RDS.
- 5. OpenTelemetry spans, failover &
k6validation (10% / 84 hrs / $6,300 CEE vs $13,860 US): Multi-AZ failover drills,pg_stat_statementsP99 alerts and 500-RPSk6load tests.
Teams treat Neon vs Supabase as a permanent choice. It isn't, as long as you keep your PostgreSQL portable. Ship your MVP fast on Supabase if you want bundled Auth and Realtime, or on Neon if your CI pipeline and AI agents depend on near-instant copy-on-write branches. Write standard Drizzle migrations and transaction-scoped SET LOCAL Row-Level Security from day one, and moving your 24/7 production cluster onto Reserved Multi-AZ RDS later takes a logical replication slot, not a codebase rewrite.
Shipped Idealogic PostgreSQL proof & 5-step CTO checklist
Idealogic runs multi-tenant PostgreSQL in production:
- PostgreSQL +
pgvectorAI SaaS (Pressmerit): Next.js, NestJS, PostgreSQL andpgvectorsemantic matching across 26 industries under strict GDPR controls. - ISO 27001 B2B isolation (Chaindoc): Shipped in 22 weeks across 500+ organizations and 10,000+ signed agreements at 99.9% uptime.
- HIPAA & GDPR clinical sync (AddMed): Idempotent
HL7 v2andFHIR R4synchronization with zero data incidents.
Settling Neon vs Supabase for your own product takes five checks:
- Building an AI-agent platform, a bursty SaaS (sustained load under roughly 85% of provisioned compute), or a PR-heavy monorepo that needs near-instant full-data branches? Pick Neon with Drizzle ORM and
@neondatabase/serverless. - Shipping a full-stack MVP that needs bundled Auth, Realtime and S3 Storage under 100k MAUs? Pick Supabase Pro, and write portable
set_configRLS policies from the start. - Provisioning thousands of tiny per-tenant databases or sub-millisecond embedded Edge reads, with no cross-tenant SQL joins? Evaluate Turso (
libSQL). - Sustaining 8+ vCPUs 24/7, 300 GB+ of storage and 150k+ MAUs under SOC 2 or HIPAA? Move production to owned Multi-AZ AWS RDS Postgres 17 with HA PgBouncer, and keep a masked Neon Launch project for CI preview branches.
- Want hard numbers on your own queries? Contact our architecture team to book a 3-week PostgreSQL Audit Sprint.

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.
Frequently asked questions
It depends on what you want the vendor to own. Neon is serverless PostgreSQL only: instant copy-on-write database branching for CI previews, scale to zero for bursty or AI-agent workloads, and a clean fit with Drizzle ORM plus an external identity provider such as Clerk or WorkOS. Supabase is a Backend-as-a-Service. You get a dedicated Postgres instance with Supabase Auth, Realtime WebSockets, S3-compatible file storage and auto-generated PostgREST APIs under one dashboard.
Databricks announced its intent to acquire Neon in May 2025, when AI coding agents were already creating over 80 percent of new Neon databases. Since then Neon has cut storage to $0.35 per GB-month and moved to usage-based Launch ($0.106 per CU-hour) and Scale ($0.222 per CU-hour) plans with no monthly minimum. Scale includes SOC 2, HIPAA and private networking. You'll also see Lakebase Postgres branding in Neon's docs and pricing pages now.
Neon separates stateless PostgreSQL compute from a multi-tenant storage layer built on Safekeepers and Pageservers. A new branch is a metadata pointer against the parent's copy-on-write pages, so it appears almost instantly and doesn't duplicate your 350 GB dataset. Idle preview computes suspend to zero after five minutes. Supabase Branching works differently: each preview environment gets its own Micro or larger instance and replays your SQL migrations and seed files. It doesn't share production storage pages.
Supabase runs every paid project on a dedicated PostgreSQL instance that stays warm around the clock. Only Free projects pause. That means no cold starts and no buffer-cache rehydration after idle periods. On cost, the 2XL compute add-on ($410 per month less the $10 plan credit) only undercuts Neon Scale when load stays above roughly 85 to 90 percent of 8 vCPUs and 32 GB RAM all month. Below that, Neon's per-CU-hour billing is cheaper.
Neon bills usage with no monthly minimum: $0.106 per CU-hour on Launch, $0.222 on Scale, plus $0.35 per GB-month of storage. Supabase charges a fixed plan fee ($25 Pro, $599 Team) plus a dedicated compute add-on. In our model of 8 vCPUs running 24/7 with 350 GB, the database bills land close: $1,475 a month on Neon Scale against $1,375 on Supabase Team 2XL. At partial load Neon is cheaper, and at one-third utilization it's about $587.
Turso and Neon solve different problems, even though both sell serverless scale to zero. Turso is built on libSQL, an open-source fork of SQLite. It's good at sub-millisecond local reads from embedded replicas and at database-per-tenant setups with thousands of small SQLite files, on plans from about $4.99 to $29 per month. Neon runs full ACID PostgreSQL 17 with native Row-Level Security, analytical joins, triggers, extensions and pgvector HNSW indexes in one relational catalog.
Neon's built-in PgBouncer pooler and Supabase's Supavisor on port 6543 both multiplex thousands of serverless requests across a small pool of backend PostgreSQL connections in transaction mode. If you run a session-level SET app.current_org_id outside a transaction, that tenant state leaks onto the next request sharing the socket. The fix is to call SELECT set_config with the third argument set to true inside an explicit BEGIN and COMMIT block.
Serverless CU-hour rates, the Team plan fee, per-MAU authentication overages above 100,000 users and egress fees add up as load becomes continuous. Once you sustain 8 or more vCPUs across 300 GB to 500 GB of state, owned Multi-AZ AWS RDS PostgreSQL 17 with Reserved Instances, HA PgBouncer and Drizzle ORM cuts modeled three-year infrastructure and platform TCO by $32,700 to $41,100. You also get full control of the VPC, KMS keys and parameter groups.
At Idealogic's $75 per hour senior Central and Eastern European rate (versus $165 per hour for US agencies), a 3 to 4 week Postgres Architecture and RLS Audit Sprint costs $18,000 to $25,000. A greenfield multi-tenant Neon or Supabase foundation costs $27,000 to $45,000. A zero-downtime logical replication migration onto owned Multi-AZ AWS RDS or Aurora runs $45,000 to $84,000, with a worked 840-hour midpoint of $63,000.
More from the journal

Merge vs Paragon in 2026: Unified API, Embedded iPaaS & TCO
Engineering and 36-month TCO comparison of Merge.dev vs Paragon vs Nango in 2026: per-linked-account vs per-tenant billing at 800 connections, Common Models vs ActionKit, an AWS KMS envelope OAuth2 vault on PostgreSQL FORCE RLS, and itemized payback math.

Payload vs Strapi in 2026: Next.js, Drizzle RLS & CMS TCO
Payload vs Strapi in 2026, with Directus and Sanity: the MIT license after Payload joined Figma, the Next.js Local API overrideAccess default, PostgreSQL row-level security, and a modelled 36-month TCO for 35 seats.

Medusa vs Shopify Plus vs Vendure in 2026: Commerce & TCO
Engineering and 36-month TCO teardown of Medusa vs Shopify Plus vs Vendure in 2026: Medusa v2 Workflows SDK vs NestJS GraphQL vs Shopify Plus variable GMV and third-party gateway fees, B2B pricing, and owned commerce math.