The native-versus-web war is over, and native won it on paper. Smoother animations, deeper OS hooks, background execution, offline-first by default. Nobody serious disputes that a well-built native app feels better than a web page. The problem is that native also lost the only battle that funds the war: the install.

The install wall got taller

Look at the home screen of a typical phone. It hasn't changed in months. Users added a handful of apps years ago and stopped. Every new native app now competes for a slot against inertia, a crowded store, a permission parade, and a 40–150 MB download on a metered connection. Most lose before they're opened once.

A mini-program asks for none of that. It opens from inside an app the user already trusts, with their identity and payment already settled. The "download" is a few hundred KB, if that, and there's no icon to earn. That's not a worse experience. For most use cases it's the only experience the user will accept.

The performance gap narrowed to a sliver

This used to be the easy native win. It isn't anymore. A modern mini-program runtime — pre-warmed engine, shared core, native bridges for the heavy bits — gets you 90% of the native feel at a fraction of the build and distribution cost. The last 10% is real but narrow: sustained heavy 3D, constant background work, and deep hardware integration. If your app is a console-grade game or a health monitor streaming Bluetooth, native still wins outright. If it's commerce, content, or a service, the gap stopped mattering to the user.

When native is still the right call

Don't let the pendulum swing too far. Native earns its keep when:

  • you need background execution the OS won't grant a sandboxed page;
  • you're pushing the GPU for minutes at a time, not seconds;
  • you depend on offline-first behavior with no network fallback;
  • you need Bluetooth, health, or NFC depth a runtime bridge doesn't expose yet.

Pretending a mini-program beats native at those is how teams ship something that stutters exactly where it can't.

DimensionNative appMini-program
Install frictionHigh (store, permissions, size)Near zero (in-app open)
First openAfter download + accountImmediate, identity reused
Peak performanceBest90% for most workloads
Build costPer-platformOne codebase
Background / offlineStrongLimited
DistributionYou fight for itHost's shelf

The rebuild tax is the real cost

Here's what nobody prices into the "just build native" decision: you build iOS, then Android, then maybe a web fallback, and you maintain three. A universal runtime flips that — one mini-program, many hosts, no per-platform rewrite. The distribution advantage is real, but the build leverage is where the money actually shows up.

The honest take

Native didn't lose because it's worse. It lost because users stopped installing, and no amount of smooth scrolling recovers an app that was never downloaded. Mini-programs didn't win on quality. They won on the only metric left: did it open? Build native where the hardware demands it, and reach everyone else where they already are.

Sources