Win Back Lapsed Users with App Store In-App Events — Deep Link Implementation for Rork (Expo) Apps

Catch the Deep Link Destination with expo-router

Every in-app event requires a deep link per card. For security, Apple recommends Universal Links. Avoid URL shorteners and extra redirects, because your app can't resolve them and the tap drops onto the home screen instead.

To receive universal links in a Rork (Expo) app, first declare the domain association in app.json.

{
  "expo": {
    "scheme": "mywallpaper",
    "ios": {
      "associatedDomains": ["applinks:events.example.com"]
    }
  }
}

Then place an Apple App Site Association file on that domain. Without it, tapping the link only opens a browser and never reaches the app.

{
  "applinks": {
    "details": [
      {
        "appID": "TEAMID.com.example.mywallpaper",
        "paths": ["/event/*"]
      }
    ]
  }
}

This file must be served at https://events.example.com/.well-known/apple-app-site-association, with Content-Type: application/json, and no file extension. I tripped here once: a Cloudflare rule failed to attach the JSON content type to the extension-less path, so the link went silent and only launched the app. Always verify the response headers on a real device.

Build the landing handler in expo-router. Define a /event/[id] route and assemble the intended screen state based on the event ID.

// app/event/[id].tsx
import { useLocalSearchParams, useRouter } from "expo-router";
import { useEffect } from "react";
import { logEvent } from "../../lib/analytics";
 
const EVENT_DESTINATIONS: Record<string, string> = {
  "june-new-wallpapers": "/collection/2026-06",
  "summer-premiere": "/collection/summer",
};
 
export default function InAppEventEntry() {
  const { id } = useLocalSearchParams<{ id: string }>();
  const router = useRouter();
 
  useEffect(() => {
    if (!id) return;
    // Always record which event card brought the user in
    logEvent("iae_open", { event_id: id });
 
    const destination = EVENT_DESTINATIONS[id] ?? "/";
    // Replace rather than push so /event/[id] doesn't linger in history
    router.replace(destination);
  }, [id]);
 
  return null;
}

The crucial choice is router.replace instead of router.push. With push, the back button returns to the /event/[id] waypoint and confuses the user. Treat the event landing as a transit point, not a place to stay.

Don't Drop the Launch Path

Universal links arrive via two paths: a cold start when the app isn't running, and a warm start resuming from the background. expo-router routes foreground links automatically, but it's safer to explicitly grab the initial URL on cold start.

// lib/useInitialEventLink.ts
import * as Linking from "expo-linking";
import { useEffect } from "react";
import { useRouter } from "expo-router";
 
export function useInitialEventLink() {
  const router = useRouter();
 
  useEffect(() => {
    let handled = false;
 
    Linking.getInitialURL().then((url) => {
      if (!url || handled) return;
      const { path } = Linking.parse(url);
      if (path?.startsWith("event/")) {
        handled = true;
        router.replace("/" + path);
      }
    });
  }, []);
}

Test on a real device by pasting https://events.example.com/event/june-new-wallpapers into the Notes app and tapping it. The simulator is unreliable for universal links, so always test on hardware, and try both a fully terminated app and a backgrounded one.

Measure Impression Through Return in Three Stages

So the event isn't a fire-and-forget, design the measurement up front. The effect of an in-app event is easiest to judge through this three-stage funnel.

1. Impressions — how often the card was displayed (from App Store Connect analytics)
2. Opens — how often a tap launched the app (the iae_open event)
3. Return actions — how often the landing led to the intended behavior (saving a wallpaper, browsing a collection)

Stage one comes from App Store Connect's Analytics as in-app event impressions. The rest you fill in with your own analytics. I attach a dedicated tag on the landing screen to distinguish event-driven sessions.

// lib/analytics.ts
let activeEventId: string | null = null;
 
export function logEvent(name: string, params: Record<string, unknown> = {}) {
  // Swap the actual sink for Firebase Analytics, etc.
  if (name === "iae_open" && typeof params.event_id === "string") {
    activeEventId = params.event_id;
  }
  send(name, { ...params, via_event: activeEventId });
}
 
export function clearEventAttribution() {
  activeEventId = null;
}

Stamping via_event onto every event lets you trace, after the fact, "for users who arrived through the event, how far into the app did they get." In my operation I make the open-to-return-action rate the primary metric; events that don't move it get their copy or card image swapped the following month.

The numbers in App Store Connect and inside the app won't match exactly, because the measurement timing differs. Treat impressions as Apple's side and opens onward as your side, and watch each trend separately — that keeps the operation sane.

Pitfalls in Review and Publish Timing

The event card goes through App Review separately from the app binary. The easy thing to miss here is lead time. Submit an event right before your intended go-live date and review may not finish, leaving the card invisible when the start date arrives. I submit at least five business days before the start date.

The most common rejection is a mismatch between the card copy and the landing content. If the card says "new release live" but the landing is still a generic home screen, the reviewer reads it as a promise that doesn't match reality. Building the deep link destination to match the event's actual substance helps both approval and effectiveness.

One more thing: events have a start and end period, so make sure the deep link doesn't land on a dead screen after the event ends. I fall back any ID not present in EVENT_DESTINATIONS to the home screen. Even if an old link gets tapped after limited-time content is removed, no one sees a blank screen.

Your Next Step

Start by preparing a single "New Season" or "Premiere" event on an app you already run, and ship it small, targeted at the lapsed segment. Build out one clean universal-link destination, measure the open-to-return-action rate for a month, and the number will tell you what to swap next.

I hope it makes a useful first step for fellow solo developers wrestling with winning lapsed users back.