Your Expo App Fell Behind the Stores: How to Ship an Update Again

The app is live and it works. The last release went out a long time ago, and nobody has touched the project since. Now you need one small change: a new price, a fixed typo, a login that broke. You open the project and it no longer builds. Or it builds, and the store refuses the upload.
Nothing in your app broke. The ground under it moved. Apple and Google keep raising what they accept, Expo and React Native keep shipping new versions, and an app that stands still falls behind all of them at once. This post explains what moved, how to measure the gap, and the order of work that gets a release out again.
What changed while the app stood still
Google Play's target API level
Since August 31, 2026, new apps and app updates must target Android 16, API level 36, to be submitted to Google Play. The same page sets a second line for apps that are not updated at all: an existing app has to target at least Android 15, API level 35, to stay available to new users on devices that run a newer Android version than the app targets. Below that line the app is only available on devices whose Android version is the same as or lower than the level it targets. Google offered an extension to November 1, 2026, and that date has passed.
Apple's build requirement
Since April 28, 2026, apps uploaded to App Store Connect must be built with Xcode 26 or later using the iOS 26 SDK. Your live app is not affected by this. Your next upload is. A project left on Expo SDK 53 or older may not build with Xcode 26: Expo says not all of those SDK versions are compatible with it, depending partly on the libraries the app uses. That is one reason the first attempt at a small fix can end in a failed build.
16 KB memory pages on Android
Apps that target Android 15 or higher must support 16 KB memory page sizes on 64-bit devices, and starting February 1, 2027, Google Play will not let you release an update that does not. This rule is about native code, and a React Native app ships native libraries, both its own and those of its dependencies. An old dependency with a compiled library that was never rebuilt is the kind of thing this check catches.
React Native's New Architecture
React Native 0.82, released in October 2025, is the first version that runs only on the New Architecture. The setting that let older projects stay on the legacy one is ignored from that version on. For your app this is mostly a question about libraries: a package that was abandoned before the New Architecture may need to be replaced before the project can move past that point.
How to measure how far behind you are
Open package.json and read the version of the expo package: its major number is your SDK. Then compare it with Expo's version table. At the time of writing the table lists SDK 56, 57 and 58. All three target API level 36 and build with Xcode 26.4 or later, and SDK 58 runs on React Native 0.88. The number of major versions between yours and the current one is the size of the job.
Three more questions decide what kind of job it is, and none of them is about code quality.
- Does the project build today, on a current machine, without changes?
- What exactly does the store say when you try to upload?
- In whose name are the Apple and Google accounts, and do you have the source code and the signing keys?
The third question matters most. If the accounts or the code sit with a developer you can no longer reach, an upgrade is not your problem yet. That situation is a recovery, and we describe it on our App Rescue page.
Why you should not jump straight to the newest version
Expo's upgrade guide is direct about this: upgrade SDK versions incrementally, one at a time, because that is how you find which step broke what. Each step is the same loop. Raise the SDK, update the packages that belong to it, fix what stops compiling, build, open the app, test the flows that earn money. Then the next one.
Two things slow this down on an old project. Expo Go only supports the latest SDK version, so the current Expo Go will not open an older project to show you where you stand. A specific older version can be installed on an Android device, an Android emulator or the iOS Simulator, and the same guide recommends development builds for production apps. And the further back you start, the more packages you meet that were abandoned along the way. Replacing one of those is a small project inside the upgrade.
The order of work that gets a release out
- Establish the starting point: does the app build as it is, and if not, what is the first error
- Upgrade one SDK version at a time, with a working build after each step
- Replace the packages that were abandoned before the New Architecture
- Fix what blocks the release: a crash on launch, a broken sign-in, a purchase that fails
- Bring the privacy answers and the Data safety form in line with what the app collects today
- Send a test release to real devices, then submit to both stores
New features and a redesign do not belong on this list. Mixing them into an upgrade turns a short job into a long one, because you can no longer tell whether a bug came from the upgrade or from the new screen.
What review can ask for after a long gap
An update is reviewed against today's rules, not the rules of the day your app first went live. Two of them are worth checking before you submit. If the app supports account creation, Apple requires account deletion inside the app. And the app privacy details are required for updates too, so answers written years ago have to be checked against the packages the app uses now.
Check the account itself as well. If the Apple Developer Program membership has expired, the apps are no longer available for download and you cannot submit updates until it is renewed. An expired distribution certificate is milder: Apple says existing apps on the App Store are not affected while the membership is valid, but you cannot upload a new build signed with it.
When an upgrade is the wrong job
Sometimes the honest answer is that the work should not be attempted as an upgrade. If the app is many major versions behind and carries a lot of custom native code, moving the screens into a fresh project on the current SDK can cost less than walking the old one forward. If the source code is missing, there is nothing to upgrade. A short written assessment before any work starts is how you find out which case you are in, and it should be able to say no.
FAQ
Will my live app be removed if I never update it?
Not on a fixed date. On Google Play, an existing app that targets a level below Android 15, API level 35, is only available on devices whose Android version is the same as or lower than the level it targets, so new users on newer phones cannot get it. On the App Store, Apple contacts developers whose apps have not been updated in three years and have very few downloads, and gives them 90 days to submit an update. An app that crashes on launch is removed immediately under that process.
Can I skip SDK versions to save time?
Expo recommends against it. Its upgrade guide says to move one SDK version at a time, because that is how you find which step caused a breakage. Skipping looks faster, but it brings several problems at once and leaves you no way to tell them apart.
Do I have to rewrite the app for the New Architecture?
No. The New Architecture is part of React Native itself, and from version 0.82 it is the only one. Your screens and logic stay. What may have to change are third-party packages that were never updated for it.
How long does it take to get an outdated app back on the stores?
It depends on how far behind the app is and whether it builds today. For an Expo app that is at most two major versions behind the current one, our Store-Ready Sprint takes at most 10 business days, the 2-business-day Health Check included. The days count from the day we have access to the code and the accounts, and do not include days spent waiting for your decision, your payment or your approval. Store review comes after the submission and is up to Apple and Google. An app that is further behind gets a separate fixed quote after the Health Check.
If you want it done for you
This is the job we packaged as the Store-Ready Sprint: a fixed-price service for Expo and React Native apps that fell behind. It starts with a Health Check of two business days that answers in writing whether the app builds today, what blocks the next release and whether the sprint is the right job. Then we move the app to the current Expo SDK, fix what blocks the release, update the privacy forms and submit the new version to both stores with your written approval. Apple and Google decide on the approval; we remove the known causes of rejection before we submit.
Sources
- Android Developers: target API level requirement
- Apple: upcoming requirements
- Android Developers: support 16 KB page sizes
- React Native 0.82 release notes
- Expo: SDK version table
- Expo: upgrade Expo SDK
- Apple: offering account deletion in your app
- Apple: program renewal
- Apple: certificates overview
- Apple: App Store Improvements
- Expo blog: the Xcode 26 requirement and Expo SDK versions
- Apple: app privacy details on the App Store
Once the app is current, keeping it there is a smaller monthly job, which we describe in what app maintenance covers. To start, send us the name of your app and its store link and mention the Store-Ready Sprint.
More from the blog
What App Maintenance Covers, and What Happens to an App Without It
A live app sits on two platforms that keep changing. What stops working when nobody maintains it, and what a monthly maintenance routine is made of.
App Developer Disappeared? Take Your App Back
App developer disappeared? Check whose name is on your Apple and Google accounts, get the code and signing keys back, and move the app into your own account.
Building Production Apps with Expo in 2026: A Startup's Guide
The SDK versions, eas.json, and runtimeVersion rules behind our live subscription apps. Development builds, EAS Build, EAS Update, and the trap that decides who gets your over-the-air fix.