I was one of those early adaptors of Expo SDK for developing mobile apps with React Native and had shared my experience of using it over a couple of blog posts. Back in the time I successfully migrated my native android app to RN and could deployed it to Android PlayStore several times leveraging EAS services from Expo. It has been over 6 to 7 years since then, and I have been working on modernizing these apps to latest Expo SDK version compliant with the New React Native Architecture using Claude Code (CC) AI Agent.
In the past I could manage with just Expo Go for my development and am now exploring ways to go beyond to leverage RN components outside of what Expo SDK provides. This means some learning curve on the habits to change and this post is just that summarizing my take on the different options and the reasons you may want to choose one over the other.
Building and deploying React Native applications with Expo has never been more powerful or more diverse. While the initial setup is wonderfully simple, scaling your app to include custom native modules, continuous integration, and store submission introduces a spectrum of deployment modes.
Whether you are spinning up your first test on your phone or configuring a complex cloud CI/CD pipeline, this guide breaks down every mode of Expo app deployment, what each offers, and the exact steps to execute them.
The Build Path at a Glance
Before we dive into the details, here is a visual overview of how the different build and deployment strategies interconnect:
1. Expo Go: The "Fastest Start" Mode
Expo Go is a pre-compiled, bundled application containing a vast array of Expo SDKs (like camera, filesystem, and location modules). It acts as a sandbox environment to run your JavaScript immediately without compiling native code.
1.1 What it Offers
- Instant Gratification: No Android Studio, and no build times.
- Live Reload: Extremely fast live reloading and hot-module replacement.
- Easy Sharing: Scan a QR code to run the app on any device with the Expo Go app installed.
1.2 The Steps
- Initialize or navigate to your Expo project.
- Run the start command: `npx expo start`
- Press `a` for Android Emulator, or scan the QR code with your physical device.
The Catch: Expo Go only supports the native modules bundled within its specific SDK version. If you need a third-party package with custom native code (like react-native-vision-camera), you must graduate to the next mode.
2. Expo Prebuild & Continuous Native Generation (CNG)
When you need complete flexibility but still want Expo's ecosystem, you utilize "Prebuild". This relies on Continuous Native Generation (CNG) to read your `app.json` config plugins and dynamically generate your native android directories.
2.1 What it Offers
- 100% Native Flexibility: You can install and link any native React Native module.
- Development Client: By installing expo-dev-client, you get the live-reload comfort of Expo Go, but within your own custom native application.
2.2 The Steps
- Generate the native directories (this wipes and rebuilds based on `app.json`):
```
npx expo prebuild
# If you change config plugins later, you can run:
npx expo prebuild --clean
``` - Build and run the app locally on your simulator or connected device:
```
npx expo run:android
```
3. Local Native IDEs: Android Studio
If you come from a native Android background, or if you need to manually inspect the native code, you can use the directories generated by Prebuild directly inside traditional IDEs.
3.1 What it Offers
- Familiar Debugging: Access to the Android Studio logcat, and native build variants.
- Standalone Release Builds: You can build `.apk` or `.aab` files manually without cloud tools.
3.2 The Steps For Android (Android Studio):
- Open the android folder in Android Studio.
- To test locally, hit the Play button (ensure Metro is running).
- To generate a release build manually, open the Build Variants tab on the bottom left, switch the variant from debug to release, and navigate to Build > Generate Signed Bundle / APK. Alternatively, you can use Gradle from the CLI:
```
cd android && ./gradlew assembleRelease
```
4. Expo Application Services (EAS) Build
Expo Application Services (EAS) is the modern, robust way to compile and distribute Expo apps. It is a hosted CI/CD service that manages your native builds and handles code signing automatically. Through the `eas.json` file, you can explicitly define different app "Modes" or Profiles: Development, Preview, and Production.
4.1 What it Offers
- EAS Update & Metadata: Seamless integration for Over-The-Air (OTA) updates and App Store deployments.
- Local EAS Builds: Emulate the cloud build pipeline on your local machine using Fastlane under the hood (free and infinite, though requires a Mac for iOS).
- No Mac Required for iOS (Bonus): Windows/Linux users can build for iOS using EAS Cloud.
4.2 Understanding EAS Profiles (eas.json)
When you run `eas build:configure`, Expo generates an `eas.json` file that looks something like below:
```json
{
"build": {
"development": {
"developmentClient": true,
"distribution": "internal",
"ios": { "simulator": true }
},
"preview": {
"distribution": "internal"
},
"production": {}
}
}
```
Here is how the 3 primary modes function:
A. Development Profile
- Purpose: Creates a build featuring the expo-dev-client.
- Usage: Installed on your simulator or internal devices. It acts as your own personal "Expo Go" that includes your custom native plugins.
- Distribution: Set to internal.
B. Preview Profile
- Purpose: Staging/QA environments. It builds a standalone application pointing to your staging APIs.
- Usage: Used to distribute release-like builds to your team via EAS internal distribution or to run automated E2E tests.
- Distribution: Set to internal.
C. Production Profile
- Purpose: The final build for the Google Play Store.
- Usage: Strips all development menus. Generates optimized `.aab` artifacts ready for store submission.
4.3 The Steps (Cloud & Local) to build your expo app using EAS:
1. Install the CLI and log in:
```
npm install -g eas-cli
eas login
```
2. Configure the project: `eas build:configure`
3. Run a Cloud Build:
```
eas build --profile development --platform android
# Or --profile preview / production
```
4. Run a Local EAS Build: `eas build --profile development --platform android --local`
4.4 Quick Summary of EAS
Choosing your deployment mode comes down to your current stage in the development lifecycle:
- Prototyping standard features? Stick to Expo Go.
- Need native modules locally? Use Prebuild (`npx expo run:android`).
- Ready to test on team devices? Use EAS Build (Development Profile).
- Staging for a client? Use EAS Build (Preview Profile).
- Ready to launch? Use EAS Build (Production Profile) and EAS Submit.