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:
- Which source revision is being built?
- Which environment and configuration are included?
- Who or what is signing the Android and iOS artifacts?
- Where can the team download and verify the artifacts?
- 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.
| Approach | Best fit | Strengths | Trade-offs |
|---|---|---|---|
| EAS Build with GitHub Actions | Expo and Expo-compatible React Native apps | Managed build infrastructure, profiles, credentials, and artifact access | Requires careful EAS configuration and attention to service limits or plan changes |
| GitHub Actions with native commands | Bare React Native apps or projects needing full build control | Direct control over Gradle, Xcode, caching, and custom scripts | More maintenance for runners, SDKs, certificates, and build failures |
| Hybrid workflow | Teams that want hosted builds but native release automation | Separates source checks, builds, store submission, and internal approvals | More 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
- Merge the release candidate after tests and review pass.
- Update the human-readable version and platform build numbers using one documented convention.
- Create a tag that identifies the exact source revision.
- Build Android and iOS artifacts with production configuration.
- Run release smoke tests on representative devices. The React Native end-to-end testing guide covers Detox, Maestro, and device setup considerations.
- Upload to internal testing or a staged track before wider distribution when the store and product process support it.
- Monitor crash reports, login, deep links, push notifications, payments, and other release-critical flows.
- Keep the previous known-good artifact and document the rollback action before starting the rollout.
Troubleshooting matrix
| Symptom | Likely area | Checks |
|---|---|---|
| Build cannot resolve dependencies | Toolchain or cache | Compare Node, Java, Gradle, CocoaPods, Xcode, and lockfile versions; clear or refresh caches before changing dependencies. |
| Signing credential is rejected or expired | Credential store | Verify 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 identity | Environment configuration | Inspect the Android application ID, iOS bundle identifier, EAS profile, schemes, flavors, and injected variables. |
| Release works locally but fails in CI | Undeclared local state | Check uncommitted files, local credentials, shell variables, generated native files, case-sensitive paths, and runner-specific tools. |
| Production build points to staging services | Build-time configuration | Print 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 wrong | Release validation | Confirm 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.