Skip to content
Tutorials Center
My learning

Topics

Lesson 53 of 71 ยท Shipping

Builds with EAS and App Store Submission

Build and ship a React Native app with EAS: eas.json profiles, signing credentials, TestFlight and Play Console tracks, version numbers and submission.

Until now your app ran inside Expo Go or a simulator. To put it on real phones you need a binary: an .ipa for iOS or an .aab/.apk for Android, compiled with the native tools of each platform and signed so the operating system trusts it. Doing that by hand means Xcode, Android Studio, certificates and a Mac for iOS. EAS (Expo Application Services) does the building in the cloud, stores your signing credentials and uploads the result to the stores.

This lesson covers the file that drives it all (eas.json), the build profiles you will use, what signing credentials are, how TestFlight and the Play Console test tracks work, and how version numbers must behave so the stores accept your uploads.

Read-only and stand-in. Builds run on Expo's servers and need developer accounts, so every command and file here is read-only. The two TryIts are stand-ins in plain JavaScript: one shows how build profiles inherit from each other, the other how store build numbers behave. Tool versions and store rules change, so check the current EAS and store documentation before your first release.

What you need before the first build

  • An Expo account and the EAS command line: npm install --global eas-cli, then eas login.
  • A unique app identifier per platform in your app config: ios.bundleIdentifier and android.package, for example com.yourcompany.notes. Once an app is published, the identifier cannot change.
  • For iOS, an Apple Developer Program membership (paid, yearly). For Android, a Google Play Console account (a one-time fee).
  • Your project linked to EAS: eas build:configure creates eas.json and registers the project. Project structure and app config are covered in Project Structure and App Config.

eas.json and build profiles

A build profile is a named recipe: "build a development client", "build something testers can install", "build for the store". They live in eas.json:

JSON
{
  "cli": {
    "version": ">= 16.0.0",
    "appVersionSource": "remote"
  },
  "build": {
    "base": {
      "node": "22.11.0"
    },
    "development": {
      "extends": "base",
      "developmentClient": true,
      "distribution": "internal",
      "ios": { "simulator": true }
    },
    "preview": {
      "extends": "base",
      "distribution": "internal",
      "channel": "preview",
      "android": { "buildType": "apk" }
    },
    "production": {
      "extends": "base",
      "autoIncrement": true,
      "channel": "production",
      "env": { "APP_ENV": "production" }
    }
  },
  "submit": {
    "production": {
      "ios": { "ascAppId": "1234567890" },
      "android": { "track": "internal", "releaseStatus": "draft" }
    }
  }
}

Reading it:

  • extends lets a profile inherit another, so shared settings (here a pinned Node version) live in one place.
  • developmentClient: true builds your own version of Expo Go with your native code in it. You use it every day while developing; see Native Modules, Expo Modules and Config Plugins.
  • distribution: "internal" means "not for the store": testers install it from a link. On iOS this needs devices registered in your Apple account (eas device:create); on Android an APK installs directly. ios.simulator: true produces a build for the iOS Simulator instead of a phone.
  • distribution: "store" (the default) builds what you submit to App Store Connect or Google Play: an .ipa, or an Android App Bundle (.aab), which is the format Google Play requires for new apps.
  • channel ties the build to an update channel for over-the-air updates, the topic of the next lesson.
  • env sets environment variables for that build. Remember from Mobile App Security that anything which ends up in the JavaScript bundle is public; use EAS secrets for build-time tokens that must never be in the bundle.

You start a build by naming the profile and platform:

Terminal
# A build for internal testers
eas build --platform all --profile preview

# A store build, submitted automatically when it finishes
eas build --platform ios --profile production --auto-submit

# Build on your own machine instead of Expo's servers
eas build --platform android --profile preview --local

Three profiles, three jobs

development Dev client with your native code.
preview Installable by testers, no store.
production Signed for the App Store and Play.

Keep shared settings in one base profile.

1 / 2

Signing credentials

Phones only install apps whose code is signed by someone they can trace to a developer account. The items differ per platform:

  • iOS: a distribution certificate (proves who you are) and a provisioning profile (ties the app identifier, the certificate and, for internal builds, the allowed devices together). Creating these by hand in the Apple Developer portal is a classic source of pain.
  • Android: a keystore holding the key that signs the app. With Play App Signing, which new apps use, Google keeps the real signing key and you sign uploads with an upload key. If you lose an upload key, Google can reset it; if you lose a key you control completely, the app can never be updated.

On the first build EAS asks to generate these and stores them for you (eas credentials lets you inspect, download or replace them). Letting EAS manage credentials is the easiest option and works for most teams. Treat the files themselves like passwords: never commit a keystore, a .p12 file or a Google service account key to your repository.

From build to store

flowchart LR
    A["Code in Git"] --> B["eas build<br/>production profile"]
    B --> C["Signed .ipa / .aab"]
    C --> D["eas submit"]
    D --> E["TestFlight / Play internal testing"]
    E --> F["Store review"]
    F --> G["Released to users"]

A store build travels through a testing track before review and release.

eas submit uploads a finished build. Useful forms:

Terminal
eas submit --platform ios --latest
eas submit --platform android --profile production

Before the first submission, a few things happen outside the command line:

  • iOS: create the app record in App Store Connect (its numeric ID is the ascAppId above). EAS authenticates with an App Store Connect API key or your Apple ID. Add screenshots, a description, a privacy policy URL and the privacy questionnaire.
  • Android: create the app in the Play Console and complete its store listing and content questionnaires. The first upload of a new app normally has to be done by hand in the Console; after that, eas submit works with a Google service account key (a JSON file, a secret to keep out of Git).

Testing tracks

Both stores give you stages between "uploaded" and "everyone can download it". Use them every time.

TestFlight (iOS)

  • Internal testers are people on your App Store Connect team. Builds appear within minutes after processing, with no review.
  • External testers are anyone you invite by email or public link. The first build of each version needs a short beta review by Apple.
  • Builds expire after a set time, so plan fresh builds rather than relying on an old one.

Play Console tracks (Android)

  • Internal testing: a small group (a few dozen people) gets the build almost immediately.
  • Closed testing: invited testers, larger groups.
  • Open testing: anyone can opt in on the store page.
  • Production: everyone, with an optional staged rollout (for example 10% of users first).

Newly created personal developer accounts on Google Play can have extra testing requirements before production access. Check the Play Console's current rules before planning a launch date.

In eas.json the track option picks the Play track, and releaseStatus: "draft" leaves the release unpublished so you review it in the Console first.

A small but useful config detail on iOS: App Store Connect asks about encryption on every build. If your app only uses standard HTTPS, set ITSAppUsesNonExemptEncryption to false in the app config's ios.infoPlist and the question goes away. Set it only if it is true for your app.

Versioning: version, build number, version code

Three numbers confuse almost everyone, so keep them straight:

Number Shown to users? Rule
version (for example 2.4.0) Yes, on the store page You choose it. Use it for releases people can talk about.
ios.buildNumber No Must increase for every upload of the same version to App Store Connect.
android.versionCode No An integer that must be higher than every earlier upload.

The stores reject a build whose number is not higher than the last one. With "appVersionSource": "remote" and autoIncrement: true, EAS keeps the counters on its servers and bumps them on each production build, so you cannot forget. With local, the numbers come from your app config and you change them yourself. Check the current number with eas build:version:get.

A new version is also the natural moment to change your runtime version if you use over-the-air updates, which is explained in Over-the-Air Updates and Release Strategy.

Stand-in: how profiles inherit

The function below is not the EAS code. It shows the idea behind extends: start from the parent profile, then let the child override it, merging nested objects such as env.

JS Resolving build profiles with extends

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Each profile ends up with the pinned Node version from base, its own API_URL, and the right distribution. Only development overrides LOG_LEVEL. The last lines show why a profile cannot extend itself in a loop.

Stand-in: stores want ever-higher build numbers

This stand-in imitates a store's upload check. A build is accepted only if its number is higher than the last accepted one; the remote counter makes sure that is always true.

JS Why autoIncrement saves you from rejected uploads

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The manual flow fails on the second upload because nobody changed the number. The automatic flow can never repeat a number, which is exactly why teams that ship often prefer it.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What does distribution: "internal" mean in an EAS build profile?

    Internal distribution creates a signed build that testers can install directly, without going through store review.
  2. 2. Which file format does Google Play require for new apps?

    New apps are published as app bundles. APKs are handy for internal installs, such as a preview profile.
  3. 3. You uploaded build number 42 and now upload 42 again with a fix. What happens?

    iOS buildNumber and Android versionCode must increase with each upload. autoIncrement with a remote version source avoids this mistake.
  4. 4. Which item should never be committed to your repository?

    Signing keys and service account keys are secrets. Let EAS store credentials, or keep the files outside Git.
  5. 5. What is the purpose of the TestFlight and Play internal tracks?

    They let you install the real store build, check it on real devices, and only then promote it to a wider audience.

Summary

  • EAS builds signed binaries in the cloud; eas.json defines build profiles (development, preview, production) that can inherit with extends.
  • Internal distribution is for testers, store distribution is for App Store Connect and Google Play (.ipa, .aab).
  • Signing credentials (iOS certificate and profile, Android keystore) can be managed by EAS; never commit them.
  • eas submit uploads builds, but the store listings, privacy answers and the first Android upload happen in the consoles.
  • Use TestFlight and the Play testing tracks before production, and a staged rollout on Android.
  • version is for people, while buildNumber and versionCode must increase on every upload; autoIncrement handles that.

Next, learn how to ship fixes without waiting for review in Over-the-Air Updates and Release Strategy.