shipping an over-the-air update is only half the job. The other half is deciding when users actually get it. Use silent updates on next launch for most changes, an "update ready" banner for meaningful fixes, and a forced update only when old versions are genuinely broken. The useUpdates() hook from expo-updates gives you everything you need to build all three.

By default, expo-updates checks for an update when the app launches, downloads it in the background, and applies it on the next launch. That's safe and invisible, and it's also why your urgent fix seems to take forever to reach users: many people keep apps open in the background for days.

Three strategies

1. Silent (the default)

The update downloads quietly and applies the next time the app starts fresh.

Use it for: copy changes, small fixes, styling, anything that can wait.

Pros: zero interruption. Cons: slow to reach people who rarely restart the app.

2. "Update ready" banner

When an update has downloaded, show a small, dismissible banner: "A new version is ready. Tap to restart." The user chooses when.

Use it for: bug fixes users would want, small features.

Pros: fast for people who tap, never interrupts anyone mid-task.

3. Forced update

Block the app until it restarts with the new version.

Use it for: broken flows, security fixes, or a backend change old versions can't handle.

Cons: it interrupts people. Use it rarely, or users learn to dread opening your app.

Check when the app comes back to the foreground

The default check only runs at launch. Add a check when the app returns to the foreground, so long-running sessions also find updates:

// src/updates/useForegroundUpdateCheck.ts import { useEffect, useRef } from 'react'; import { AppState } from 'react-native'; import * as Updates from 'expo-updates'; const MIN_INTERVAL_MS = 15 * 60 * 1000; // at most every 15 minutes export function useForegroundUpdateCheck() { const lastCheck = useRef(0); useEffect(() => { if (__DEV__) return; // updates don't run in development const sub = AppState.addEventListener('change', async (state) => { if (state !== 'active') return; if (Date.now() - lastCheck.current < MIN_INTERVAL_MS) return; lastCheck.current = Date.now(); try { const result = await Updates.checkForUpdateAsync(); if (result.isAvailable) await Updates.fetchUpdateAsync(); } catch { // Never let an update check break the app } }); return () => sub.remove(); }, []); } 

The throttle matters: users switch apps constantly, and you don't need to hit the update server every time.

A reusable update banner

useUpdates() tells you when an update is downloaded and waiting (isUpdatePending). That's all a banner needs:

// src/updates/UpdateBanner.tsx import { useState } from 'react'; import { Pressable, Text, View } from 'react-native'; import * as Updates from 'expo-updates'; export function UpdateBanner() { const { isUpdatePending } = Updates.useUpdates(); const [dismissed, setDismissed] = useState(false); if (!isUpdatePending || dismissed) return null; return ( <View className="absolute bottom-6 left-4 right-4 flex-row items-center rounded-2xl bg-gray-900 p-4"> <Text className="flex-1 text-white">A new version is ready.</Text> <Pressable onPress={() => setDismissed(true)} className="px-3 py-2"> <Text className="text-gray-400">Later</Text> </Pressable> <Pressable onPress={() => Updates.reloadAsync()} className="rounded-xl bg-white px-3 py-2"> <Text className="font-semibold text-gray-900">Restart</Text> </Pressable> </View> ); } 

Render it once in your root layout, together with the foreground check. If the user taps "Later", the update still applies on their next launch.

Forced updates, done carefully

A forced update needs a signal that says "this one is critical". Two common approaches:

  • A minimum version from your backend. Your API returns the minimum supported app version or update ID. If the running app is older, show a blocking screen with one button that fetches and reloads. This also works for native store updates, where the button opens the store instead.
  • Update metadata. Include a marker in your update's message or metadata and read it when the update is available.

The backend approach is more flexible, because you can turn it on and off without publishing anything, and it works even when the problem is in a version that can't receive updates.

Whatever you choose, keep the blocking screen honest and short: "This version needs an update to keep working. It takes a few seconds." and one button.

Rules of thumb

  • Default to silent. Most updates don't deserve the user's attention.
  • Never reload without consent unless the current version is broken.
  • Don't interrupt critical moments. Hide the banner during checkout, recording or form entry.
  • Throttle checks on foreground.
  • Log the running update ID in your crash reporting, so you know which update a problem came from.

Conclusion

Over-the-air updates are fast only if users actually receive them. Check on foreground, show a gentle banner for updates worth having, keep forced updates for genuine emergencies, and let everything else apply silently.

If your app is built with RapidNative, the exported Expo project supports expo-updates, so you can drop these components straight in.

How does your app handle updates today: silent, banner or forced? Tell us in the comments.