⬡ Dev Tools/2026-03-14Advanced

Moving Six Apps to EAS CI/CD — EAS Build, OTA Updates, and GitHub Actions in Practice

How I moved the build and release pipeline for six indie apps to Expo Application Services: EAS Build for iOS and Android, OTA updates with EAS Update, GitHub Actions integration, and honest notes on free-tier limits.

Rork⁵¹⁵ EAS⁶ Expo¹⁴⁹ CI/CD⁷ OTA⁶ GitHub Actions⁵

✦ Premium Article

Why I moved six apps to EAS — and what broke first

Through the first months of 2026 I was pushing v2.0.0 and v2.1.0 updates across six apps in parallel — most of them wallpaper apps I have been running since going independent in app development back in 2014. Archiving each one in Xcode, uploading to App Store Connect, exporting AABs for Play Console: doing that by hand for six apps swallowed the better part of two days per release wave. And whenever a small bug surfaced afterwards, the whole cycle started over.

Expo Application Services (EAS) is how I got that time back. It builds iOS and Android binaries in the cloud, ships JavaScript-only fixes over the air, and plugs into CI/CD — no local Xcode or Android Studio required, which also means you can build iOS apps without owning a Mac.

One clarification before we start, because the product naming trips people up: since February 2026, Rork generates Expo (React Native) apps for both iOS and Android, while Rork Max is a separate product that generates native Swift apps and compiles them on a cloud Mac fleet — it does not use EAS at all. Everything in this article applies to the Expo (React Native) projects that Rork produces.

What follows is the setup I actually run for my six apps, from first install to production checklist.

Setting up EAS — from the CLI to eas.json

Step 1: Install EAS CLI Globally

npm install -g eas-cli

Verify installation:

eas --version

Step 2: Authenticate with Expo Account

eas login

You'll be prompted to open a browser and log in to your Expo account. If you don't have one, sign up for free at expo.dev.

ℹ️

**Pro Tip**: For CI/CD environments (GitHub Actions, GitLab CI), generate an API token at [expo.dev/settings/access-tokens](https://expo.dev/settings/access-tokens) and store it as the `EXPO_TOKEN` environment variable. This enables passwordless authentication across all pipelines.

Step 3: Initialize EAS Build Configuration

eas build:configure

This command creates an eas.json configuration file in your project root. Below is a comprehensive example with development, preview, and production profiles.

Complete eas.json Configuration

{
  "cli": {
    "version": ">= 5.0.0"
  },
  "build": {
    "development": {
      "distribution": "internal",
      "channel": "development",
      "ios": {
        "buildType": "development",
        "enterpriseProvisioning": "universal-adhoc"
      },
      "android": {
        "buildType": "development",
        "gradleCommand": ":app:assembleDebug"
      }
    },
    "preview": {
      "distribution": "internal",
      "channel": "preview",
      "ios": {
        "buildType": "ad-hoc",
        "provisioning": {
          "teamId": "YOUR_APPLE_TEAM_ID"
        }
      },
      "android": {
        "buildType": "apk",
        "gradleCommand": ":app:assembleRelease"
      }
    },
    "production": {
      "distribution": "store",
      "channel": "production",
      "ios": {
        "buildType": "app-store",
        "provisioning": {
          "teamId": "YOUR_APPLE_TEAM_ID"
        }
      },
      "android": {
        "buildType": "aab",
        "gradleCommand": ":app:bundleRelease"
      }
    }
  },
  "submit": {
    "production": {
      "ios": {
        "appleId": "your-email@example.com",
        "ascAppId": "1234567890",
        "appleTeamId": "YOUR_APPLE_TEAM_ID"
      },
      "android": {
        "serviceAccount": "path/to/service-account.json",
        "track": "production"
      }
    }
  }
}

Profile Breakdown

development: For local testing. Internal distribution via Expo Go
preview: For QA teams. Builds can be shared via QR code or internal testing tracks
production: For App Store / Google Play releases. Generates AAB (Android App Bundle) and App Store-ready iOS builds

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦Working configuration files and step-by-step setup for EAS Build, EAS Update, and GitHub Actions, drawn from running six apps in parallel

✦How to decide when the free tier's 30-builds-per-month quota stops being enough, with real queue-time observations

✦A same-day OTA hotfix walkthrough and a rollback design you can copy

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Building iOS apps with EAS Build

iOS Prerequisites

You'll need an Apple Developer Account to build for iOS. Sign up at developer.apple.com and enroll in the Apple Developer Program ($99/year).

Step 1: Configure iOS Credentials

eas credentials

This interactive command securely stores:

Apple ID email
App-specific password (recommended over account password)
Development and distribution certificates
Provisioning profiles

ℹ️

**Security First**: Never commit credentials to version control. EAS encrypts and manages all credentials server-side. For CI/CD, use `EXPO_TOKEN` instead of your Apple credentials.

Step 2: Create Your First iOS Build

eas build --platform ios --profile production

EAS queues the build and displays a build ID. Monitor progress:

eas build --status

Upon completion, you'll receive a .ipa file ready for TestFlight submission.

Step 3: Submit to TestFlight

eas submit --platform ios --profile production

The app automatically uploads to App Store Connect and becomes available to TestFlight internal testers within minutes.

iOS Configuration Best Practices

{
  "build": {
    "production": {
      "ios": {
        "buildType": "app-store",
        "provisioning": {
          "teamId": "YOUR_APPLE_TEAM_ID"
        },
        "entitlements": {
          "com.apple.developer.networking.vpn": [
            "allow"
          ],
          "com.apple.developer.pass-type-identifiers": [
            "pass.com.example.rorkmax"
          ]
        },
        "buildNumberPattern": "{{YEAR}}.{{MONTH}}.{{DAY}}.{{BUILD_NUMBER}}"
      }
    }
  }
}

Troubleshooting iOS Builds

If builds fail, check:

# List all builds with details
eas build --list --limit=10
 
# View logs for a specific build
eas build --id=BUILD_ID --logs

Common issues:

Certificate expired: Re-run eas credentials to regenerate
Provisioning profile mismatch: Ensure bundle ID matches provisioning profile
Xcode version conflict: EAS automatically uses the latest stable Xcode version

Building Android apps and shipping to Google Play

Android Prerequisites

You'll need a Google Play Developer Account to publish apps. Sign up at play.google.com/console ($25 one-time fee).

Step 1: Configure Android Keystore

eas credentials

EAS can auto-generate a keystore or import an existing one.

Manual Keystore Creation (if needed)

keytool -genkey -v -keystore my-release-key.keystore \
  -keyalg RSA -keysize 2048 -validity 10000 \
  -alias my-key-alias \
  -storepass mypassword \
  -keypass mypassword

Step 2: Build APK or AAB

# APK build (for testing/sideloading)
eas build --platform android --profile preview
 
# App Bundle (for Google Play)
eas build --platform android --profile production

Android Configuration

{
  "build": {
    "production": {
      "android": {
        "buildType": "aab",
        "gradleCommand": ":app:bundleRelease",
        "env": {
          "TARGET_SDK_VERSION": "34",
          "MIN_SDK_VERSION": "24"
        }
      }
    },
    "preview": {
      "android": {
        "buildType": "apk",
        "gradleCommand": ":app:assembleRelease"
      }
    }
  }
}

Step 3: Submit to Google Play

eas submit --platform android --profile production

First, set up a Google Play service account:

Open Google Cloud Console
Create a new project
Enable Google Play Android Developer API
Create a service account with Editor role
Download the JSON key file
Configure in eas.json:

{
  "submit": {
    "production": {
      "android": {
        "serviceAccount": "./path/to/service-account.json",
        "track": "production"
      }
    }
  }
}

Android Multi-Language Support

For apps supporting multiple regions:

{
  "build": {
    "production": {
      "android": {
        "buildType": "aab",
        "env": {
          "LANGUAGES": "en,ja,es,fr,de"
        }
      }
    }
  }
}

EAS Update — shipping fixes without waiting for review

What OTA Updates Can Change

EAS Update distributes changes to JavaScript code and static assets without requiring new app store submissions.

Supported Updates:

React Native / Rork business logic
UI components and screens
API calling logic
StyleSheet and CSS-in-JS styles
Image and font assets

Not Supported:

New native modules
Permission changes
SDK version upgrades
Compiled native code

Deploy an OTA Update

eas update --branch production --message "Critical fix: payment processing crash"

This command:

Builds the JavaScript bundle
Uploads to EAS servers
Immediately distributes to all users on the production branch

Detailed Update with Metadata

eas update --branch production \
  --message "v1.2.1: Improved dashboard performance" \
  --metadata "{\"environment\": \"production\", \"severity\": \"high\"}"

Multi-Branch Release Strategy

# Canary release to 10% of users
eas update --branch production \
  --message "Experimental: new checkout flow" \
  --percent 10
 
# Promote to 50% after monitoring
eas update --branch production \
  --message "Expanding rollout to 50%" \
  --percent 50
 
# Full rollout
eas update --branch production \
  --message "Complete rollout of new checkout" \
  --percent 100

Rollback to Previous Release

# View update history
eas update --list
 
# Rollback to a specific update ID
eas update --branch production --rollback-to-release-id=abc123def456

ℹ️

**Production Practice**: Always validate OTA updates on a staging branch before production rollout. If issues are detected, rolling back takes seconds using `--rollback-to-release-id`.

Scheduled Updates

For non-breaking updates, schedule them to deploy during off-peak hours:

eas update --branch production \
  --message "Scheduled update: 2:00 AM PT" \
  --scheduled

Wiring up CI/CD with GitHub Actions

Complete GitHub Actions Workflow

Create .github/workflows/eas-ci.yml:

name: Rork EAS CI/CD Pipeline
 
on:
  push:
    branches:
      - main
      - develop
  pull_request:
    branches:
      - main
  workflow_dispatch:
 
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
 
jobs:
  test:
    name: Lint & Unit Tests
    runs-on: ubuntu-latest
    timeout-minutes: 15
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18.x"
          cache: "npm"
 
      - name: Install dependencies
        run: npm ci
 
      - name: Run ESLint
        run: npm run lint -- --format json --output-file eslint-report.json || true
        continue-on-error: true
 
      - name: Run tests with coverage
        run: npm run test -- --coverage --silent
 
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage-final.json
          fail_ci_if_error: false
 
  build-preview:
    name: Build Preview (iOS & Android)
    runs-on: ubuntu-latest
    needs: test
    if: github.event_name == 'push' && github.ref == 'refs/heads/develop'
    timeout-minutes: 45
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
 
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18.x"
          cache: "npm"
 
      - name: Install EAS CLI
        run: npm install -g eas-cli
 
      - name: Install dependencies
        run: npm ci
 
      - name: Build iOS Preview
        id: ios-build
        run: |
          eas build \
            --platform ios \
            --profile preview \
            --non-interactive \
            --wait
        env:
          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
 
      - name: Build Android Preview
        id: android-build
        run: |
          eas build \
            --platform android \
            --profile preview \
            --non-interactive \
            --wait
        env:
          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
 
      - name: Comment on PR with preview links
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## ✅ Preview Builds Ready\n\n📱 **Download Preview App:**\n- [iOS Preview](https://expo.dev/accounts/rorklab/projects/rorkmax)\n- [Android Preview](https://expo.dev/accounts/rorklab/projects/rorkmax)\n\n📖 Scan QR code in Expo Go to test changes.`
            })
 
  build-and-deploy-production:
    name: Build Production & Deploy
    runs-on: ubuntu-latest
    needs: test
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    timeout-minutes: 60
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18.x"
          cache: "npm"
 
      - name: Install EAS CLI
        run: npm install -g eas-cli
 
      - name: Install dependencies
        run: npm ci
 
      - name: Get version
        id: version
        run: |
          VERSION=$(node -p "require('./package.json').version")
          COMMIT_SHA=${{ github.sha }}
          echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT
          echo "COMMIT_SHA=${COMMIT_SHA:0:7}" >> $GITHUB_OUTPUT
 
      - name: Build iOS Production
        id: ios-prod
        run: |
          eas build \
            --platform ios \
            --profile production \
            --non-interactive \
            --wait
        env:
          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
 
      - name: Build Android Production
        id: android-prod
        run: |
          eas build \
            --platform android \
            --profile production \
            --non-interactive \
            --wait
        env:
          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
 
      - name: Deploy OTA Update
        id: ota-deploy
        run: |
          eas update \
            --branch production \
            --message "Release v${{ steps.version.outputs.VERSION }} (${{ steps.version.outputs.COMMIT_SHA }})" \
            --non-interactive
        env:
          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
 
      - name: Notify Slack - Success
        if: success()
        uses: slackapi/slack-github-action@v1.24.0
        with:
          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}
          payload: |
            {
              "text": "🚀 Rork Production Deployment Successful",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "*✅ Status*: Success\n*Version*: v${{ steps.version.outputs.VERSION }}\n*Commit*: <${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }}|${{ steps.version.outputs.COMMIT_SHA }}>\n*Branch*: main"
                  }
                }
              ]
            }
 
      - name: Notify Slack - Failure
        if: failure()
        uses: slackapi/slack-github-action@v1.24.0
        with:
          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}
          payload: |
            {
              "text": "❌ Rork Production Deployment Failed",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "*❌ Status*: Failed\n*Version*: v${{ steps.version.outputs.VERSION }}\n*Commit*: <${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }}|${{ steps.version.outputs.COMMIT_SHA }}>"
                  }
                }
              ]
            }
 
  security-scan:
    name: Security & Dependency Check
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
 
      - name: Run npm audit
        run: npm audit --audit-level=moderate || true
 
      - name: Check for vulnerable dependencies
        uses: dependabot/dependabot-cli@v1
        with:
          command: update
          directory: .
          allow-conditions: "(semver:~1.0.0)"

GitHub Secrets Configuration

In your repository, go to Settings > Secrets and variables > Actions and add:

Secret Name	Value
`EXPO_TOKEN`	From expo.dev/settings/access-tokens
`SLACK_WEBHOOK_URL`	Your Slack incoming webhook (optional)

Handling environment variables and secrets safely

Create EAS Secrets

eas secret:create

This securely stores sensitive values like API keys, analytics tokens, and credentials on EAS servers.

Define Secrets per Profile

# Production API key
eas secret:create --scope production --name API_KEY_PROD --value "sk_live_..."
 
# Staging API key
eas secret:create --scope preview --name API_KEY_STAGING --value "sk_test_..."

Access in React Native Code

import Constants from 'expo-constants';
 
export const config = {
  apiKey: Constants.expoConfig?.extra?.apiKey || '',
  environment: Constants.expoConfig?.extra?.environment || 'development',
  logLevel: Constants.expoConfig?.extra?.logLevel || 'warn',
};
 
// Usage in API calls
const headers = {
  'Authorization': `Bearer ${config.apiKey}`,
  'X-Environment': config.environment,
};

Configure per Profile in eas.json

{
  "build": {
    "development": {
      "env": {
        "API_BASE_URL": "http://localhost:3000",
        "ENVIRONMENT": "development",
        "LOG_LEVEL": "debug"
      }
    },
    "preview": {
      "env": {
        "API_BASE_URL": "https://staging-api.rork.dev",
        "ENVIRONMENT": "staging",
        "LOG_LEVEL": "info"
      }
    },
    "production": {
      "env": {
        "API_BASE_URL": "https://api.rork.dev",
        "ENVIRONMENT": "production",
        "LOG_LEVEL": "error"
      }
    }
  }
}

GitHub Actions Environment Variables

In your workflow, pass secrets to EAS commands:

- name: Deploy OTA Update
  env:
    API_KEY: ${{ secrets.PRODUCTION_API_KEY }}
    ANALYTICS_TOKEN: ${{ secrets.ANALYTICS_TOKEN }}
  run: eas update --branch production --non-interactive

ℹ️

**Best Practice**: Never log secrets or pass them in command-line arguments. Use EAS CLI's built-in secret management or GitHub's encrypted environment variables exclusively.

Running QA with preview builds

Generate a Preview Build

eas build --platform ios --profile preview --non-interactive

Once complete, EAS generates a QR code. iOS testers can scan it with Expo Go to instantly test the app.

Share Preview with Team

# Build with a descriptive message
eas build \
  --platform ios \
  --profile preview \
  --message "QA: Payment flow iteration 3" \
  --non-interactive \
  --wait

Android Preview Testing

eas build --platform android --profile preview

The resulting APK can be distributed directly to Android testers, or uploaded to Google Play's internal testing track.

Preview with Debug Menu

For development testing, enable the Expo dev menu:

{
  "build": {
    "preview": {
      "env": {
        "EXPO_DEBUG": "true",
        "LOG_LEVEL": "debug"
      }
    }
  }
}

This allows testers to access performance metrics, network request logs, and reload the app without rebuilding.

Pricing and limits — how far the free tier goes

EAS Free Plan

Build quota: up to 30 cloud builds per month (my six-app setup burns 12 on production builds alone — six apps × two platforms)
Concurrent builds: 1, with lower queue priority during busy hours
EAS Update: usable within the free tier for small-scale delivery

Ideal for: prototyping, personal projects, a once-a-month release cadence

EAS Production Plan (from $99/month)

Build credits: a monthly credit allowance is included, with usage-based billing beyond it
Concurrent builds: multiple builds in parallel
Queue priority: high — builds start promptly even during peak hours

Ideal for: actively developed apps with weekly or faster releases

Cost Optimization Tips

# Cache dependencies to reduce build time
eas build --platform ios --profile production
 
# Check detailed build logs
eas build --status --detailed
 
# Use preview builds for QA (lower priority)
eas build --platform ios --profile preview

Pricing details change over time, so check Expo's official pricing page for the current numbers before committing to a plan.

ℹ️

**Pro Tip**: Batch preview builds on a separate branch to separate QA testing from production release builds. This optimizes build queue usage and costs.

Production release checklist

Before deploying Rork to production, verify:

Pre-Build Verification

[ ] eas.json production profile configured with correct settings
[ ] Apple Team ID and Google Play service account JSON registered
[ ] All required environment variables and secrets created in EAS
[ ] iOS certificates and provisioning profiles valid (not expired)
[ ] Android keystore properly configured and backed up
[ ] app.json version matches intended release version

Testing Phase

[ ] Preview build tested on iOS and Android devices
[ ] End-to-end tests pass (login, API calls, payments)
[ ] Staging API integration verified
[ ] Network error handling (offline, slow connection) tested
[ ] Performance profiling shows acceptable metrics
[ ] Crash analytics (Sentry, Crashlytics) configured

Release Execution

[ ] Git main branch updated with final code
[ ] npm run lint && npm run test passes locally and in CI
[ ] Version numbers updated in package.json and app.json
[ ] Release notes drafted and reviewed
[ ] Team members notified of pending deployment

Post-Deployment Monitoring

[ ] Crash rate monitored in Crashlytics/Sentry (< 0.1% acceptable)
[ ] Analytics dashboard shows expected session count
[ ] User reviews on App Store / Google Play reviewed
[ ] Support queue monitored for new issue reports
[ ] Rollback strategy prepared if critical bugs detected

Rollback Procedure

If critical issues emerge:

# View recent updates
eas update --list --limit=5
 
# Rollback to previous version immediately
eas update --branch production --rollback-to-release-id=PREVIOUS_ID

What months of real-world use taught me

OTA updates earned their keep first. When one of my wallpaper apps shipped with a duplicated-row bug in its list pagination, the fix was JavaScript-only, so eas update delivered it the same day — no review queue, no one-to-two-day wait. Being able to fix a bug the day you find it quietly shows up in your review scores, too.

The free tier's build quota, on the other hand, does not survive six apps. Thirty builds a month sounds generous until production builds alone (six apps × two platforms) consume twelve, and preview builds eat the rest. My compromise: production builds go through EAS, day-to-day testing stays on local development builds and Expo Go, and I only pay for the months when releases pile up. If you ship weekly, the paid plan (from $99/month) pays for itself; for a once-a-month indie cadence, the free tier works with a little discipline.

Queue times deserve a mention as well. On the free tier, builds submitted during US daytime hours sometimes sat for 20–40 minutes before starting. Batching my builds into the JST morning — a quiet window for the build fleet — removed almost all of that friction.

Where to go next

Pick one existing Rork (Expo) project, run eas build:configure, and get a preview build onto your own device. The moment the cloud build finishes and installs from a QR code, you will feel how much of your release routine this can absorb. GitHub Actions integration can wait until the manual flow feels boring.

I hope this saves you a few release weekends. Thank you for reading.

Additional Resources

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

✦Copy-paste ready implementation code
✦New advanced guides published daily
✦$5/mo or $10 for lifetime access

View Membership →

⬡ Dev Tools2026-03-21

Setting Up CI/CD for Rork Apps with GitHub Actions and EAS Build

Learn how to build a complete CI/CD pipeline for your Rork app using GitHub Actions and EAS Build. From automated testing on every pull request to hands-free TestFlight deployment, this guide walks you through the entire setup.

⬡ Dev Tools2026-06-28

Ship EAS Updates to a Few First, and Halt Automatically on Crash Rate

Because OTA updates reach everyone instantly, a bad update reaches everyone instantly too. Here is a three-layer design: ship EAS Update to a small canary, decide expand-or-halt from crash-free rate automatically, and hold a safety net on the device — with working code.

⬡ Dev Tools2026-06-24

When EAS Update Ships but the Bug Won't Die — Why OTA Stalls Silently, and How I Operate Around It

EAS Update can succeed and still fail to reach a slice of your users. These are field notes on runtimeVersion drift, updates that publish but never get adopted, and choosing the right rollback — with the instrumentation that actually helped on my Rork apps.

📚RECOMMENDED BOOKS

Build a Large Language Model (From Scratch)

Sebastian Raschka

LLM Dev

Prompt Engineering for LLMs

* Contains affiliate links

See all →

Moving Six Apps to EAS CI/CD — EAS Build, OTA Updates, and GitHub Actions in Practice

Why I moved six apps to EAS — and what broke first

Setting up EAS — from the CLI to eas.json

Step 1: Install EAS CLI Globally

Step 2: Authenticate with Expo Account

Step 3: Initialize EAS Build Configuration

Complete eas.json Configuration

Profile Breakdown

Continue Reading

Unlock This Article

Building iOS apps with EAS Build

iOS Prerequisites

Step 1: Configure iOS Credentials

Step 2: Create Your First iOS Build

Step 3: Submit to TestFlight

iOS Configuration Best Practices

Troubleshooting iOS Builds

Building Android apps and shipping to Google Play

Android Prerequisites

Step 1: Configure Android Keystore

Manual Keystore Creation (if needed)

Step 2: Build APK or AAB

Android Configuration

Step 3: Submit to Google Play

Android Multi-Language Support

EAS Update — shipping fixes without waiting for review

What OTA Updates Can Change

Deploy an OTA Update

Detailed Update with Metadata

Multi-Branch Release Strategy

Rollback to Previous Release

Scheduled Updates

Wiring up CI/CD with GitHub Actions

Complete GitHub Actions Workflow

GitHub Secrets Configuration

Handling environment variables and secrets safely

Create EAS Secrets

Define Secrets per Profile

Access in React Native Code

Configure per Profile in eas.json

GitHub Actions Environment Variables

Running QA with preview builds

Generate a Preview Build

Share Preview with Team

Android Preview Testing

Preview with Debug Menu

Pricing and limits — how far the free tier goes

EAS Free Plan

EAS Production Plan (from $99/month)

Cost Optimization Tips

Production release checklist

Pre-Build Verification

Testing Phase

Release Execution

Post-Deployment Monitoring

Rollback Procedure

What months of real-world use taught me

Where to go next

Additional Resources

Thank You for Reading

Related Articles