Asc Testflight Orchestration

Asc Testflight Orchestration is a community skill for automating TestFlight beta testing workflows, covering beta group management, tester invitation, build distribution, feedback collection, and external review submission for structured beta testing programs.

What Is This?

Overview

Asc Testflight Orchestration provides patterns for managing TestFlight beta programs through the App Store Connect API. It covers beta group management that creates and configures internal and external testing groups with different access levels, tester invitation that adds and removes testers by email with group assignment, build distribution that assigns specific builds to targeted testing groups with release notes, feedback collection that retrieves beta feedback and crash reports submitted by testers, and external review submission that manages the Beta App Review process for external testing groups. The skill enables teams to run structured beta testing programs.

Who Should Use This

This skill serves QA managers running beta testing programs with multiple tester groups, iOS engineers automating build distribution to TestFlight from CI, and product managers collecting structured feedback from beta testers.

Why Use It?

Problems It Solves

Managing beta tester lists manually is error-prone for large testing programs. Build distribution to specific groups requires manual assignment after each upload. External beta testing requires separate review submission that adds delay. Beta feedback and crash reports must be retrieved and organized from TestFlight for actionable triage.

Core Highlights

Group manager creates and configures beta testing groups with role-based access. Tester controller adds and removes testers with bulk invitation support. Build distributor assigns builds to groups with localized release notes. Feedback aggregator collects tester feedback and crash data for analysis.

How to Use It?

Basic Usage

// TestFlight orchestrator
import Foundation

struct TestFlightOrchestrator {
  let api: ASCClient

  func createGroup(
    appId: String,
    name: String,
    isInternal: Bool
  ) async throws -> String {
    let resp =
      try await api.post(
        path:
          "/v1/betaGroups",
        body: [
          "data": [
            "type":
              "betaGroups",
            "attributes": [
              "name": name,
              "isInternal"
              + "Group":
                isInternal],
            "relationships":
              ["app": ["data":
                ["type":
                  "apps",
                "id":
                  appId]]]]])
    return resp.data.id
  }

  func addTesters(
    groupId: String,
    emails: [String]
  ) async throws {
    let testers =
      emails.map { email in
        ["type":
          "betaTesters",
         "attributes":
          ["email": email]]
      }
    try await api.post(
      path:
        "/v1/betaGroups/"
        + "\(groupId)/"
        + "relationships/"
        + "betaTesters",
      body: [
        "data": testers])
  }

  func distribute(
    buildId: String,
    groupIds: [String]
  ) async throws {
    let groups =
      groupIds.map {
        ["type":
          "betaGroups",
         "id": $0]
      }
    try await api.post(
      path:
        "/v1/builds/"
        + "\(buildId)/"
        + "relationships/"
        + "betaGroups",
      body: [
        "data": groups])
  }
}

Real-World Examples

// Beta feedback collection
struct FeedbackCollector {
  let api: ASCClient

  func getBetaFeedback(
    buildId: String
  ) async throws
      -> [BetaFeedback] {
    let resp =
      try await api.get(
        path:
          "/v1/builds/"
          + "\(buildId)/"
          + "betaApp"
          + "ReviewDetail")

    return resp.data.map {
      BetaFeedback(
        id: $0.id,
        email: $0.attributes
          .contactEmail,
        notes: $0.attributes
          .notes)
    }
  }

  func submitForReview(
    buildId: String,
    contactEmail: String,
    notes: String
  ) async throws {
    try await api.post(
      path:
        "/v1/betaApp"
        + "ReviewSubmissions",
      body: [
        "data": [
          "type":
            "betaAppReview"
            + "Submissions",
          "relationships":
            ["build":
              ["data":
                ["type":
                  "builds",
                "id":
                  buildId]]]]])
  }
}

Advanced Tips

Use internal groups for immediate distribution without Beta App Review and reserve external groups for wider testing phases. Automate tester list management from a CSV or team directory to keep groups current. Set up build distribution rules that automatically assign new builds to specific groups based on branch or tag.

When to Use It?

Use Cases

Automate TestFlight build distribution to QA, stakeholder, and beta tester groups on each CI build. Manage external beta testing with structured group assignment and Beta App Review. Collect and aggregate beta tester feedback for product triage.

Related Topics

TestFlight, beta testing, App Store Connect API, build distribution, and tester management.

Important Notes

Requirements

App Store Connect API key with TestFlight management permissions. Valid processed builds for distribution to testing groups. Beta App Review submission for external testing distribution.

Usage Recommendations

Do: use internal groups for rapid iteration and external groups for wider beta testing. Include localized what-is-new text when distributing builds for meaningful tester communication. Remove inactive testers regularly to maintain clean group lists.

Don't: add external testers to internal groups as this bypasses Beta App Review. Distribute builds without release notes leaving testers without context. Exceed the 10,000 external tester limit per app.

Limitations

External testing requires Beta App Review which may take up to 48 hours. Internal testing is limited to team members in the App Store Connect organization. TestFlight builds expire after 90 days requiring re-upload for continued testing.