A deep link fails silently: the tap works, the app opens, but the user lands on a generic home screen instead of the product, offer, or thread they clicked for. A deep linking strategy for mobile growth means treating links as a routing contract — custom schemes, Universal Links, App Links, and deferred deep linking each solve a different piece of "get the right user to the right screen," and skipping any one of them leaks paid, referral, and re-engagement traffic.
Quick Answer: Use OS-verified links (Universal Links on iOS, App Links on Android) as your default, not custom URI schemes, which fail silently when the app isn't installed. Layer deferred deep linking on top so a not-installed user still lands on the intended screen after the app store round-trip. Test all three states — installed, not installed, logged out — before every campaign ships.
Every acquisition and re-engagement channel a growth PM owns — paid social, SMS, email, referral, push — routes through a link. If that link doesn't resolve to the right in-app destination, the campaign's click-through rate looks fine and the conversion rate quietly collapses. The gap between those two numbers is almost always deep linking plumbing, and it rarely shows up in a dashboard as "deep link broken." It shows up as "onboarding conversion dropped 4 points and nobody knows why."
What Is Deep Linking and Why Should a Growth PM Own It
Deep linking is the mechanism that routes a URL tap to a specific screen inside a mobile app instead of the app's default launch state. For a growth PM, it's the connective tissue between every acquisition and re-engagement surface and the actual product experience the campaign promised.
Three technical approaches solve this problem with very different reliability guarantees:
- Custom URI schemes (e.g.,
myapp://product/123) — the oldest approach, supported by nearly every mobile OS version, but with no verification step: the OS just tries to open whatever app claims that scheme. - Universal Links (iOS) and App Links (Android) — HTTPS URLs that the OS verifies belong to your app via a domain-hosted association file, so they degrade gracefully to a web page instead of erroring out.
- Deferred deep linking — a layer on top of either, using device fingerprinting or install referrer data to preserve destination context across an app-store detour, so a not-yet-installed user still lands correctly post-install.
Why this is a growth problem, not just an engineering one: every dollar spent on paid acquisition, every referral share, and every re-engagement push assumes the link lands the user where the campaign promised. If it doesn't, you're not measuring product-market fit failure — you're measuring plumbing failure, and misreading it as the former is a classic mistake documented in growth literature going back to Brian Balfour's writing on activation funnels.
The Three Failure Modes That Actually Cost You Users
Links fail in three distinct ways, and each maps to a different fix:
- The link doesn't open the app at all (custom scheme with no fallback, OS shows an error or does nothing).
- The link opens the app but drops the user on the home screen (deep link data lost, most common with custom schemes across app restarts).
- The link works for existing users but loses context after an install (no deferred deep linking, new user lands generically after downloading from the app store).
Growth PMs typically discover these failures downstream — in funnel drop-off, not in a bug report — which is exactly why this deserves the same rigor as any other part of the mobile PM role.
Universal Links vs App Links: What Actually Differs and Why It Matters
Universal Links (Apple's iOS implementation) and App Links (Google's Android equivalent) are functionally similar but operationally distinct, and conflating them is the single most common mistake in a cross-platform deep linking strategy. Both use standard HTTPS URLs verified against a domain-hosted file, but the verification mechanics, fallback behavior, and edge cases differ enough that testing one does not validate the other.
| Dimension | Universal Links (iOS) | App Links (Android) |
|---|---|---|
| Verification file | apple-app-site-association (AASA), hosted at domain root, no extension | assetlinks.json, hosted under .well-known/ |
| Verification timing | At install time and periodically thereafter, by the OS | At install time, via Android App Links auto-verification |
| Fallback if unverified | Opens in Safari as a normal web link | Shows a disambiguation dialog (chooser) instead of failing outright |
| User can override default | Yes, via Settings, silently | Yes, via app defaults, more discoverable |
| Common breakage cause | AASA file misconfigured, wrong content-type header, or CDN caching stale version | assetlinks.json SHA-256 fingerprint mismatch after a new signing key or App Bundle update |
| Testing tool | Apple's AASA validator, or swcutil on-device | adb shell pm get-app-links, Google's Statement List Generator |
The practical takeaway: your two platforms need two separately maintained, separately tested verification files, and a change to your app's signing certificate or bundle ID on either platform can silently break its link file without touching the other. Treat both as release-blocking checks, not one-time setup.
Where Custom Schemes Still Belong
Custom URI schemes aren't obsolete — they're still useful as a secondary, in-app fallback (for example, one app opening another you control) or inside environments that don't support HTTPS-verified links well, like some in-app browser webviews or QR codes scanned by camera apps that don't resolve associated domains.
What they should never be is your primary channel for paid or referral traffic, because a custom scheme with no matching app installed either errors visibly or does nothing — there's no graceful web fallback, and you lose the click entirely instead of routing it to a landing page or app store listing.
Deferred Deep Linking for Onboarding: Solving the Post-Install Gap
Deferred deep linking preserves a link's intended destination across the app-store detour a not-installed user takes, so someone who clicks a referral link, doesn't have the app, installs it, and opens it for the first time still lands on the specific screen the link promised — not a generic home screen that makes them re-find what they clicked for.
This matters because the gap it closes is exactly where acquisition campaigns bleed conversion. A user clicks a paid ad for a specific product, gets routed to the App Store because they don't have the app, installs, opens the app, and finds themselves at onboarding step one with zero memory of what they clicked. That's not a small UX rough edge — it's the moment the campaign's promise and the product's delivery diverge.
How the Matching Actually Works
Since a fresh app install has no cookies or session to carry context, deferred deep linking relies on a matching heuristic between the pre-install click and the post-install open:
- Device fingerprinting — combining IP address, user agent, screen resolution, and timezone into a probabilistic match. Imperfect (shared networks, VPNs, and IP churn cause false matches) but works without any platform cooperation.
- Install referrer APIs — Android's Install Referrer API passes UTM-style parameters straight from the Play Store click through to first app open, deterministically. iOS has no equivalent first-party mechanism, which is why third-party attribution SDKs exist.
- Clipboard-based fallback — copying a token to the clipboard before redirecting to the store, then reading it on first open. Effective but increasingly constrained by OS clipboard-access prompts that flag the read to the user.
Growth teams commonly route this through a third-party linking/attribution provider (Branch, AppsFlyer, Adjust, and similar are the well-known names in this space) rather than building fingerprint-matching in-house, since match-rate tuning is a genuinely hard, ongoing problem — not a one-time integration.
The honest caveat: deferred deep linking is probabilistic, not guaranteed. Build a sensible default landing experience for the small percentage of installs where the match fails or times out, rather than assuming 100% resolution.
The Story: A Paid Campaign That Leaked Users to a Generic Home Screen
A recognizable pattern for growth PMs: a paid social campaign drives strong click-through to a specific in-app offer, but activation from that campaign underperforms every other channel by a wide margin — while the ad's landing page and creative both test clean.
The typical root cause, once traced: the campaign link used a custom URI scheme with no deferred deep linking layer. Users with the app installed opened straight to the offer and converted normally. Users without the app clicked through to the store, installed, opened the app cold, and landed on the default home tab with no memory of the offer that got them there in the first place — effectively a second cold-start funnel stacked silently inside what looked like one funnel in the dashboard.
The fix pattern is consistent across cases like this:
- Audit whether the link is OS-verified (Universal/App Link) or a bare custom scheme with no web fallback.
- Add a deferred deep linking layer so the not-installed path preserves the offer context through install.
- Split funnel reporting by installed-vs-not-installed at click time, so this leak is visible in the metrics instead of buried inside a single blended activation number.
The lesson generalizes: a link's job doesn't end at "the app opened." It ends at "the user is looking at what they clicked for." Everything between those two points is either specified deliberately or silently left to chance — and paid budget makes that gap expensive fast.
The QA Matrix: Testing Every Link State Before You Ship a Campaign
Every deep link needs testing across three independent states — app installed, app not installed, and user logged out — because each state routes through a different code path, and a link that works in one state can fail silently in another without any error surfacing to the person who tested it.
| State | Expected behavior | Common failure |
|---|---|---|
| App installed, logged in | Opens directly to the linked screen | Deep link data lost on cold start vs. warm start (works when app is backgrounded, fails when fully killed) |
| App installed, logged out | Routes to auth, then to the linked screen post-login | Destination context dropped during the login redirect; user lands on default home after auth |
| App not installed | Routes to app/play store, then (via deferred linking) to the linked screen on first open | No deferred linking configured; user lands on generic onboarding with zero context |
| App installed, different account logged in | Either shows an account-switch prompt or a scoped "not available" state | Link silently applies to the wrong account's context |
| Link clicked inside an in-app browser/webview | Falls back gracefully to a mobile web equivalent | Webview can't resolve associated domains; link dead-ends |
Run this matrix on both iOS and Android, since the underlying failure causes (AASA misconfiguration vs. assetlinks.json mismatch) are platform-specific and one platform passing tells you nothing about the other. Add it as a named row in your release checklist alongside app store review considerations, not as an afterthought tested only once at initial build.
Logged-Out State Deserves Its Own Attention
The logged-out path is the state most often skipped in testing, because the person testing is almost always logged in on their own device. It's also the state most likely to affect a real campaign, since paid and referral clicks disproportionately reach people who don't have an active session.
Design the redirect explicitly: capture the intended destination before sending the user to auth, and re-apply it immediately after login succeeds — don't let auth reset the navigation stack to a default tab.
Mapping the Broken Link Moment to the User's Emotional Arc
A deferred deep link failure isn't just a routing bug — it's a specific moment where an excited new user, mid-install, hits friction and bounces before ever reaching the product's actual value. That's a distinct point on the user's emotional trajectory, and it's worth treating it as one.
Prodinja's Customer Journey emotion curve is built for mapping exactly this kind of moment: plotting a user's emotional state across the stages from ad click through install through first open, so a dip caused by a broken deferred deep link is visible as a specific low point tied to a specific stage — not folded anonymously into a blended "onboarding activation rate." Walking your acquisition-to-activation flow through that emotion curve can surface where a routing failure is doing more damage to the funnel than the raw conversion number suggests, since the excitement-to-frustration drop at that exact stage is often steeper than surrounding stages.
Key Takeaways
- Default to OS-verified links (Universal Links on iOS, App Links on Android) over custom URI schemes for any campaign-facing link, since verified links degrade gracefully to web instead of failing silently.
- Universal Links and App Links are not interchangeable configurations — each platform needs its own hosted verification file, tested and monitored separately, since either can break independently after a signing-key or bundle-ID change.
- Deferred deep linking closes the post-install gap, but it's probabilistic (device fingerprinting) or platform-dependent (Android's Install Referrer API), not a guaranteed 100% match — design a sensible fallback for the miss rate.
- Test all three core states — installed, not installed, logged out — plus wrong-account and in-app-webview cases, on both platforms, before every campaign that drives new installs or re-engagement.
- Split funnel metrics by link state at click time, not just by channel, so a routing leak shows up as a visible gap instead of quietly dragging down a blended activation number.
- Treat the post-click, post-install moment as an emotional inflection point, not just a technical handoff — a broken deferred link converts campaign excitement into an immediate bounce.
Frequently Asked Questions
What's the difference between Universal Links and App Links?
Universal Links are Apple's iOS implementation and App Links are Google's Android equivalent — both use verified HTTPS URLs instead of custom schemes, but they use different verification files (apple-app-site-association vs. assetlinks.json) and different fallback behavior, so passing tests on one platform doesn't validate the other.
Do I still need custom URI schemes if I use Universal Links?
Custom schemes still have a narrow, useful role as a secondary fallback for contexts that don't handle HTTPS-verified links well, such as certain webviews or QR flows, but they shouldn't be your primary link type for paid or referral campaigns since they fail silently with no installed app and no web fallback.
How accurate is deferred deep linking really?
Deferred deep linking match rates vary by method and platform: Android's Install Referrer API is deterministic and highly reliable, while iOS relies on probabilistic device fingerprinting that can misfire on shared networks or VPNs — build a sensible default experience for the inevitable non-matched fraction rather than assuming perfect resolution.
Why did my deep link work in testing but fail for real users?
The most common cause is testing only the "app installed, logged in, warm start" path, which is the easiest state to hit accidentally and the least representative of real campaign traffic — always run the full installed/not-installed/logged-out matrix, including a fully killed (not backgrounded) app state.
Should growth PMs or engineers own deep linking QA?
Both, with clear split ownership: engineering owns the verification file correctness and SDK integration, while the growth PM owns defining the expected destination and context for every campaign link and validating the full QA matrix before launch, since only the growth PM has visibility into which links are about to carry real ad spend.