skip to content

How would you upgrade an Expo pet-adoption app from SDK 54 to SDK 57, and why go one SDK at a time instead of jumping straight there?

level: seniorimportance: should knowfreq 45%

answer

  1. 54 to 55, 55 to 56, 56 to 57
  2. expo@^N, then install --fix
  3. regenerate native folders each step
  4. read each SDK's changelog
  5. 55: New Architecture only

basics

~20 s

Upgrade in three steps, 54 to 55, 55 to 56 and 56 to 57: bump expo, run npx expo install --fix, regenerate native folders, follow that SDK's release notes and test. Each step then breaks in a small, attributable way.

solid answer

~50 s

I upgrade in three steps, 54 to 55, 55 to 56 and 56 to 57, following Expo's advice to go one SDK at a time. Each step is the same loop: `npm install expo@^N.0.0`, `npx expo install --fix` to align every package, a health check, then regenerate the native projects (delete generated `android/` and `ios/`, or apply the native upgrade helper if they are hand-maintained), read that SDK's release notes, build a development build and test the app's key flows. Each step has its own breaking changes. SDK 55 runs only on the New Architecture, so every native library must support it. SDK 56 moves React Navigation imports to `expo-router` entry points and raises the minimum iOS to 16.4. SDK 57 moves to React Native 0.86 and makes `prebuild` clean by default. One step at a time, each failure maps to one changelog.

code

bash · 11 lines
bash
# Repeat for 55, then 56, then 57
npm install expo@^55.0.0
npx expo install --fix
npx expo-doctor

# With Continuous Native Generation: let the next build regenerate native code
rm -rf android ios
npx expo prebuild

# Build, test the key flows, then commit before the next SDK
git commit -am "chore: upgrade to Expo SDK 55"

go deeper

for a junior

Know the basic loop: install the new expo version, run npx expo install --fix, then rebuild and test.

for a middle

Explain why SDKs are upgraded one at a time and what native folders need after each step.

for a senior

Plan each step's breaking changes in advance, especially the New Architecture switch at SDK 55, and keep every step a tested, committed state.

for a principal

Set an upgrade cadence that never lets the app fall several SDKs behind, because the cost of catching up grows with each skipped release.

## Why one SDK at a time The Expo docs recommend upgrading **incrementally, one SDK at a time**, because it helps you pinpoint breakages. Concretely: - **Each SDK's release notes are written against the previous SDK.** Their "Upgrading your app" instructions and codemods assume you are coming from N-1. - **Deprecations are signposted before they become removals.** Stepping through each SDK lets you see the warnings; jumping straight lands you on the removal with no warning. - **Failures stay attributable.** A crash after one step has a short list of suspects; after a three-SDK jump it could come from any of dozens of changes. - **Each step is a shippable state.** You can stop between steps, release, and continue later. ## Before the first step A little inventory saves most of the pain: - List every library with native code and check its release notes or React Native Directory entry for New Architecture support, since SDK 55 requires it. - Note any deprecated APIs the app still uses, such as `expo-av` or `@react-navigation/*` imports. - Make sure the app has a way to test its key flows on both platforms, even a short manual checklist. ## The loop for each step For a pet-adoption app with pet listings, a camera for profile photos and a favourites tab, each step looks like this: 1. **Bump the SDK:** `npm install expo@^55.0.0` (then 56, then 57), or the equivalent for your package manager. 2. **Align dependencies:** `npx expo install --fix`, which installs the versions the new SDK expects for its React Native. 3. **Health check:** run `npx expo-doctor` for remaining problems. 4. **Native projects:** with Continuous Native Generation, delete generated `android/` and `ios/` so the next build regenerates them; without it, run `npx pod-install` and apply the native upgrade helper's changes. 5. **Read that SDK's release notes** and apply their specific instructions. 6. **Build a development build and test** the flows that matter: browsing pets, taking a profile photo, saving favourites. 7. **Commit** before starting the next step. ## What changes at each step | Step | React Native | Changes worth planning for | |---|---|---| | 54 to 55 | 0.81 to 0.83 | New Architecture always on and cannot be disabled; libraries without New Architecture support break; `expo-av`, deprecated in SDK 54, was slated for removal (use `expo-audio`, `expo-video`); Expo packages switch to SDK-major version numbers | | 55 to 56 | 0.83 to 0.85 | Expo Router no longer supports importing `@react-navigation/*` in app code, so imports move to `expo-router` entry points (a codemod exists); minimum iOS becomes 16.4 | | 56 to 57 | 0.85 to 0.86 | `npx expo prebuild` clears and regenerates native folders by default (`--no-clean` keeps them); React Native 0.86 itself lists no user-facing breaking changes | The 54-to-55 step is the risky one for older apps: SDK 54 was the last SDK where `newArchEnabled` could be set to `false`, so any library still relying on the legacy architecture must be upgraded or replaced **before** that step. ## Things that are not version bumps - **Expo Go** supports only the latest SDK, so testing intermediate SDKs means **development builds**. - **Store requirements** move independently of Expo; the minimum OS versions of each SDK and the stores' requirements both matter. - **OTA updates** built on the new SDK are not compatible with binaries built on the old one, and the runtime version is what keeps them apart; each upgrade ships as a new store build. ## When a step fails - Read the error against that SDK's release notes first; the cause is usually listed there. - Check each third-party native library's release notes for the React Native version you just reached. - Use `npx expo install --check` to confirm nothing drifted after manual edits. - If a library blocks you, choose between a newer release, a replacement, or a temporary `patch-package` patch, and record the decision. ## Why not jump straight to 57 A single jump would combine the New Architecture switch, the import-path move and the prebuild default change in one diff. When the favourites tab crashes on launch, you would not know which of them caused it, and none of the per-SDK instructions would apply cleanly. Three smaller upgrades usually cost less time than one large debugging session.

  • The app uses a native library that only supports the legacy architecture; when must that be solved?
    Before the SDK 55 step. SDK 54 is the last SDK where the legacy architecture can be enabled; from SDK 55 the New Architecture is always on and cannot be disabled. Upgrade the library to a version with New Architecture support, replace it, or stay on SDK 54 until one exists.
  • Can users receive the SDK 57 version of the app as an over-the-air update?
    No. An SDK upgrade changes native code and React Native itself, so the JavaScript built on SDK 57 is incompatible with binaries built on SDK 54. The upgrade ships as a new store build, and later updates target that new build.
  • Why commit between SDK steps?
    Each commit is a known-good state with one SDK's changes. If the next step breaks something, you can bisect or roll back to the last working SDK instead of untangling several upgrades at once, and the history shows which SDK introduced which change.

saying these in an interview costs you the question

  • Jump straight to the newest SDK to save time
  • Bump expo and leave the other packages as they are
  • An SDK upgrade can ship to users as an OTA update
  • The legacy architecture can still be enabled on SDK 55
  • Committed native folders update themselves after an SDK bump