logo-kreta-white
The Edge Runtime Delusion: Why Distributed Compute Breaks Relational Reality
Tara

The Edge Runtime Delusion: Why Distributed Compute Breaks Relational Reality

2026-11-12

Explore industry news, expert advice, and creative strategies to keep your website ahead of the curve.

Continue exploring ideas in web design and beyond.

Back to Blogs

Edge compute near user, DB pinned single region. Physics wins: cross-continent TCP roundtrips crush latency, pool exhaustion kills serverless edge workers.

The Edge Runtime Delusion: Why Distributed Compute Breaks Relational Reality

Edge computing is the current darling of infrastructure marketing. The pitch is seductive: run your code in hundreds of data centers worldwide, get your logic as close to the user as physically possible, and watch latency numbers drop into single-digit milliseconds. Vercel, Cloudflare, and AWS all sell variations of this vision. Conference talks abound. Twitter threads declare the origin server dead.

We at Kreasi Kita call this the edge runtime delusion, and it deserves a direct rebuttal: for database-heavy applications — which is to say, most real business applications — edge compute is not an optimization. It is a regression dressed up in a latency dashboard.

The core problem is simple and physical. Edge runtimes move compute near the user, but your relational database stays pinned in a single region. You cannot shard Postgres across six continents without destroying the transactional guarantees that made you choose Postgres in the first place. So the edge worker executes your business logic in Singapore, then reaches across the ocean to a database in Virginia. You have moved the bottleneck, not removed it. Physics wins. It always does.

The Architecture Nobody Draws in the Marketing Slides

Edge computing diagrams show users connecting to nearby PoPs, glowing lines, happy arrows. What the diagrams omit is the backend reality: nearly every meaningful request needs database access, and that database lives in one place.

Edge Runtime Delusion:

User (Jakarta) ──▶ Edge PoP (Singapore) ──▶ Origin DB (us-east-1, Virginia)
                    ~10ms RTT                  ~200-250ms RTT

Colocated Reality:

User (Jakarta) ──▶ App server (Singapore) ──▶ Postgres (Singapore)
                    ~10ms RTT                  ~1-2ms RTT

In the edge model, the roundtrip that matters is not user-to-edge. It is edge-to-database. A TCP roundtrip from Singapore to us-east-1 is roughly 200–250ms — and a single database query typically requires at least one roundtrip, often several when connection setup, TLS handshakes, and multi-statement transactions are involved. A request that touches the database three times can spend the better part of a second just waiting on wire propagation.

Compare that to colocating application servers with Postgres in the same data center. Intra-region roundtrips measure in single-digit milliseconds. The user in Jakarta gets a slower hop to Singapore (~10–30ms) but a fast path to data. Total request latency drops dramatically — not because we moved compute closer to the user, but because we moved compute closer to the data.

This is the inversion the edge hype misses: for stateful applications, data locality beats user locality.

Edge Computing vs Origin Server: The Latency Math

Let's be precise about what each hop costs. These are representative figures based on publicly documented network characteristics, not fabricated benchmarks — treat them as order-of-magnitude planning numbers for a hypothetical architecture.

ScenarioUser → ComputeCompute → DBQueries per requestApprox. added DB latency
Colocated app + Postgres (same region)10–30ms1–2ms3~3–6ms
Edge runtime, DB in single region5–10ms200–250ms3~600–750ms
Edge runtime + regional read replica5–10ms50–80ms3~150–240ms

The edge model loses by two orders of magnitude on any request that touches the database. Even the read-replica mitigation — which introduces its own consistency problems, since replicas lag the primary — cannot close the gap. And read replicas do nothing for writes. Your checkout flow, your booking transaction, your user registration: all writes, all hitting the primary, all paying the cross-continent toll.

Edge runtimes do win on one class of workload: stateless, cacheable, database-free logic. Personalization at the CDN layer, A/B header routing, static content, geolocation-based redirects. But that is not "edge computing replacing your backend." That is a CDN doing CDN things — which we wholeheartedly endorse, and which you do not need a new compute paradigm to achieve.

Connection Pooling: Where Serverless Edge Falls Over

Latency is only half the story. The other half is connection management, and it is where edge and serverless architectures genuinely break under load.

Relational databases are built around long-lived, authenticated connections. Postgres connections are expensive: each one is a backend process with its own memory footprint. A typical Postgres instance comfortably handles a few hundred concurrent connections before performance degrades. This is why connection poolers like PgBouncer and Prisma's PgBouncer-backed modes exist — they multiplex thousands of application requests over a small, fixed set of database connections.

Now consider the edge runtime model:

  • Every isolate is a separate process. Edge platforms spin up thousands of short-lived worker instances across dozens of PoPs. Each one wants its own database connection.
  • Pooling at the edge is fundamentally broken. A pool in a Singapore isolate is useless to an isolate in Frankfurt. You cannot share connection state across a globally distributed fleet.
  • Cold starts multiply connections. Burst traffic spawns new isolates, each opening fresh TCP + TLS + Postgres authentication handshakes — three-plus roundtrips to a database that is already an ocean away.

The result, under sustained load, is predictable: connection pool exhaustion, FATAL: too many connections errors, cascading retries that amplify the storm, and an origin database spending its CPU on connection churn instead of serving queries. Teams hit this wall and respond by bolting on HTTP-based database proxies, regional poolers, and caching layers — at which point they have rebuilt a traditional regional backend, badly, with more moving parts.

The honest conclusion: if your workload is database-heavy, the edge runtime is solving a problem you do not have while creating several you do.

What Conventional Wisdom Gets Wrong

"Latency to the user is the only latency that matters." No. End-to-end request latency is the sum of every hop. Moving compute 20ms closer to the user while adding 200ms between compute and data is a net loss. Optimize the dominant term, which for stateful apps is the database hop.

"Edge runtimes scale infinitely." They scale compute. Your Postgres primary does not scale infinitely, and it is the thing your edge fleet is hammering. Distributed compute in front of a centralized, transactional database is not a distributed system — it is a denial-of-service architecture against your own origin.

"Just add caching." Caching is valuable and we use it aggressively, but cache invalidation for transactional data across a global fleet is a hard, unsolved-in-practice problem. Stale inventory counts, stale session state, stale authorization data — these are correctness bugs, not performance trade-offs.

"The biggest companies do it, so should you." Hyperscalers running edge compute also run globally partitioned databases with bespoke coordination layers, eventual-consistency trade-offs their product teams spent years engineering around, and budgets to match. Copying their topology without their supporting architecture is cargo-culting.

The Kreasi Kita Position

Our stance is unambiguous, and we apply it on every project:

  1. Keep business logic colocated with your relational database. A well-sized dedicated VPS or regional cloud instance running your application next to Postgres gives you millisecond data access, sane connection pooling, and full transactional semantics. This is the architecture that has powered reliable backends for decades, and no marketing cycle has invalidated it.

  2. Use the edge for what edges are good at. Standard CDN caching for static assets, images, and cacheable API responses. TLS termination at the edge. Geographic routing. This delivers the user-facing latency wins without corrupting your data architecture.

  3. Scale vertically first, then regionally. Postgres on capable hardware goes remarkably far. When you outgrow a single node, add read replicas in-region before you consider anything exotic. Cross-region distribution is a product decision with consistency costs, not a default.

  4. Measure end-to-end, not hop-by-hop. Judge architectures by p95 and p99 full-request latency under realistic load — including database roundtrips — not by the shiny number on the edge provider's dashboard.

Edge runtimes are a tool with a narrow, legitimate scope. The delusion is treating them as a replacement for the origin server. For database-heavy applications, the origin server — sitting next to your database — remains the correct place for your compute. That is not conservatism. It is physics, plus connection pooling, plus transactional integrity.

Build on Solid Ground

If you are evaluating an edge migration, or designing a backend that will not fall over under real traffic, we would rather talk physics with you than sell you a paradigm. Kreasi Kita architects robust, database-first backends for founders, CTOs, and product leaders who care about p99 more than press releases. Bring us your hardest workload — start the conversation at Kreasi Kita.<p class="blog-internal-links">For the implementation path, explore our <a href="/services/web-development">web development with a deliberate runtime architecture</a>. Continue with <a href="/blog/serverless-tax-why-we-choose-vps-docker">when VPS and Docker are a better operational fit</a>.</p>

●Kreasi Kita Engineering & Design

Ready to build a high-performance web experience?

We engineer modern, ultra-fast websites and custom web applications with Next.js, tailored UI/UX design, and zero bloat.

Start a Conversation

More articles