React Native CI/CD Guide: EAS Build, GitHub Actions, Signing, and Store Releases
React NativeCI/CDEAS BuildGitHub ActionsApp Publishing

React Native CI/CD Guide: EAS Build, GitHub Actions, Signing, and Store Releases

NNative Dev Hub
2026-11-21
8 min read

A practical React Native CI/CD guide covering EAS, GitHub Actions, signing, release estimates, artifacts, staged rollout, and rollback.

Automating React Native releases means more than running a build command in the cloud. This guide shows how to design a repeatable CI/CD workflow with GitHub Actions, Expo Application Services (EAS), or native Android and iOS tooling; estimate the effort and operational cost of each approach; protect signing credentials; validate release candidates; and publish with a rollback plan.

Overview

A dependable React Native CI/CD pipeline should answer five questions for every release:

  1. Which source revision is being built?
  2. Which environment and configuration are included?
  3. Who or what is signing the Android and iOS artifacts?
  4. Where can the team download and verify the artifacts?
  5. How will the release be staged, monitored, and reversed if necessary?

The right implementation depends on the project’s native footprint. An Expo project using a managed workflow can usually delegate much of the build infrastructure to EAS. A project with custom native modules, multiple flavors, or specialized Xcode and Gradle configuration may use EAS with native configuration or run builds on self-managed or hosted macOS and Linux runners. The goal is not to eliminate every manual decision. It is to make each decision explicit and reproducible.

ApproachBest fitStrengthsTrade-offs
EAS Build with GitHub ActionsExpo and Expo-compatible React Native appsManaged build infrastructure, profiles, credentials, and artifact accessRequires careful EAS configuration and attention to service limits or plan changes
GitHub Actions with native commandsBare React Native apps or projects needing full build controlDirect control over Gradle, Xcode, caching, and custom scriptsMore maintenance for runners, SDKs, certificates, and build failures
Hybrid workflowTeams that want hosted builds but native release automationSeparates source checks, builds, store submission, and internal approvalsMore moving parts and more places to audit secrets

How to estimate

Before choosing a provider or writing a workflow, estimate the pipeline using inputs your team can measure. This avoids treating CI/CD as a one-time setup project when its ongoing maintenance is usually the larger concern.

1. Count the release paths

List the combinations that must be built and tested. A simple app might have one Android and one iOS production artifact. A larger app may add development, preview, staging, and production profiles, plus Android product flavors or separate application identifiers. Use this formula:

Release paths = platforms × environments × variants

For example, two platforms, three environments, and two Android variants produce up to twelve paths before accounting for pull-request checks or hotfix builds. Not every path needs a store submission, but each should have an owner, configuration source, and validation rule.

2. Estimate build volume

Separate validation builds from release builds:

Monthly build demand = pull-request builds + branch builds + release builds + retry allowance

Use your repository history to estimate pull-request frequency, then add a conservative retry allowance for dependency failures, signing mistakes, and canceled jobs. This number helps you compare hosted build usage, runner capacity, queue time, and the maintenance cost of self-managed infrastructure. Do not estimate only from the number of developers; build volume is driven by branch policy and release cadence.

3. Estimate human effort

Track the time spent on four activities over one or two release cycles:

  • Pipeline maintenance, including dependency and runner updates.
  • Credential and certificate renewal.
  • Investigating failed builds or environment-only bugs.
  • Manual release preparation, verification, and store submission.

Operational effort = maintenance + credential work + failure investigation + release handling

A managed EAS workflow may reduce infrastructure maintenance, while a native workflow may provide more control at the cost of additional configuration. Compare the total effort, not just the visible build charge. Record assumptions in the repository so the estimate can be recalculated after a framework, Xcode, Android, or CI-provider change.

4. Estimate release risk

Use a simple risk register rather than an unsupported percentage. For each release path, record whether it has automated tests, a reproducible build, protected signing credentials, a review gate, a staged rollout option, and a rollback procedure. A path missing several controls should not be treated as equivalent to a production path with all of them.

Inputs and assumptions

Keep these inputs visible in a release document or repository README:

  • Toolchain: React Native version, Expo SDK when applicable, Node.js version, package manager, Java version, Android Gradle Plugin, Gradle version, Xcode version, and minimum platform versions. Pin or explicitly manage versions where possible.
  • Identifiers: Android application ID and iOS bundle identifier for every environment. A mismatch can create a build that signs correctly but cannot be installed or submitted where intended.
  • Profiles: Development, preview, staging, and production profiles should differ deliberately. Define their distribution type, update channel or runtime configuration, build numbers, and environment variables.
  • Secrets: Store tokens, keystores, passwords, certificates, provisioning data, and signing credentials in the CI provider or EAS credential system. Do not commit them to the repository or print them in logs.
  • Artifacts: Decide how long Android packages, iOS archives, mapping files, test reports, and release notes remain available. Retain enough information to investigate a production issue.
  • Approval rules: Require review before production builds and keep store submission separate from ordinary pull-request checks.

For Android, the release pipeline must use the intended application ID, signing key, and version configuration. Back up the keystore through an approved secret-management process and document who can rotate or restore it. For iOS, maintain the relationship between the bundle identifier, certificates, provisioning profiles, App Store Connect access, and the selected Xcode project settings. Prefer short-lived or narrowly scoped credentials where the platform and tooling support them.

Environment variables should describe configuration, not replace secret management. Public API base URLs may be injected into a build, but private tokens should never be bundled into a mobile application because shipped app code can be inspected. For authentication tokens and other runtime secrets, use platform-secure storage as described in the React Native Secure Storage Guide.

Worked examples

Example A: Expo application using EAS

A practical Expo workflow starts with separate EAS profiles in eas.json. Keep development and production settings distinct, then invoke builds from a protected branch or an approved release tag.

{
  "build": {
    "development": {
      "developmentClient": true,
      "distribution": "internal"
    },
    "preview": {
      "distribution": "internal"
    },
    "production": {}
  }
}

The exact profile fields should match the project’s Expo and EAS versions. A typical local verification sequence is:

npm ci
npx expo-doctor
npx eas build --profile preview --platform all

In CI, authenticate with a protected token, select the intended profile, and upload the resulting artifact or build URL to the workflow summary. Use production credentials only in a job that is gated by review or a release tag. Store the build identifier, commit SHA, profile name, and environment in release notes.

Example B: Native GitHub Actions workflow

A bare React Native project can run JavaScript checks on every pull request and reserve native builds for protected branches. A simplified workflow template might look like this:

name: mobile-release

on:
  pull_request:
  push:
    tags:
      - 'v*'

jobs:
  checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
          cache: 'npm'
      - run: npm ci
      - run: npm test -- --runInBand
      - run: npx tsc --noEmit

  android:
    if: startsWith(github.ref, 'refs/tags/')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: cd android && ./gradlew bundleRelease
      - uses: actions/upload-artifact@v4
        with:
          name: android-release
          path: android/app/build/outputs/**/*.aab

  ios:
    if: startsWith(github.ref, 'refs/tags/')
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: bundle exec fastlane ios release

This is a template, not a drop-in production workflow. Pin action versions according to your organization’s policy, install the required Ruby and CocoaPods dependencies, configure signing, and validate the current runner images. For iOS, a lane-based tool such as Fastlane can centralize archive and submission steps, but the credentials still need to be managed outside the repository.

Release sequence

  1. Merge the release candidate after tests and review pass.
  2. Update the human-readable version and platform build numbers using one documented convention.
  3. Create a tag that identifies the exact source revision.
  4. Build Android and iOS artifacts with production configuration.
  5. Run release smoke tests on representative devices. The React Native end-to-end testing guide covers Detox, Maestro, and device setup considerations.
  6. Upload to internal testing or a staged track before wider distribution when the store and product process support it.
  7. Monitor crash reports, login, deep links, push notifications, payments, and other release-critical flows.
  8. Keep the previous known-good artifact and document the rollback action before starting the rollout.

Troubleshooting matrix

SymptomLikely areaChecks
Build cannot resolve dependenciesToolchain or cacheCompare Node, Java, Gradle, CocoaPods, Xcode, and lockfile versions; clear or refresh caches before changing dependencies.
Signing credential is rejected or expiredCredential storeVerify the identifier, certificate or keystore, expiration, access scope, and CI secret name. Test a controlled rotation rather than replacing several credentials at once.
Artifact has the wrong app identityEnvironment configurationInspect the Android application ID, iOS bundle identifier, EAS profile, schemes, flavors, and injected variables.
Release works locally but fails in CIUndeclared local stateCheck uncommitted files, local credentials, shell variables, generated native files, case-sensitive paths, and runner-specific tools.
Production build points to staging servicesBuild-time configurationPrint non-secret configuration in a safe diagnostic step, verify profile selection, and test the artifact itself rather than only the source branch.
Store upload succeeds but app behavior is wrongRelease validationConfirm runtime configuration, native permissions, deep links, push notification setup, and migration behavior on a clean install and upgrade.

When to recalculate

Revisit the estimate and workflow whenever an input changes. That includes a React Native or Expo upgrade, a new Xcode or Android toolchain, a new environment or app flavor, a change in release frequency, a CI-provider plan or pricing change, a certificate renewal, or a move from internal testing to public distribution.

Also recalculate after three practical signals: build queues become disruptive, engineers repeatedly repair the same failed job, or a release requires undocumented manual steps. Compare the new build volume, artifact retention needs, runner time, credential work, and failure-investigation time with the previous baseline. If the pipeline has grown, split fast pull-request checks from slower release jobs and keep production signing behind an explicit approval.

Before each production deployment, use this short checklist:

  • Confirm the tagged commit, version, build number, profile, and app identifiers.
  • Confirm secrets are available without exposing their values in logs.
  • Verify Android and iOS signing assets and their renewal owners.
  • Run unit, type, and release smoke tests.
  • Save artifacts, checksums or build identifiers, and release notes.
  • Define the staged rollout, monitoring window, and rollback artifact.

A CI/CD system becomes reliable when another developer can reproduce its decisions from the repository, workflow history, and release record. Keep those records current, recalculate the operational assumptions when the project changes, and treat signing and rollback as first-class parts of React Native app publishing rather than last-minute store tasks.

Related Topics

#React Native#CI/CD#EAS Build#GitHub Actions#App Publishing
N

Native Dev Hub

React Native Editor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.