Over-the-air app updates: what they can and can't fix
Short answer: Over-the-air (OTA) updates let a React Native or Expo app download new JavaScript and assets without a trip through the App Store or Google Play. They're excellent for bug fixes, copy changes and layout tweaks, and useless for anything touching native code, permissions or the SDK version, which still need a new build. Store rules still apply to what you ship this way, so OTA is a faster delivery route, not a way around review.
When an app owner hears "we can push a fix tonight without waiting for Apple", it's easy to imagine every future change shipping that way. The reality is narrower, and knowing the boundary helps you plan releases and budgets realistically.
Myth 1: "OTA means we never need app store releases again"
Reality: OTA replaces only the JavaScript bundle and assets that run inside the existing app binary. Expo's update documentation lists what it suits, including fixing bugs or crashes in JavaScript, updating copy, translations, styling and screen layouts, and testing updates with internal teams. It also lists what it can't do: changes to native code or native dependencies, changes to app permissions such as camera or location, updating the Expo SDK version, and anything else that requires a new binary. For those, you build and submit a new version.
In practice, a typical app still needs store releases for new device features, new native libraries, SDK upgrades and some platform requirements. OTA fills the gaps between them.
Myth 2: "Updates go around app review"
Reality: the platform rules still apply. Expo's FAQ says updates must follow the App Store and Play Store guidelines, including the content of updates and how you use them, and that changes to an app's behaviour usually need to be reviewed.
Apple's App Review Guidelines, section 2.5.2, say apps may not download, install or execute code that introduces or changes features or functionality of the app. Google Play's Device and Network Abuse policy says an app may not update itself other than through Google Play's update mechanism or download executable code such as dex, JAR or .so files from outside Google Play, while noting that this doesn't apply to code running in a virtual machine or interpreter, such as JavaScript in a webview, and that interpreted code loaded at run time must not allow policy violations.
The practical reading many teams follow: use OTA for fixes and small adjustments to features that were already reviewed, and submit new features through the store. Read the current policies yourself before relying on any interpretation.
Myth 3: "Every user gets the update instantly"
Reality: the app downloads updates in the background and applies them according to its configuration. Expo's FAQ says users see the new version on their next app launch or reload, without reinstalling. Someone who keeps the app open for days, or who rarely opens it, will be on the old version for a while. Plan support conversations around that delay.
Myth 4: "If an update breaks something, we're stuck until the store approves a fix"
Reality: this is where OTA shines. Expo's rollbacks guide describes two kinds of rollback: back to a previously published update, or back to the update embedded in the build itself. And rollouts let you release an update to a percentage of users first, for example 10%, then raise it gradually. A broken JavaScript change can be contained quickly. A broken native change can't, which is another reason to keep native releases careful.
Myth 5: "An update could crash old versions of the app"
Reality: it can, if versioning is ignored. JavaScript written for new native code may call functions an older binary doesn't have. Expo handles this with runtime versions: according to its documentation, updates are only sent to builds with compatible native code, and when native code changes you create a new runtime version. Set this up deliberately instead of relying on defaults you don't understand.
Myth 6: "OTA is an Expo-only thing"
Reality: other approaches exist for React Native, and some teams self-host update servers. One widely used older option, Microsoft's CodePush, was part of Visual Studio App Center, which Microsoft's retirement notice scheduled for retirement on March 31, 2025. If your app still depends on it, check your migration status now.
A release routine that uses both channels
| Change | Route | Notes |
|---|---|---|
| Typo, wording, translation fix | OTA | Staged rollout optional |
| JavaScript bug fix | OTA | Roll out to a small percentage first |
| Layout or styling change | OTA | Test on small and large screens |
| Small change to an existing feature | OTA, with care | Stay within what was reviewed |
| New feature | Store release | Reviewed as a new version |
| New native library or SDK upgrade | Store release | Then a new runtime version for future OTA |
| New permission (camera, location, notifications) | Store release | Permission text reviewed by the store |
| Emergency fix of a native crash | Store release | Request expedited review where offered |
A few habits make this work:
- Name your channels clearly (for example, production, staging, internal) so a test update never reaches customers.
- Publish from your build pipeline, not a laptop, so you know exactly what went out.
- Write a one-line message for every update so the history makes sense later.
- Keep native releases on a schedule, monthly or quarterly, so OTA doesn't become an excuse to postpone SDK upgrades.
FAQ
Do users have to do anything to get an OTA update?
No. The app downloads the update and applies it on a later launch or reload, depending on how it's configured.
Can we change the app icon or splash screen over the air?
Those are part of the native binary on both platforms, so they generally need a store release. Check your framework's documentation for specifics.
Is there a cost to OTA updates?
Hosted update services usually have usage-based plans. Check the provider's pricing page for current terms.
How quickly can we roll back a bad update?
With rollbacks you can re-publish an earlier update or return users to the version embedded in the build. Users pick it up on their next launch or reload.
Want a release setup where small fixes ship quickly and native changes stay safe? Tell us how your app is built.
Sources
- https://docs.expo.dev/eas-update/introduction/
- https://docs.expo.dev/eas-update/rollouts/
- https://docs.expo.dev/eas-update/rollbacks/
- https://developer.apple.com/app-store/review/guidelines/
- https://support.google.com/googleplay/android-developer/answer/9888379?hl=en
- https://learn.microsoft.com/en-us/appcenter/retirement