---
title: "Expo Go vs Development Builds: When to Switch"
description: "Expo Go vs development builds explained: what Expo Go can and cannot run, when your React Native app needs a dev build, and the exact Expo CLI commands."
url: "https://arbabnaseer.com/articles/expo-go-vs-development-build/"
lang: "en"
author: "Arbab Naseer"
datePublished: "2026-10-11T00:00:00+05:00"
dateModified: "2026-10-11T00:00:00+05:00"
tags: "Expo, React Native, Expo Go, Expo CLI, EAS Build"
---

# Expo Go vs Development Builds: When to Switch

> Expo Go vs development builds explained: what Expo Go can and cannot run, when your React Native app needs a dev build, and the exact Expo CLI commands.

Arbab Naseer · 2026-10-11 · https://arbabnaseer.com/articles/expo-go-vs-development-build/

**Short answer:** use **Expo Go** to learn, prototype and test apps that only use libraries already included in Expo Go. Switch to a **development build** as soon as you add a library with its own native code, need push notifications on Android, want your real app icon and name on the device, or need to match an older Expo SDK. A development build is your own version of Expo Go, with your exact native code inside.

I use both every week. The React Native work I do on [Stadioss](https://arbabnaseer.com/projects/stadioss-sports-social-network-app/) runs on development builds, while I designed [@tryonit/react-native](https://arbabnaseer.com/projects/tryonit-react-native-expo-virtual-try-on/), my open source virtual try-on package, specifically so it also works inside Expo Go. This guide explains the difference and the exact commands.

## What is Expo Go?

Expo Go is a free app from the App Store and Google Play that runs your React Native project without building it. You start your project with `npx expo start`, scan the QR code, and your JavaScript loads inside Expo Go.

It is the fastest way to see a React Native app on a real phone, with no Xcode or Android Studio needed.

The catch is in how it works. Expo Go is a prebuilt app. It already contains a fixed set of native modules: the Expo SDK libraries (camera, location, image picker, file system and many more) plus a selection of popular community libraries. Your project can use those. It cannot add new native code, because Expo Go was compiled before your project existed.

## What is a development build?

A development build is a debug build of **your own app** that includes the `expo-dev-client` library. It works like Expo Go (you scan a QR code, get fast refresh and the developer menu), but it contains exactly the native libraries, configuration and app identity your project needs.

Think of it this way: Expo Go is a shared playground that many projects use. A development build is your own private playground, built from your `app.json` or `app.config.ts` and your `package.json`.

## Expo Go vs development build: side by side

| | Expo Go | Development build |
|---|---|---|
| Install | Download from the store | Build once (locally or with EAS Build), then install |
| Custom native libraries | Only those bundled in Expo Go | Any library, including your own native modules |
| Config plugins | Not applied | Applied at build time |
| App name, icon, bundle ID | Shows as Expo Go | Your real app identity |
| Push notifications | Limited (remote push not available on Android) | Full support |
| Expo SDK version | Only the version the store app supports | Any SDK version your project uses |
| Rebuild needed when | Never | Only when native code or native config changes |
| Best for | Learning, prototypes, workshops, quick demos | Real products and anything going to the stores |

JavaScript changes never need a rebuild in either mode. You only rebuild a development build when you add or update a native library or change native configuration.

## When you must switch from Expo Go

You need a development build when any one of these is true:

1. **You install a library with native code that Expo Go does not include.** The usual signs are an error like `Native module cannot be null`, `Cannot find native module` or `TurboModuleRegistry.getEnforcing(...): 'X' could not be found`. Common examples are high performance storage, advanced camera and video libraries, payments SDKs and analytics or crash reporting SDKs.
2. **You need remote push notifications on Android.** Expo Go no longer supports them there, so testing push needs a development build.
3. **You use a config plugin** that changes native files, for example to add permissions, URL schemes, Google services files or a custom splash setup.
4. **You need to test deep links, universal links or app links** with your own scheme and domain.
5. **Your project is on an older Expo SDK** than the one the store version of Expo Go supports. Expo Go in the stores supports one SDK version at a time, so after a new SDK release, older projects stop opening in it.
6. **You are close to launch** and want to test exactly what users will get.

If none of these apply, stay in Expo Go. It is faster for everyone on the team.

## How to create a development build

The steps below work for any Expo project. Run them from the project root.

### 1. Install the dev client

```bash
npx expo install expo-dev-client
```

Always use `npx expo install` instead of `npm install` for Expo and React Native libraries. It picks the version that matches your Expo SDK.

### 2a. Build in the cloud with EAS Build (no Xcode or Android Studio needed)

```bash
npm install -g eas-cli
eas login
eas build:configure
eas build --profile development --platform android
```

For iOS, use `--platform ios`. Installing on a physical iPhone needs an Apple Developer account and device registration (`eas device:create`). For the iOS Simulator, set `"ios": { "simulator": true }` in the development profile of `eas.json`.

When the build finishes, EAS gives you a link and a QR code to install it.

### 2b. Or build locally

```bash
npx expo run:android
npx expo run:ios
```

This needs Android Studio (for Android) or Xcode on a Mac (for iOS). Expo generates the native `android` and `ios` folders for you with prebuild, so you do not have to manage them by hand.

### 3. Start the dev server

```bash
npx expo start
```

Once `expo-dev-client` is installed, Expo CLI starts in development build mode. Open your installed development build and scan the QR code, or pick the server from the list inside the app. Press `s` in the terminal to switch between development build and Expo Go mode.

## Useful Expo CLI commands and shortcuts

These are the ones I use most with `npx expo start`:

| Command or key | What it does |
|---|---|
| `npx expo start` | Starts the Metro dev server |
| `npx expo start --clear` | Clears the Metro cache, fixes many "stale code" problems |
| `npx expo start --tunnel` | Works when the phone and computer are on different networks |
| `a` / `i` | Opens the app on an Android emulator or iOS Simulator |
| `r` | Reloads the app |
| `j` | Opens the JavaScript debugger |
| `m` | Toggles the developer menu on the device |
| `s` | Switches between development build and Expo Go |
| `npx expo install --check` | Finds libraries whose versions do not match your SDK |
| `npx expo-doctor` | Checks the project for common configuration problems |

## How I keep a library working in Expo Go

When I built `@tryonit/react-native`, I wanted developers to try virtual try-on without any native build step, because that first five minutes decides whether someone keeps using a library. So the package runs its tracking and rendering engine inside `react-native-webview`, which Expo Go already includes.

The same product files work in Expo Go, in development builds and in bare React Native apps.

If you maintain a library, this is the trade off to think about: native code gives you the most performance and control, but anything Expo Go can already run removes a huge amount of friction for new users. Offering both paths is often the best answer.

## FAQ

### Is Expo Go free?

Yes. Expo Go is free to download from the App Store and Google Play. Development builds are also free to create locally. EAS Build has a free tier with a monthly build allowance, and paid plans for more builds and faster queues.

### Can I publish an app made with Expo Go to the App Store?

You publish your own app, not Expo Go. Any Expo project can be built for the stores with `eas build --profile production` and submitted with `eas submit`. Expo Go is only a development tool, so the final app is always a standalone build with your name and icon.

### Why does my app work in Expo Go but crash in a development build?

Usually a config plugin, permission or environment variable is set up differently. Check that native permissions are declared in `app.json`, run `npx expo-doctor`, rebuild after changing native config, and read the native logs with `adb logcat` on Android or the Xcode console on iOS.

### Do I need to rebuild the development build for every change?

No. JavaScript and asset changes load instantly with fast refresh, just like in Expo Go. You only rebuild when you add, remove or upgrade a library with native code, or change native configuration such as permissions, plugins or the app identifier.

### What is the difference between Expo CLI and EAS CLI?

Expo CLI (`npx expo`) runs on your computer for development: starting the dev server, installing compatible packages and building locally. EAS CLI (`eas`) talks to Expo's cloud services: EAS Build for builds, EAS Submit for store submission and EAS Update for over the air updates.

---

Building a React Native app with Expo and stuck on native modules, builds or store release? I work as a React Native developer with Expo every day. [Get in touch](/contact/).
