The catalog model's whole appeal is "write once, run in every super-app." By 2025 that stopped being a pitch and became a survival strategy: developers watched platform fees and policy whims on a single host and refused to be held hostage. One team shipped a single mini-program into eleven hosts — WeChat, Telegram, a few partner apps — and branched the code zero times. Not because the hosts are identical, but because from the first commit the team refused to let three things leak into the build.

Payment is where "same" falls apart first

Every host has its own money. WeChat Pay, Telegram Stars, a partner's own PSP — each returns a different callback shape, settles on a different timeline, and fails a different way. The common mistake is to write handleWeChatCallback() and then copy it eleven times because of if (host === 'telegram'). That is not multi-host; that is eleven apps wearing one costume. The correct abstraction: payments expose a single pay(order) interface, host differences pushed entirely into an adapter layer, so adding a host means adding one adapter, not editing eleven places.

Login identity breaks across hosts

WeChat gives an openid; Telegram gives a tg user id; a self-owned account system gives another. A user who finds the mini-program on WeChat and later arrives via Telegram is two people in the backend, and real cross-host LTV cannot be computed. Abstract identity into a resolveIdentity() interface too, with the adapter mapping each host id back to one internal id, to avoid duplicate users and broken attribution.

Difference sourceHard-coded costAbstracted cost
Payment callbackOne copy per hostOne adapter per host
Login identityCross-host user splitUnified id mapping
Review cadenceOne change re-reviews allLayered release

Review cadence is the invisible schedule

Host review cycles differ completely: some are hourly, some weekly. A change touching payment logic can be stuck three weeks at a slow host while the other ten have shipped — and then runtime version skew appears, one host still on an old runtime where the new feature silently fails. The controllable practice is to push all host differences into the adapter layer with zero branching in core logic, so any host's review delay never infects the others. One team that abstracted payments into adapters cut a new host's integration from three months to two weeks.

Config-driven, not branch-driven

Once host differences live in adapters, the build has to follow: ideally one build emits per-host bundles with host parameters injected at build time — app id, payment channel, callback domain — and the runtime only reads config, never decides. One team that switched to this stopped the core package bloating with "special cases left for a host" and turned a new host from a code change into filling a config and an adapter, about two days. Build-time injection and zero runtime branching are the two stones multi-host rests on without rotting.

Treat each host's review gate as a feature

A slow or strict review at one host is annoying, but it is also the only point where per-host compliance is actually checked. Teams that fight the gate usually discover later that the host was catching something real — a payment flow that violated local rules, or a missing data-collection notice. The robust pattern is layered release: ship to the fast, permissive hosts first, let the strict one review in parallel, and treat its findings as a checklist that improves the shared core rather than a blocker that holds everyone. One team turned a three-week Telegram review wait from a schedule risk into a quality gate that caught a missing refund disclosure before it reached eleven markets.

The bottom line

Multi-host's real exam is not "can it run" but "does changing one thing rework all eleven hosts." Push every host difference behind an adapter, keep core logic host-agnostic, and write-once finally runs everywhere.

Sources