Getting Started with Expo

After working through this course you will be able to build and ship a real iOS application with Expo. You will know what Expo adds on top of React Native, how to migrate an existing Xcode project to it without throwing away your native code, how to compare the two development loops honestly, and how to take an app all the way to a TestFlight build that testers can install on a physical device.

What Expo is

Expo is a framework and a set of services for building cross-platform applications with React Native. React Native renders real native views, so the result is not a web page in a wrapper; Expo adds the parts of the toolchain that React Native deliberately leaves out:

  • a curated set of native modules for the camera, notifications, location, secure storage and a few hundred other things, all with a consistent API;
  • Expo Go, a client app that runs your project on a real device without any build step at all;
  • EAS Build, a hosted build service that produces signed binaries for you, so a machine without Xcode can ship an iOS app;
  • EAS Update, which pushes JavaScript and asset changes to installed apps over the air without a new store release;
  • Expo Router, a file-based router that generates the route tree from the folder structure.

The result is a workflow where most of your time is spent writing application code, and the native project is something you generate on demand rather than something you maintain by hand.

Who this course is for

You should already be comfortable with Xcode, Swift or Objective-C, and native iOS concepts such as a view controller, a build configuration, a provisioning profile and an app bundle identifier. This course does not re-teach iOS; it teaches the parts of Expo that a native developer has to unlearn first.

You should also be able to read JavaScript and TypeScript. React knowledge helps, but the course explains the React pieces as they appear.

What you need before you start

RequirementWhy
Node.js 18 or newer, with npmThe Expo CLI, the bundler and every build script run on Node
Xcode with the iOS simulatorFor running the app locally and for the native debugging walkthrough
An Apple Developer accountRequired for TestFlight; a free account is enough for simulator work
The Expo accountUsed by EAS Build and EAS Update; create it with eas login

The course map

  1. Why native developers need Expo - what the framework actually gives you, the mental model shift, and where it does not fit.
  2. Core feature comparison and collaboration - the two development loops side by side, and how Expo and Xcode work together rather than against each other.
  3. Building an iOS feature, compared to the Xcode workflow - the same feature, camera capture and saving to the photo library, implemented twice.
  4. Building for iOS and shipping to TestFlight - EAS Build, App Store Connect, eas submit, and over-the-air updates.

The order matters. The comparison pages assume you know what Expo is, and the build page assumes you know which workflow you are actually using.

The whole thing in five minutes

If you want to see the shape of the workflow before reading anything else, run these commands.

# Create a project with the current template.
npx create-expo-app@latest my-first-expo-app
cd my-first-expo-app

# Start the development server.
npx expo start

Scan the QR code with the Expo Go app on your phone, or press i in the terminal to open the iOS simulator. The default template renders a text input and some styled text. Change App.tsx, save the file, and the screen updates immediately - that is Fast Refresh, and it is the closest thing React Native has to Xcode’s live view.

The three ways to run an Expo app

Choosing the right one is the single most important decision in the first hour of a project.

  1. Expo Go - the prebuilt client from the app store. Nothing to compile, so the loop is instant. It can only use the modules that ship inside Expo Go, so a library with custom native code will not work.
  2. A development build - your own binary, built with npx expo run:ios or with EAS Build, that contains exactly the native modules your app needs. Use it as soon as you add a library that Expo Go does not include.
  3. A production build - the signed archive you upload to TestFlight or the App Store. Built with eas build --platform ios --profile production.

A useful rule: start with Expo Go, and switch to a development build the first time you install a package that ships native code. Everything else in this course assumes that progression.

Practice

Before you continue, answer this: you have a working iOS app written in Swift with a SwiftUI interface, a notification permission flow, and a subscription purchase implemented with StoreKit 2. You are asked to add an Android version and to let the team ship bug fixes without waiting for a store review.

Which parts of this course answer that request, and which parts of the existing app would you expect to keep?

ExpoReact NativeXcodeCross-PlatformEAS Update

Approach:

The question has two halves - “add Android” and “ship fixes faster” - and they are solved by two different parts of Expo. The first is answered by React Native’s cross-platform promise, which the course explains in the first chapter. The second is answered by EAS Update, which the last chapter covers in detail. The third part of the question - what survives the migration - is answered by the native boundary.

Steps:

  1. Android support comes from writing the interface in React Native rather than SwiftUI. The course chapters on Expo and on the Xcode comparison cover what the shared code looks like and what has to be rewritten per platform.
  2. Faster shipping of fixes is EAS Update, which pushes JavaScript and assets to installed apps over the air. The last chapter shows the runtimeVersion setting that decides which builds can receive an update, and the eas update command that publishes one.
  3. The native code stays native. Expo does not replace Swift or Objective-C. Anything implemented in Swift - a custom camera preview, a Core ML model, a StoreKit wrapper - can stay in Swift and be reached from JavaScript through the Expo Modules API. That is covered in the comparison chapter.
  4. The subscription is the hard part. StoreKit 2 purchases are native Apple code. They can be called from an Expo app through a custom native module, but they cannot be shared with Android, because Android uses a different billing system. Expect to write two thin native modules and one shared JavaScript layer on top of them.

Answer:

Part of the requestAnswerWhere it is covered
Add an Android versionRewrite the interface in React Native, keep the native pieces behind the Expo Modules APIChapters 1 and 2
Ship fixes without a store reviewEAS Update, with runtimeVersion controlling which builds can receive itChapter 4
Keep the Swift codeYes - Swift modules still run natively, reached from JavaScriptChapter 2
Keep StoreKit 2 as it isYes, but it stays iOS-only; Android needs its own billing moduleChapter 2
Keep the SwiftUI interfaceNo - the interface is rewritten in React Native componentsChapter 3

Found an issue with this content?

Tell us what could be improved.