Building and Signing Game Builds for App Store

Building and Signing Game Builds for App Store

In our practice, a common scenario: Xcode Organizer shows "Upload Successful", but App Store Connect sends an email — "Missing required icon", even though icons are set in Assets.xcassets. Or a build succeeds, but a TestFlight build crashes on launch with SIGABRT because the Enable Bitcode = NO flag wasn't removed for one plugin in the Release configuration. Such incidents delay releases by an average of a day and eat significant budgets. The iOS build process for App Store is a manageable pipeline with a dozen failure points. We take over setting up a reliable compilation, signing, and upload pipeline so you can focus on game design.

What Problems Arise Without a Proper Pipeline?

Code signing chaos. For an average Unity project with 15+ plugins, there are multiple provisioning profiles, manual management of Developer and Distribution certificates, tangled Capabilities (Push Notifications, In-App Purchase, Game Center, Sign in with Apple). When compiling on a CI machine without the proper certificates in Keychain, you get No signing certificate "iOS Distribution" found. Fastlane Match solves this systematically: certificates and profiles are stored in a git repository (encrypted), and CI fetches them via match(type: "appstore") — no manual .p12 export. This approach reduces signing errors by 90%.

Entitlements. Unity generates Unity-iPhone.entitlements when exporting the Xcode project. If Automatically Sign is enabled at the wrong moment, Xcode overwrites entitlements, removing manually added capabilities. The PBXProject API in Unity (via UnityEditor.iOS.Xcode) allows you to programmatically add entitlements in a post-build script — this is more reliable than manual editing. In 30% of projects we discover mismatches in Capabilities, leading to crashes on launch.

Incrementing build number. App Store Connect does not accept a build with the same CFBundleVersion as the previous one — even if CFBundleShortVersionString changed. With manual compilation, this is forgotten in about 30% of cases. Automation via Fastlane: increment_build_number(build_number: latest_testflight_build_number + 1).

How We Automate Build and Signing

The base tool is Fastlane with Gymfile for iOS. Unity-specific: before calling gym, a Unity compilation step is needed via command line:

Unity.exe -batchmode -executeMethod BuildScript.BuildiOS -projectPath . -logFile build.log -quit

BuildScript.BuildiOS uses BuildPlayerOptions to set BuildTarget.iOS, BuildOptions.Il2CPP, and configure PlayerSettings for the specific build (bundle ID, version, icons).

After exporting the Xcode project — post-build processing via PostProcessBuild attribute: we add required frameworks, tweak Info.plist (NSPhotoLibraryUsageDescription, Privacy manifest for iOS 17+), set linker flags for plugins with Objective-C categories.

Signing and archiving via xcodebuild archive, then xcodebuild -exportArchive with a .plist configuration ExportOptions.plist (signing method app-store, correct provisioning profile per bundle ID, enable bitcode if needed).

Upload to App Store Connect via xcrun altool --upload-app or through Fastlane deliver/pilot. pilot for TestFlight allows immediate assignment of tester groups and setting release notes.

What Our Pipeline Setup Includes

For a reliable pipeline, we include:

• Setup of Fastlane Match and storage of certificates in a git repository.
• Development and integration of PostProcessBuild scripts for your plugins.
• CI/CD configuration (GameCI + GitHub Actions) with full cycle: compilation → signing → upload to TestFlight.
• Documentation of the process and team training (1–2 hours).
• Support for one month after implementation.

Why Choose Automation?

Manual compilation takes up to 2 hours per release, and Code Signing errors delay publication by an average of a day. Automation reduces time to 15 minutes and eliminates human error. According to Apple, studios with CI/CD publish updates 40% faster.

We have implemented over 100 projects for setting up pipelines for mobile and console games. Our experience: 5+ years in game dev, dozens of successful releases on the App Store.

Core Tools for the Pipeline

Timelines

Cost is calculated after an audit of your current CI infrastructure and certificate/profile state. Request an audit of your pipeline — we will assess your project and propose an optimal solution. Contact us for details.

Manual pre-release preparation as a source of delays

We automate the entire pre-release pipeline for mobile and XR games. A studio is about to release a game — a week before the date, the manager remembers they need to build an AAB, sign it, and upload to Google Play. The build engineer manually starts the build, waits an hour, forgets to enable IL2CPP, the build crashes on Android 12. Rebuilding takes another hour. Simultaneously, the icon needs to be redesigned to meet new Google requirements. As a result, the release is delayed by three days. Experience shows: manual pre-release preparation is the primary source of delays and bugs that do not manifest on the developer's machine.

How to set up CI/CD for mobile game builds?

Pipeline tools

GameCI — open-source Docker images for Unity builds, running on GitHub Actions, GitLab CI, or any other CI provider. Key components: unity-builder (builds for the target platform), unity-test-runner (runs Unity Test Framework before build), unity-return-license (returns the license — critical for Pro). Unity Cloud Build is simpler but less flexible and expensive for frequent builds. Fastlane is the standard for final steps: signing, uploading to stores, metadata.

Typical pipeline

jobs:
  test:
    name: Run Unity Tests
    uses: game-ci/unity-test-runner@v4
    with:
      unityVersion: 2022.3.20f1
      testMode: playmode

  build-android:
    name: Build Android
    needs: test
    uses: game-ci/unity-builder@v4
    with:
      targetPlatform: Android
      androidKeystoreBase64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
      androidKeystorePass: ${{ secrets.KEYSTORE_PASSWORD }}
      androidKeyaliasPass: ${{ secrets.KEY_PASSWORD }}

  upload-to-play:
    name: Upload to Google Play (Internal Track)
    needs: build-android
    uses: r0adkll/upload-google-play@v1
    with:
      serviceAccountJsonPlainText: ${{ secrets.SERVICE_ACCOUNT_JSON }}
      packageName: com.yourcompany.yourgame
      releaseFiles: build/Android/*.aab
      track: internal

Secrets, not variables — all keys in CI secrets. AAB instead of APK has been mandatory for several years. Tracks: internal → closed → open → production. Promotion — manual or Fastlane supply promote.

iOS specifics

Unity builds an Xcode project, then xcodebuild. Need Distribution Certificate and Provisioning Profile (App Store). Fastlane Match solves the problem of certificate synchronization within the team:

lane :build_ios do
  match(type: “appstore”, readonly: true)
  build_app(workspace: “Unity-iPhone.xcworkspace”,
            scheme: “Unity-iPhone”,
            export_method: “app-store”)
  upload_to_testflight
end

App Store Connect API Key replaces login/password, does not break with 2FA.

Step-by-step pipeline setup

1. Audit Unity PlayerSettings (Graphics APIs, Scripting Backend, stripping).
2. Create CI configuration with GameCI — define test, build, and deploy jobs.
3. Integrate Fastlane for code signing and store uploads.
4. Store all secrets (keystore, certificates, API keys) in encrypted CI variables.
5. Run a test release on internal track, verify end‑to‑end.

Each step includes validation: build must pass on a clean runner, not just a local machine.

Why does App Store reject about a third of first submissions?

Apple rejects 30–40% of first submissions from new studios. Common reasons:

Practice: before submission, go through the App Store Review Guidelines from start to finish — 2–3 hours, saving 2–3 weeks of resubmission loops.

Google Play is more lenient: typical reasons — outdated targetSdkVersion, excessive permissions, incorrect Data Safety Form.

Deliverables of pre-release preparation

We deliver the following for your game release:

• CI/CD pipeline configured (GameCI + Fastlane, Unity Cloud Build — turnkey)
• Metadata and marketing assets (screenshots, icons, feature graphics)
• Store submission guidance with documentation of all accesses and credentials
• 72‑hour post‑release monitoring (Crashlytics, ANR rate, user reviews)
• Pipeline documentation and team training session (hands‑on)
• Age rating configuration (IARC, ESRB, PEGI, CERO) and localization of store metadata

Pipeline automation replaces the manual work of an entire department. For example, setting up Continuous Integration via GameCI and Fastlane reduces pre‑release preparation time threefold — from 8 working hours to 2.5.

Our pre-release workflow: from audit to store submission

Impact of pipeline automation on timelines and budget

Manual game release incurs significant engineering and testing costs. CI/CD automation pays for itself within the first two months, reducing release costs by 40–60%.

Result: we reduce the commit‑to‑publish cycle by 6–8 times. For projects with frequent hotfixes, this is the difference between a week‑long user wait and a one‑day fix. We guarantee the pipeline works reliably after setup. Our engineers hold Unity Certified Professional credentials.

Typical savings: $2,500–$5,000 per month on engineering time eliminated by automation — $30,000–$60,000 annually on a mid‑size project.

Post‑release: monitoring and updates

Crash rate < 1% (Firebase Crashlytics), ANR rate < 0.47% (Play Console) — otherwise visibility restrictions. Phased rollout is mandatory: first 10%, then 50%, then 100% of users.

Our track record: 30+ mobile game releases, 5+ years on the market. CI/CD automation pays for itself within the first two months, reducing release costs by 40–60%.

Timeline

Setup takes from 2 days (simple mobile game with existing Unity project) to 2 weeks (complex multi‑platform project with custom CI runners). We calculate exact hours during a free pipeline audit.

Contact our engineers for a free pipeline audit and a timeline estimate. Submit a request — we will analyze your pipeline and offer a solution within 2 days. Get a consultation from an engineer who has shipped 30+ titles.