I'm Shipping 3 Apps Simultaneously — Here's How I Automated Everything

Three apps. Two stores. Six metadata configurations. Twelve sets of screenshots. Certificates, provisioning profiles, age ratings, privacy policies, keywords in multiple languages.

When I started publishing my second app, I realized I'd go insane doing everything through the web dashboard. By the time the third one came around, I'd automated nearly everything.

The real problem: the store is more work than the app

Building the app is the fun part. The hell begins when you open App Store Connect or Google Play Console for the first time.

For each app, you need to:

• Create the app ID, configure certificates and provisioning profiles
• Write title, subtitle, description, keywords — in each language
• Generate screenshots for 4+ screen sizes (iPhone 6.7", 6.5", 5.5", iPad)
• Configure age rating (answering ~15 fields about violence and content)
• Set categories, pricing, privacy policy
• Build, sign, upload, wait for review

Multiply that by 3 apps and two stores. That's dozens of hours clicking through web forms.

The good news: all of it can be done from the command line.

The tools I use (and how they complement each other)

After a lot of trial and error, I landed on a stack of 4 tools that cover 100% of the workflow. Each has its role.

Fastlane — the local Swiss army knife

Fastlane is open source, free, and does everything. Automated screenshots, code signing, metadata, upload to TestFlight and Play Store. You define "lanes" (workflows) in a Ruby file and run them from the terminal.

In my Fastfile, I have separate lanes for each operation:

# Local build + TestFlight
fastlane ios build_beta

# Just metadata and screenshots, no build
fastlane ios metadata

# Android build + upload to internal track
fastlane android build_beta

# Promote from internal to production
fastlane android release

Fastlane shines with total control. I can build locally, sign with my certificates, and upload directly — no cloud dependency.

The downside: it runs locally. iOS builds are CPU-intensive and take minutes. And the initial Ruby setup can be annoying if you're not used to it.

ASC CLI — App Store Connect in the terminal

ASC CLI is newer and solves a specific problem: managing App Store Connect without opening a browser.

I use it for things Fastlane also does, but more directly:

# List recent builds
asc builds list --app 6760364479 --limit 5

# Upload IPA
asc builds upload --app 6760364479 --ipa build/reino.ipa

# Push metadata (title, description, keywords)
asc metadata push --app 6760364479 --version 1.3.0 --dir .asc/metadata

# Check auth status
asc auth status

The strength is that it works as a pure CLI — no Ruby, no complex configuration. Install, authenticate, use.

I combined ASC CLI with Node.js scripts to automate more complex tasks like age rating, pricing, and review submission:

# Complete setup for a new app
node scripts/setup-app-store.js    # Pricing, privacy, categories
node scripts/fix-age-rating.js     # Automated age rating
node scripts/upload-ios-screenshots.js  # Screenshots per locale
node scripts/submit-for-review.js  # Submit to Apple Review

EAS (Expo Application Services) — cloud builds

If your apps are Expo/React Native (mine are), EAS is the simplest way to build without needing a Mac.

The free tier gives you 30 builds per month (up to 15 iOS), with lower priority. For 3 apps in active development, that's enough most months.

# Production build and auto-submit to TestFlight
eas build --platform ios --profile production --auto-submit --non-interactive

# Separate submit (if you already have the build)
eas submit --platform ios --latest

Minimal configuration in eas.json:

{
  "submit": {
    "production": {
      "android": {
        "serviceAccountKeyPath": "./google-service-account.json",
        "track": "internal"
      },
      "ios": {
        "ascAppId": "6760364479"
      }
    }
  }
}

EAS solves the biggest pain for anyone without a Mac available 24/7 or who doesn't want to burn local CPU on builds. But when those 30 builds run out, the paid plan starts at $19/month.

GitHub Actions — automated CI/CD

For the most mature flow, I have a workflow that builds and submits automatically on push:

name: EAS Build & Submit
on:
  push:
    branches: [develop]

jobs:
  build-and-submit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - uses: expo/expo-github-action@v8
        with:
          eas-version: latest
          token: ${{ secrets.EXPO_TOKEN }}
      - run: eas build --platform ios --profile preview --auto-submit --non-interactive

Push to develop → automatic build → TestFlight. Push to main → production build → App Store. No manual steps.

GitHub Actions is free for public repos and gives 2000 minutes/month for private ones. Since the heavy building runs on EAS (not GitHub's runner), Action minutes are barely consumed.

The complete workflow: from code to store

With everything configured, my flow for publishing a new version is:

1. Development — code, test on simulator
2. Push to develop — GitHub Actions triggers EAS build → automatic TestFlight
3. Test on TestFlight — install on real iPhone, validate
4. Merge to main — automatic production build
5. Metadata — asc metadata push + fastlane ios metadata for screenshots
6. Submit — node scripts/submit-for-review.js or via dashboard if preferred

From push to TestFlight: zero manual interaction. From TestFlight to App Store: 2 commands.

The angle nobody talks about: AI + CLI = superpowers

Here's what ties everything together. When all store configuration is done via CLI, AI agents can operate the store for you.

I use Claude Code as my SRE — it manages my entire infrastructure via Telegram. And because Fastlane, ASC CLI, and EAS are all CLI-first, Claude can:

• Generate metadata — optimized descriptions, keywords per locale, promotional text
• Execute deploys — run fastlane ios build_beta or eas build --platform ios
• Diagnose issues — "why did the build fail?" → read logs and suggest a fix
• Configure new apps — run setup scripts automatically

This is unthinkable with web interfaces. You can't ask an AI agent to "open App Store Connect, click App Information, change the category to Business." But you can ask: "run asc metadata push with the updated description."

CLI-first tools aren't just convenience — they're the interface that connects humans and AI agents.

Quick comparison

Don't try to use just one

The temptation is to pick one tool and use it for everything. It doesn't work. Fastlane doesn't do cloud builds. EAS doesn't do metadata. ASC CLI doesn't do builds.

The combination that works for me:

• EAS for builds (cloud, no Mac overheating)
• ASC CLI for metadata and App Store Connect management
• Fastlane for screenshots and when I need local builds
• GitHub Actions for automatic triggers

And on top of everything: Claude Code as the orchestrator, running any of these tools when I need them.

The takeaway

If you're publishing more than one app, automate the store before automating the build. The build you set up once and it works. The store is a form-filling hell that changes with every Apple and Google update.

Start with metadata — title, description, keywords. Then screenshots. Then code signing. Every layer you automate saves hours on every future release.

And when everything is CLI, you'll be able to delegate to AI agents. That's the future that's already working here.

If you're building apps and want to accelerate your deploy flow, I do individual mentorship for devs who want to operate at a senior level.