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.
| Dimension | Native app | Mini-program |
|---|---|---|
| Install friction | High (store, permissions, size) | Near zero (in-app open) |
| First open | After download + account | Immediate, identity reused |
| Peak performance | Best | 90% for most workloads |
| Build cost | Per-platform | One codebase |
| Background / offline | Strong | Limited |
| Distribution | You fight for it | Host'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
- MDN — Progressive web apps — the install-light model that narrowed the gap with native.
- DataReportal — Digital 2026 — mobile behavior data behind falling app-install willingness.
- StatCounter — Mobile market share — the device base where install friction bites hardest.
- WeChat Mini Program docs — framework — a runtime that reaches users without an install step.
- GSMA — Mobile Economy — why data-constrained markets punish heavy native installs.