You measure latency in the lab on wifi and report it's fine. In the field, on a mobile connection that dips to 3G at the wrong moment, that comfortable 100 ms is 400, and 400 is the difference between a tap that converts and a thumb that moved on. Mini-programs live in borrowed-attention contexts — a super app, a chat, a feed — where any delay reads as "broken," not "loading." The bar is higher than the web ever was, and latency is the tax you pay on every interaction you don't optimize.

The three latency taxes

Connection setup. Every cold API call pays DNS, TCP, and TLS before a single byte of your data moves. On a mini-program that opens, calls home, and closes, that handshake can cost more than the payload. Do it repeatedly and the user is staring at a skeleton.

Redundant round trips. Your API waits on three downstream services, each its own round trip, before it answers. The client sees one slow call but the backbone saw four. That's latency you inherited, not latency you caused — but the user blames your mini-program either way.

No prefetch. The data the next screen needs isn't fetched until the user asks for it. In a low-bandwidth context, that "ask then wait" is the moment they leave.

Why mini-programs feel it worse

On the web a slow site is expected and tolerated. Inside a super app, the user is one swipe from ten alternatives that do the same thing. A mini-program that hesitates doesn't get the benefit of the doubt. Latency isn't a performance metric here; it's a churn event wearing a stopwatch.

What a runtime does that you can't alone

A host-owned runtime sits below every mini-program and attacks the tax at the source:

  • Connection reuse. One TLS session to the host's edge, shared across all mini-programs on the device, instead of every app negotiating its own. The handshake you were paying disappears.
  • Prefetch. The data the next screen needs is fetched the moment the current one renders — often before the tap.
  • Edge caching. Common responses live close to the user instead of across an ocean.
  • One optimized channel. A single tuned pipe beats a dozen per-app connections fighting for radio time.
TaxNaive mini-programRuntime-optimized
ConnectionNew TLS per callReused edge session
Round tripsSerial downstreamCollapsed at edge
Next-screen dataFetched on tapPrefetched on render
GeographyOrigin far awayEdge cache near user
Typical API latency350–600 ms80–180 ms

The tradeoff you accept

Prefetch wastes bandwidth when the user doesn't go to the next screen. Edge caching serves stale data if you cache the wrong thing. The honest move is to prefetch only what's likely and to set cache lifetimes by how fast the data actually changes — not to abandon the optimization because it isn't perfect.

The real read

Latency is the silent leak in mini-program economics. It doesn't show up as an error; it shows up as a user who never came back, and a conversion you booked but didn't collect. Measure it on the device your users actually hold, on the network they actually have, and let a runtime eat the handshake and the round trips. Every 100 ms you give back is a mini-program you finally get to monetize.

Sources