Skip to main content
Installing and testing on a real iPhone Level: Developer 11 min read

Why Is My TestFlight Build Stuck on Processing? Causes and Fixes

Understand why iOS builds get stuck in Processing or disappear from TestFlight, how to diagnose failures with FlightDeck MCP, and how to recover.

Published: 2026-10-31 • Last Updated: 2026-11-01 • Author: Kip Lawrence
Key MCP Tools: builds_listbuild_getbuild_upload_status

Uploading your .ipa binary to App Store Connect is only the first half of the deployment pipeline. Once the file transfer finishes, Apple's servers take ownership of the package and place the build into a state labeled Processing.

For many developers—especially those using terminal-driven workflows, CI pipelines, or AI coding assistants in Cursor, Claude Code, or Antigravity—this is where confusion arises. The build may remain in "Processing" for an extended period, appear to stall without an error message, or vanish from the TestFlight dashboard entirely.

This guide clarifies how Apple's ingestion pipeline operates, explains how to distinguish the distinct stages of upload transfer and backend analysis, shows how to diagnose your build's status using natural-language AI prompts with FlightDeck, and provides a structured troubleshooting protocol when an upload stalls or fails.


Understanding Apple's Ingestion and Processing Pipeline

To diagnose processing delays and visibility issues effectively, developers must distinguish the separate state layers involved in Apple's deployment pipeline:

TEXT
[Layer 1: Transport Ingestion (buildUploads)] ─── Network file upload to Apple storage
         │ States: AWAITING_UPLOAD ──► PROCESSING ──► COMPLETE (or FAILED)
         ▼
[Layer 2: Apple Backend Processing (builds)] ─── Apple cloud workers validate binary
         │ States: PROCESSING ──► VALID (or INVALID / FAILED)
         ▼
[Layer 3: Export Compliance Assessment]
         │ States: Missing Compliance ──► Resolved (ITSAppUsesNonExemptEncryption)
         ▼
[Layer 4: Beta Group Distribution & Tester Visibility]
         │ Requires: Build attached to Beta Group + TestFlight Review (for external groups)
         ▼
[Visible to TestFlight App on Tester Devices]

1. Transport Ingestion (buildUploads)

When you upload an archive using FlightDeck or another transport tool, Apple allocates a staging upload container.

  • States: AWAITING_UPLOAD, PROCESSING, COMPLETE, FAILED.
  • Cancellation: If an upload stalls or your local network drops before the transfer finishes, the staging container can be cancelled.
  • Retrying: If an upload fails during transport before ingestion completes, you can re-upload the same binary file with the same build number. Apple has not yet committed it to your app's permanent build table.

2. Apple Cloud Processing (builds)

Once the upload container reaches COMPLETE, Apple's automated worker fleet takes ownership of the package and registers a permanent build entity.

  • States: PROCESSING, VALID, FAILED, INVALID.
  • No External Cancellation: Once Apple's backend workers start analyzing an ingested build, Apple provides no API endpoint, CLI command, or portal button to cancel, pause, speed up, or kill the backend processing job. FlightDeck cannot accelerate or terminate Apple's backend workers.
  • No Compiler Logs via API: Apple's App Store Connect REST API does not stream real-time compilation output, asset catalog compiler stdout/stderr, or internal worker telemetry. When an analysis completes or fails, Apple updates the build's state and sends status notifications.
  • No Published Processing SLA: Apple does not publish fixed turnaround time guarantees. Processing duration varies dynamically based on binary size, asset complexity, framework count, and Apple server queue load worldwide.

3. Export Compliance Status

A build can reach VALID processing status while still remaining invisible to testers. If Info.plist lacks the ITSAppUsesNonExemptEncryption key, Apple flags the build as "Missing Compliance". The build is technically processed, but Apple halts distribution until the questionnaire is completed or the key is supplied.

4. Tester Distribution & Visibility

Even when a build is fully VALID with compliance resolved, testers cannot install it until the build is explicitly assigned to a beta group. External testing groups additionally require TestFlight Beta App Review approval from Apple.


Asking Your AI Coding Assistant to Diagnose Build Status

Instead of repeatedly refreshing the App Store Connect web portal or trying to query Apple's REST API directly, you can ask your AI coding assistant to inspect your build's status using natural language. FlightDeck handles the API queries behind the scenes.

Because inspecting build status is a read-only query (Tier 1), FlightDeck executes the inspection immediately without requiring manual approval.

Diagnostic Prompt

Copy and paste this prompt into your connected AI coding assistant:

TEXT
Check App Store Connect for [Your App Name]. Find our recent build uploads and active builds for version [e.g., 1.0.0], and report the status of build [e.g., 42]. Distinguish whether the upload is still transferring, currently in Apple's processing queue, marked VALID, flagged for missing compliance, or marked INVALID/FAILED.

Your assistant will connect to FlightDeck, query the latest build uploads and registered build entities, and report:

  • The exact current processing state (PROCESSING, VALID, INVALID, or FAILED).
  • The date and timestamp when Apple received the binary.
  • Whether export compliance is blocking the build from distribution.
  • Which beta groups (if any) currently have access to the build.

Verification and Read-Back Prompt

To check whether Apple has completed processing after waiting for backend queues to clear, run this follow-up prompt:

TEXT
Check App Store Connect again for [Your App Name] build [e.g., 42]. Has Apple finished processing, is it ready for internal testing, or did it fail validation?

Your assistant will query App Store Connect and confirm whether the build has transitioned to VALID or whether an error occurred.


How to Distinguish the Seven Pipeline States

To avoid making incorrect assumptions about your build, use this guide to identify exactly which stage your binary has reached:

Pipeline State System Indicator Meaning Required Action
1. Upload Transferring buildUploads status AWAITING_UPLOAD or chunk upload in progress Binary parts are streaming across the network to Apple storage. Maintain network connection. If aborted, retry upload with the same build number.
2. Transfer Complete buildUploads status COMPLETE All chunks received by Apple storage; build handed off to processing queue. Wait for Apple worker allocation.
3. Processing Active builds status PROCESSING Apple's cloud workers are actively thinning, compiling, and analyzing the binary. Wait. Apple does not publish queue SLAs; duration varies with server load.
4. Processing Succeeded builds status VALID Binary validated successfully; ready for distribution. Assign build to beta groups or attach to an App Store version draft.
5. Processing Failed builds status FAILED or INVALID Server error (FAILED) or binary violated ingestion rules (INVALID). Check registered developer email for ITMS error notice; fix root cause, bump build number, and rebuild.
6. Missing Compliance processingState: VALID, missing compliance flag Processing succeeded, but export compliance declaration is required. Answer questionnaire in web portal or configure ITSAppUsesNonExemptEncryption in project config.
7. Build Not in Version Build absent from expected version view Version string mismatch or registered under different App ID. Verify CFBundleShortVersionString and CFBundleIdentifier in project settings.

Why Builds Disappear or Appear Stalled

1. The "Disappearing Build" Phenomenon (Silent Invalidation)

When Apple's backend pipeline determines that a binary violates ingestion rules (e.g., missing privacy manifests, un-sandboxed dynamic libraries, missing App Store icons, or improper entitlements), Apple marks the build INVALID. In many cases, App Store Connect simply removes the build from the TestFlight dashboard list without displaying an inline error.

Developers often assume the upload was lost, but Apple dispatches an automated notification email to the account's registered Account Holder and Admin addresses within minutes of invalidation. The email contains a specific ITMS error code (such as ITMS-90034, ITMS-90683, or ITMS-90809) detailing the exact defect.

2. "Processing" vs. "Missing Compliance"

A frequent source of confusion is mistaking Missing Compliance for an active processing hang:

  • When a build finishes technical processing, Apple checks for an export compliance declaration (ITSAppUsesNonExemptEncryption).
  • If this key is missing from Info.plist, the build pauses distribution. In the web UI, it displays a yellow exclamation mark ("Missing Compliance").
  • Once compliance is declared, the build transitions immediately to VALID.
  • For details on permanently declaring this in your source code, see Fixing Missing Encryption Key (ITSAppUsesNonExemptEncryption).

3. Build Number Collisions

Apple requires that every uploaded binary for a given marketing version (CFBundleShortVersionString, e.g., 1.0.0) have a strictly unique build number (CFBundleVersion, e.g., 42). If you attempt to re-upload build 42 after a previous attempt failed, Apple will reject the incoming binary at ingestion.

4. Apple System Status and Platform Outages

Apple's processing fleet operates on shared cloud infrastructure. During major iOS release cycles or platform-wide infrastructure disruptions, processing queues back up across all developers. Before assuming your build is defective, check the official Apple Developer System Status dashboard to confirm that "App Store Connect - Processing" is operating normally.


Recovery Protocol: When and How to Rebuild

Do not rebuild and increment your build counter solely because a set number of minutes has passed. Rebuilding should follow a targeted diagnostic decision tree:

TEXT
                  [Is Build Still in PROCESSING?]
                                  │
      ┌───────────────────────────┴───────────────────────────┐
      ▼                                                       ▼
[Apple System Status Normal]                           [System Outage Reported]
      │                                                       │
      ├─ Check registered developer email for ITMS notices   Wait for Apple platform
      ├─ Check App Store Connect web portal for warnings     incident resolution
      │
      ▼
[Is Build Marked INVALID or FAILED?]
      │
      ├─ Yes: Fix root defect, increment CFBundleVersion, and re-export.
      └─ No (Stalled with no status change & no system outage):
            Investigate via Apple Developer Support or submit fresh build.

When an Increment and Rebuild Is Required

  1. Apple Marked Build INVALID: Inspect the specific ITMS-XXXXX code sent to your developer email, resolve the issue in your codebase, increment CFBundleVersion, and recompile.
  2. Apple Marked Build FAILED: An unrecoverable backend exception occurred on Apple's servers. Increment CFBundleVersion and re-export.
  3. Confirmed Queue Drop: If Apple Developer Support confirms an unrecoverable queue stall, increment CFBundleVersion and re-upload.

Staging the Replacement Build via AI

Once your project is updated with an incremented build counter (e.g., from 42 to 43), prompt your assistant:

TEXT
I generated a replacement build at [path/to/MyApp_v43.ipa] with build counter 43. Use FlightDeck to inspect the binary and stage an upload to App Store Connect for [Your App Name].

Because delivering a new binary creates resources on Apple's servers, FlightDeck stages the upload for your review. FlightDeck Desktop presents an Approval Center sheet displaying the target application, version string, build number, and file path.

Illustrative representation of the FlightDeck Approval Center sheet:

TEXT
┌──────────────────────────────────────────────────────────────┐
│ FlightDeck Desktop — Operation Approval Request             │
├──────────────────────────────────────────────────────────────┤
│ Operation:   Deliver iOS Binary (.ipa)                      │
│ Target App:  [Your App Name] (App ID: 6812899314)           │
│ Binary Path: /path/to/MyApp_v43.ipa                         │
│ Version:     1.0.0 (Build 43)                               │
│ Platform:    iOS                                            │
│ Action:      Upload binary parts to Apple Ingestion Storage │
│ Impact:      Stages build for Apple server processing.      │
├──────────────────────────────────────────────────────────────┤
│ [Reject Proposal]                        [Approve & Execute] │
└──────────────────────────────────────────────────────────────┘

Review the details and click Approve & Execute. Once uploaded, the fresh build will be processed independently by Apple's worker fleet.


Summary Checklist and Next Steps

Situation Underlying Reality Prescribed Action
Network dropped during upload Ingestion container failed before commit. Retry Same Build: Re-run upload with the same build number.
Status is PROCESSING Active backend validation queue. Wait & Monitor: Track status using natural-language queries.
Build disappeared from dashboard Build rejected as INVALID. Check Email: Locate the ITMS rejection code sent to the Account Holder email.
Build shows "Missing Compliance" Processing complete; compliance needed. Declare Compliance: Complete the web questionnaire or add ITSAppUsesNonExemptEncryption to Info.plist.
Multiple successive builds stall Apple infrastructure incident. Check Status / Support: Review Apple System Status or submit a ticket via Apple Developer Support.

Connect Your AI Agent to App Store Connect

FlightDeck runs locally on your Mac, keeping private keys secure in your macOS Keychain and executing mutations only after your explicit approval.

Download FlightDeck on Mac App Store