Skip to main content
Building, signing, and binary uploads Level: Intermediate 12 min read

Using Fastlane and FlightDeck Together: Compilation vs API Automation

How to combine Fastlane's build and code-signing automation with FlightDeck's conversational App Store Connect management and approval governance.

Published: 2026-11-02 • Last Updated: 2026-11-02 • Author: Kip Lawrence
Key MCP Tools: build_upload_startapp_store_version_localization_update

Overview: Combining Fastlane and FlightDeck

Fastlane has long been the standard open-source tool for automating iOS and macOS build tasks, code signing with match, and headless CI/CD deployments. Fastlane uses a Ruby-based configuration file (Fastfile) to execute scripted build lanes.

FlightDeck, by contrast, is a native macOS application and Model Context Protocol (MCP) server that connects App Store Connect to AI coding assistants (such as Cursor, Claude Code, Windsurf, or Antigravity). FlightDeck brings natural-language interaction, in-process binary inspection, and human-in-the-loop desktop approval governance to Apple management workflows.

Rather than viewing these tools as mutually exclusive, modern release engineering pipelines frequently combine them:

TEXT
┌────────────────────────────────────────────────────────────────────────┐
│                      LOCAL BUILD & SIGNING ENGINE                      │
│                                FASTLANE                                │
│                                                                        │
│   • fastlane match (Sync certificates & provisioning profiles)         │
│   • fastlane gym   (Compile source & export signed .ipa / .pkg)        │
│   • fastlane scan  (Execute local unit & UI test suites)               │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │
                       Signed .ipa / .pkg on Disk
                                    │
                                    ▼
┌────────────────────────────────────────────────────────────────────────┐
│                   NATURAL-LANGUAGE MANAGEMENT & GOVERNANCE             │
│                             FLIGHTDECK MCP                             │
│                                                                        │
│   • build_upload_preview (Offline metadata & integrity verification)   │
│   • Desktop Approval Center (Human-in-the-loop mutation governance)   │
│   • build_upload_start (Direct Apple cloud presigned streaming)        │
│   • TestFlight & Metadata (Beta groups, release notes, localization)   │
└────────────────────────────────────────────────────────────────────────┘
Important

Independent Tool Architecture: Fastlane and FlightDeck are distinct, separate tools. FlightDeck does not run Fastlane automatically, and Fastlane does not call FlightDeck's MCP tools. Developers can choose either Fastlane (pilot / upload_to_testflight) or FlightDeck (build_upload_start) to execute the binary upload. An AI coding assistant or developer coordinates the workflow between Fastlane (for local compiling and signing) and FlightDeck (for App Store Connect API operations and approval governance). State is not automatically synchronized between the two systems.


1. Clear Division of Responsibilities

To design an effective pipeline, separate tasks based on where each tool excels:

Pipeline Responsibility Fastlane FlightDeck MCP
Code Signing & Keychain Sync Primary (match) Not supported (FlightDeck does not access Keychain certs)
Local Source Compilation Primary (gym / build_app) Not supported (FlightDeck has no compiler or Xcode engine)
Unit & UI Testing Primary (scan) Not supported (Local test execution is external to ASC)
Pre-Upload Binary Inspection Basic file check Primary (build_upload_preview) with in-process SHA-256
Human Approval Center Not supported (headless CLI) Primary (Desktop GUI) with explicit staging approval
Direct Binary Upload to Apple Supported (pilot / Transporter) Supported (build_upload_start) via native ASC API
Conversational TestFlight Management Rigid Ruby lanes Primary (Natural Language) for groups, testers, and links
What's New & Metadata Updates Complex file trees (deliver) Primary (app_store_version_localization_update)

2. Practical Integration Models

Teams typically integrate Fastlane and FlightDeck using one of two patterns:

In an AI-enabled IDE (Cursor, Claude Code, Windsurf, or Antigravity), the AI assistant uses terminal access to run Fastlane for building and testing, and uses FlightDeck MCP for all App Store Connect interactions:

  1. Step 1 (Fastlane): Assistant runs bundle exec fastlane gym to produce a signed .ipa.
  2. Step 2 (FlightDeck): Assistant calls build_upload_preview to inspect the .ipa against App Store Connect records.
  3. Step 3 (FlightDeck): Assistant stages build_upload_start. The developer reviews the details in the FlightDeck Desktop Approval Center and approves.
  4. Step 4 (FlightDeck): Assistant monitors Apple build processing until VALID, then updates TestFlight "What to Test" notes and assigns the build to beta groups.

Model 2: CI Headless Delivery + FlightDeck Management

In automated environments:

  1. CI Pipeline (Fastlane): A GitHub Action, GitLab CI, or Xcode Cloud runner runs Fastlane to compile, sign, test, and upload the build.
  2. Developer Desktop (FlightDeck): Once the build is uploaded, developers use FlightDeck MCP in their IDE to inspect processing status, generate localized release notes using AI, manage beta tester groups, and prepare store submissions without navigating the web portal.

3. Configuring Fastlane for Clean Hand-Offs

When Fastlane compiles your application, configure Fastfile to export the binary to a predictable directory where FlightDeck can inspect it:

RUBY
# fastlane/Fastfile
default_platform(:ios)

platform :ios do
  desc "Build and export a signed release IPA"
  lane :build_release do
    # 1. Sync signing credentials via match
    match(
      type: "appstore",
      readonly: is_ci
    )

    # 2. Compile and package the application
    gym(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      configuration: "Release",
      output_directory: "./build/export",
      output_name: "MyApp.ipa",
      clean: true,
      export_method: "app-store",
      export_options: {
        uploadSymbols: true
      }
    )
  end
end

Running bundle exec fastlane build_release produces ./build/export/MyApp.ipa, perfectly formatted for FlightDeck's pre-upload validator.


4. Protecting API Secrets and Credentials

Both Fastlane and FlightDeck require access to App Store Connect, but they manage credentials differently:

Fastlane API Key Handling

Fastlane uses App Store Connect API keys loaded from environment variables or a configuration JSON:

  • Store the .p8 private key path in APP_STORE_CONNECT_API_KEY_PATH or supply the key contents via APP_STORE_CONNECT_API_KEY_KEY.
  • Provide Key ID via APP_STORE_CONNECT_API_KEY_KEY_ID.
  • Provide Issuer ID via APP_STORE_CONNECT_API_KEY_ISSUER_ID.

[!CAUTION] Strict Secret Security: - Never hardcode .p8 private keys into Fastfile or commit them to Git repositories. - Never paste API private keys or service credentials into AI assistant chat windows. - Always supply secrets through local environment variables or secure CI/CD vault storage.

FlightDeck Key Handling

FlightDeck stores your App Store Connect API private keys securely in the encrypted macOS Keychain. FlightDeck signs short-lived JWT tokens locally on your Mac. The AI coding assistant never sees, requests, or transmits your private key.


5. Conversational Prompts for an Integrated Workflow

Use this prompt to have your AI assistant execute an end-to-end build and delivery workflow combining Fastlane and FlightDeck:

MARKDOWN
Inspect this project's Fastlane configuration and help me build a safe TestFlight release workflow. Use Fastlane for building and uploading, and use FlightDeck only for the App Store Connect operations it actually supports. Show me the complete plan, identify required secrets without printing them, and require approval before uploading or changing tester distribution. Verify the uploaded build and its processing state afterward.

What Your AI Assistant Does:

  1. Audits your Fastfile to locate the build lane and verify gym parameters.
  2. Checks that required environment variables are set without displaying secret values.
  3. Proposes executing Fastlane to build the binary.
  4. Uses FlightDeck's build_upload_preview to inspect the generated package.
  5. Stages upload and distribution operations for human review in FlightDeck's Approval Center.
  6. Once the build finishes processing on Apple servers, drafts and applies localized "What to Test" notes via FlightDeck.

6. Post-Upload Automation with FlightDeck

After an upload completes—whether uploaded via Fastlane or FlightDeck—you can use FlightDeck MCP to manage post-upload release tasks conversationally:

1. Monitor Build Processing

MARKDOWN
Check the processing state of the latest build for "Quest Companion". Let me know as soon as Apple marks it VALID.

2. Update Localized Release Notes

MARKDOWN
Draft concise "What's New" release notes in English, Spanish, and Japanese for the latest build of "Quest Companion" based on our recent Git commits. Show me the drafted text before updating App Store Connect.

FlightDeck uses app_store_version_localization_update to update store metadata across all target languages in seconds. See Automating App Store Localization.

3. Add to TestFlight Beta Groups

MARKDOWN
Add the newly processed build to our "Internal QA" and "Public Beta" groups, and enable the public link for external testers.

For full details on beta group distribution, see Managing TestFlight Beta Groups.

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