Catch Real-Device Bugs Before You Ship: A Pre-Submission Checklist for Rork Share Links

The seven device differences to clear first (in order)

Apply checks starting with what has broad impact and a low fix cost. Going in the order below reduces rework later.

1. Safe area, the notch, and Dynamic Island

Look at the corners first. A title sliding under the notch or Dynamic Island, or a bottom button overlapping the home indicator, is invisible at the preview's single size. Use the insets from react-native-safe-area-context and avoid fixed padding values.

2. The first timing of the permission prompt

Asking for notification, camera, or tracking permission right at launch tends to draw a refusal with no context. Always experience when the dialog appears on a real device. Simply shifting the request to after the user sees value moves the grant rate noticeably.

3. Deep links and cold start

When a share link or notification sends the user to a specific screen, recovery from a fully terminated state (cold start) is the most fragile spot. It is common to catch links while the app is running yet miss only the cold-start case.

4. Weak signal and offline

Picture airplane mode or a subway tunnel and open each screen with the connection cut. A loader spinning forever, or a screen going blank on error, only shows up on real hardware. Just preparing one offline state lifts perceived quality.

5. Keyboard-driven layout breaks

When the input field is tapped, check that the keyboard does not cover the submit button. Keyboard behavior differs between Android and iOS, so it is worth touching both real devices.

6. Dark mode and enlarged text

Put the device in dark mode and raise the system font size near its maximum. Text spilling out of its frame, or contrast vanishing between text and background, appears for the first time on the device of a user who raised their accessibility settings.

7. Perceived speed on low-end Android

Finally, open it on the oldest Android device you can find. Stuttering list scrolls and delayed image loads never surface on a high-end phone or in the preview. This is where I have found the most to fix.

What to set up in code before sharing the link

Rather than fixing breaks after you see them in testing, putting defensive code in before you distribute reduces rework. Add foundations like the following to the React Native (Expo) code Rork generates.

Take the safe area from insets, not fixed padding.

import { useSafeAreaInsets } from 'react-native-safe-area-context';
import { View } from 'react-native';
 
export function ScreenContainer({ children }) {
  const insets = useSafeAreaInsets();
  return (
    <View
      style={{
        flex: 1,
        paddingTop: insets.top,
        paddingBottom: insets.bottom,
        paddingLeft: insets.left,
        paddingRight: insets.right,
      }}
    >
      {children}
    </View>
  );
}

Ask for permission after the user has felt some value, not right at launch.

import * as Notifications from 'expo-notifications';
 
// e.g. call this right after the user saves their first favorite — a moment with context
export async function askNotificationWhenRelevant() {
  const current = await Notifications.getPermissionsAsync();
  if (current.granted) return true;
  if (!current.canAskAgain) return false; // the OS won't show it a second time
  const result = await Notifications.requestPermissionsAsync();
  return result.granted;
}

Receive deep links on two channels so neither cold start nor in-session links slip through.

import * as Linking from 'expo-linking';
import { useEffect, useState } from 'react';
 
export function useIncomingLink() {
  const [url, setUrl] = useState(null);
  useEffect(() => {
    // initial URL on cold start
    Linking.getInitialURL().then((initial) => {
      if (initial) setUrl(initial);
    });
    // links arriving while running
    const sub = Linking.addEventListener('url', (event) => setUrl(event.url));
    return () => sub.remove();
  }, []);
  return url;
}

Centralize offline detection in one place so every screen reads the same verdict.

import NetInfo from '@react-native-community/netinfo';
import { useEffect, useState } from 'react';
 
export function useOnline() {
  const [online, setOnline] = useState(true);
  useEffect(() => {
    const unsub = NetInfo.addEventListener((state) => {
      setOnline(Boolean(state.isConnected && state.isInternetReachable));
    });
    return () => unsub();
  }, []);
  return online;
}

With these four in place, share-link verification shifts from "hunting for breaks" to "confirming the defenses hold as intended."

Where iOS and Android diverge, by priority

Even with identical code, the spots where iOS and Android split are predictable. When you hand a share link to real devices on both, this priority order is efficient.

The Android physical back is especially easy to overlook: you mean to close a modal and the whole app exits instead. Before distribution, I always tap only the back action repeatedly on each screen and confirm the behavior.

How to keep a verification log (a solo workflow)

Working alone, you tend to keep verification in your head. But a share link goes to several people, so feedback comes back in fragments. In my case, I collect it in a simple note with just four fields per line: device, OS version, screen, and symptom. No elaborate issue tracker is needed; the lighter it is, the longer I keep it up.

I sort each report by which of the seven items above it belongs to. When the same symptom comes from multiple devices, it is not an isolated bug but a structural gap in device coverage. After I made this sorting a habit during staged rollouts of a wallpaper app, the number of bug reports I received in store reviews dropped noticeably. Ad display around AdMob also ties directly to perceived quality through device differences, so I track it in the same log.

A next step

Make just one share link in a Rork project you have on hand, get one old Android device, and touch the seven items above from the top down. The sheer number of breaks the first device reveals should make the return on verification obvious. I relearn this every time, and I have come to feel that the few dozen minutes before distribution stand in for days of work after release.