Every app reinvents the same twenty screens — a map, a form, a payment, a login, a list, a chat. Each is a hire, a sprint, a maintenance burden that never ends. A mini-program runtime with a catalog of vetted templates lets a team assemble the common parts from what already exists and spend its people on the thing only it can do. You didn't shrink the ambition; you stopped paying twice for the parts everyone builds.
The mechanic is reuse as infrastructure. The host supplies identity, wallet, maps, and a library of mini-program templates the team composes rather than authors. The rare feature — the one specific to your market — is the only thing you write from scratch, and even that can start from a template. Engineering capacity stops leaking into table-stakes and starts compounding on the differentiator.
| Cost center | Build it all | Mini-program path |
|---|---|---|
| Common screens | Per team, per market | Shared catalog |
| Maintenance | N versions, N bugs | One runtime |
| Time to launch | Months per feature | Days per composition |
| Ops overhead | Own the stack | Host owns the container |
Here's the pushback the "we own our stack" teams won't like. They'll say reuse means compromise. Sometimes — a template won't match a bespoke flow. But most of what teams build is not bespoke; it's the same form with a different label. A governed runtime gives you the standard parts free and the escape hatch for the rare custom one. You didn't lose control; you stopped spending your best engineers on the login screen.
And the loop is the moat. Lower cost per feature means more features per quarter, which means a deeper catalog, which means more reasons to stay — all without a headcount that scales with the roadmap. Chinese apps didn't win by out-spending; they won by assembling fast on a runtime that made each new service cheap to ship. The cost advantage was the strategy.
The local angle is the unlock. In Indonesia, Brazil, Kenya, the Philippines, the team is small and the market is wide, so every engineer hired to rebuild a map is an engineer not building the local flow that wins. A portable runtime with local templates lets a lean team ship a warung reorder and a moto-taxi fare that feel native, without a build-out per feature. You don't import a big engineering org; you borrow the runtime and keep the local brain.
I won't pretend the catalog is free to curate. A template library is only as good as its governance — a stale or insecure component is a liability multiplied across every service that uses it. The honest risk is treating reuse as "grab whatever's there" and shipping a shared bug to a thousand mini-programs at once. We should maintain the catalog like the critical infrastructure it is.
But the direction is clear. The screens are already built somewhere. The team is already stretched. The only missing piece is a runtime that lets you assemble the common parts and spend your people on the rare ones. Keep the catalog maintained, keep the escape hatch real, and the team you didn't hire becomes the feature you still shipped.
Sources
- StatCounter — Mobile market share — why a host surface is where reuse actually compounds.
- Think with Google — Engineering efficiency — how assembly speed shapes what teams can ship.
- World Bank — Private sector development — where lean local teams and micro-enterprise demand actually show up.
- web.dev — Web platform guidance — the runtime and performance basics behind a portable mini-program.
- MDN Web Docs — Web tech reference — the standards a reusable component library should build on.