A mini-program buried in a host's menu is one the user has to remember to open. The growth that actually compounds for Mini Apps — a level shared to a Telegram group, a coupon scanned at a counter, a reminder pushed the next morning — all runs on deep links. WeChat mini-games live or die on share chains; Telegram Mini Apps spread through chat. The math is unforgiving: the viral coefficient must clear 1 to grow, and a deep link that drops the user on the home screen instead of the shared level silently pushes K below 1. The share still happens; the loop just stops.
Hosts rewrite your links on purpose
The first break point is that the host controls the surface. WeChat and Telegram both mediate shared links, and a bare deep link is often wrapped, stripped of its query, or downgraded to a web preview. If the route reads the level id from the query and the host eats the query, the user lands on the home screen. The fix is to encode the destination as a short code or path the host cannot silently drop, and resolve it server-side:
// wrong: destination in query, host strips it
openMiniApp('game?level=42');
// right: destination encoded in path, resolved server-side
openMiniApp('game/lvl/42');
Deferred deep linking: what if the user has not installed
The second break point is the not-installed case. A user tapping the link before installing the host or mini-program cannot deep-link and the attempt fails. Deferred deep linking lands the user on a landing or app-download page first, then after install uses a one-time match token to carry them to the original level. This requires the server to remember "where this share pointed" and replay it after install, instead of relying on the client to remember locally.
| Break point | Symptom | Fix |
|---|---|---|
| Link rewritten | Lands home | Path encoding plus server resolve |
| Not installed | Deep link fails | Deferred plus match token |
| No preview card | Gray block in chat | Server-generated OG card |
| Attribution lost | Growth miscounted | Deep link bound to attribution |
Preview card and attribution are two sides of one wound
A link with no OG preview card is a gray block in a group, with a naturally lower click rate; the preview card has to be generated server-side. Deeper, when a deep link is rewritten or lost, the install it brought cannot be attributed to the channel — the same wound as the "funnel polluted by the host" piece. Converging deep link, preview card, and attribution together on the server is what finally closes the viral loop.
The short-code service design
Encoding the destination into a path still needs a server mapping the short code back to the real target, and that mapping must expire and resist enumeration — an enumerable short code hands the level structure to anyone. The good design is one-time, signed short codes that the server invalidates immediately after validation, and this same service reuses the preview-card generation: one share yields both a host-proof deep link and a chat-displayable OG card. Deep link, preview card, and attribution should be three things from one server exit.
Attribution breaks at which hop
The cost of a lost deep link is not only experience but the ledger. A share rewritten to the home screen may still convert — the user finds the level and buys — but that conversion is attributed to organic or misattributed elsewhere by SKAdNetwork, exactly the "third of attribution is wrong" problem. Binding deep link and attribution server-side is what makes the share's install actually return to the channel, and only then does the viral loop's ROI compute. Break one hop of the deep link and the loop and the attribution break together.
A broken deep link is silent churn
What makes a lost deep link expensive is that nobody complains. The user lands on the home screen, shrugs, and does not return; there is no support ticket, just a slightly lower retention that nobody traces to the link. The defense is to measure the deep-link-to-conversion path explicitly and watch it by channel. One team instrumented the full chain and found a host rewrite was silently dropping thirty percent of shared-level links to the home screen — a leak invisible in aggregate metrics but obvious once the hop was measured. Silent churn is still churn.
The bottom line
A deep link is not the URL in the share box; it is the blood vessel of the viral loop. Hosts rewrite it, absence breaks it, missing cards bury it — defend all three on the server, and every share hop actually carries the user back to the level, not the home screen.