Learn Swift - Deployment & App Distribution

#Introduction

All your hard work culminates here: the app reaches users' hands. Episode 20 covers deployment and app distribution — from archive, to beta testing with TestFlight, to uploading to the App Store and distributing to macOS, watchOS, and tvOS.

Clean distribution isn't just about pressing the Upload button. Behind it are correct code signing, notarization for user security, and release management that makes rollbacks and gradual releases easy.

#Archive and Export

#Creating an Archive

The distribution artifact is produced through an archive (episode 18). Before archiving, make sure the version number and build number are updated — both must increment on every release:

xcodebuild archive \
  -scheme Aplikasi \
  -archivePath ./build/Aplikasi.xcarchive \
  -configuration Release \
  -allowProvisioningUpdates

xcodebuild archive ... -allowProvisioningUpdates produces a .xcarchive containing the app along with its metadata and symbols. This archive is the starting point for every distribution path — App Store, TestFlight, or ad-hoc.

#Export and Upload

From the archive, the app is exported to a distribution format and then uploaded:

xcodebuild -exportArchive \
  -archivePath ./build/Aplikasi.xcarchive \
  -exportPath ./export \
  -exportOptionsPlist exportOptions.plist

xcodebuild -exportArchive -exportOptionsPlist ... turns the archive into an .ipa according to the options in exportOptions.plist — for example uploadBitcode and method set to app-store. Upload to App Store Connect is done through Xcode Organizer or Fastlane.

#TestFlight and Beta Testing

#Distributing Beta Builds

TestFlight is Apple's beta testing service. Uploaded builds can be distributed to external and internal testers:

• Internal testing: up to 100 team members, live immediately without review.
• External testing: up to 10,000 testers, requires Apple beta review and follows the App Store Review Guidelines.

TestFlight builds also provide crash data and tester feedback. Use this phase to validate on real devices before the general release.

#Automating TestFlight Uploads

Fastlane simplifies this step — episode 18 introduced the beta lane:

bundle exec fastlane beta

bundle exec fastlane beta runs the lane that builds, signs, and uploads the build to TestFlight. This automation means every commit on a given branch produces a fresh beta build with no manual intervention.

#Deployment to Every Platform

#macOS and Notarization

For macOS apps, Apple requires notarization: the app must be checked by Apple before users can run it outside the App Store. The process is run with notarytool:

xcrun notarytool submit Aplikasi.dmg \
  --keychain-profile "notary-profile" \
  --wait

xcrun notarytool submit Aplikasi.dmg --wait submits the app for Apple's automated security check and waits for the result. Once approved, stapler attaches the receipt so the app runs without an "unidentified developer" warning.

#watchOS and tvOS

Deploying to watchOS and tvOS follows the same path — App Store Connect accepts builds for all three platforms, with differences:

• watchOS: the watch app is bundled inside the iOS app as a companion.
• tvOS: the TV app uses a separate target and provisioning profile.
• Both go through the same App Store, TestFlight, and App Store Review.

Design a pipeline that handles several targets from the start — for example, one Fastlane lane per platform, or one lane with parameters.

#Release Management

#Release Strategy

Healthy release practices include:

• Consistent versioning: increment versions according to an agreed scheme.
• Maintained changelog: record every change for users.
• Gradual releases: use phased release in App Store Connect to monitor issues before a full rollout.
• Rollback plan: document the steps to go back if a regression appears in production.

#App Store Review

Every build submitted to the App Store goes through review. To smooth the process:

• Include review information: demo account, flows to test.
• Comply with the App Store Review Guidelines.
• Explain features that might raise reviewer questions.

#Closing

Key takeaways:

• The archive produces the artifact that feeds every distribution path.
• TestFlight enables internal and external beta testing before release.
• macOS requires notarization to run outside the App Store.
• watchOS and tvOS go through the same distribution path as iOS.
• Increment version and build number on every release, and keep the changelog.
• Phased releases and a rollback plan protect users at release time.

In the next episode, episode 21, we'll cover observability and production support — crash reporting and analytics in Swift apps, logging, telemetry, and performance monitoring, health checks and user feedback loops, plus incident response and release rollback. Your apps become clear in production!