Deliver (Fastlane) — what it is, App Store upload, and configuration in iOS and Android development

What is Deliver (Fastlane)?

Deliver (Fastlane) is a component of the Fastlane ecosystem that automates the process of publishing mobile apps to the App Store. It handles binary file uploads, metadata updates (name, description, keywords), screenshot uploads, and pricing configuration for all localization languages.

Without Deliver, each release requires manually updating information through the App Store Connect web interface: filling in descriptions in multiple languages, uploading screenshots for each screen size, updating keywords, and configuring pricing. App Store publishing is the final stage of the iOS app lifecycle, involving binary file verification, content moderation, and making the app available in production.

According to App Store Connect Documentation (2025), apps with regular updates receive 30% more repeat installations and rank better in search results. Deliver enables teams to release updates weekly by automating routine publishing steps and reducing the risk of human error when filling in metadata across dozens of languages.

Use Deliver for any app published on the App Store — it is especially valuable for projects with multilingual localization where manually updating 32 languages takes several hours.

How Deliver works with App Store Connect

Deliver's operation mechanism is built on a two-stage process. In the first stage, the tool prepares metadata — it validates the Deliverfile structure, loads screenshots, and generates a change manifest. In the second stage, Deliver sends data to the App Store Connect API, uploads the binary file, and starts the build verification process on Apple's side.

Deliver uses the App Store Connect API for all operations, ensuring compatibility with Apple's latest requirements and eliminating the use of private interfaces. App Store Connect API is Apple's official REST API for automating app operations, including build uploads, metadata management, and review status tracking.

Binary file upload

Deliver integrates directly with Gym through Fastlane: after the IPA build, Deliver uploads it to App Store Connect and starts the processing. The --ipa parameter specifies the path to the binary file. If not specified, Deliver automatically finds the latest IPA in the build directory specified in Gymfile or passed through previous Fastlane steps.

After upload, Deliver waits for Apple's binary processing to complete — similar to Pilot, the status is tracked via a progress bar. Available statuses: Processing, Waiting For Review, In Review, Ready For Sale, or Rejected. Deliver notifies the team of each status change through callbacks in Fastfile.

App metadata management

Deliver manages the full set of app metadata: name, description (short and full), keywords, support and marketing URLs, category, and age rating. App metadata is the textual information about the app displayed on the App Store page, used for search indexing and ASO optimization.

The --submit_for_review parameter sends the app for moderation immediately after metadata upload. This is a key parameter for fully automated releases. Without it, Deliver only uploads data but does not submit the app for review — useful for pre-checking all fields before actual submission.

Working with screenshots

Deliver automatically uploads screenshots for all device and language combinations from the specified directory. File names must follow the pattern: iPhone_6.5_01.png for a 6.5-inch iPhone on the first slot. Deliver determines the screenshot size and matches it with Apple's requirements for each device type.

Screenshots are uploaded in the correct order and separately for each localization language. If screenshots are not found for a language, Deliver uses English versions as a fallback. Screenshot localization is a mandatory requirement for apps that want to rank well in the App Store across different countries, as Apple considers local content in search results.

# Basic App Store upload command
fastlane deliver

# Upload with metadata and screenshots specified
fastlane deliver --ipa "build/MyApp.ipa" \
      --force --submit_for_review

# Preview without uploading
fastlane deliver --preview

Deliver configuration via Deliverfile

Deliverfile is a Fastlane configuration file for storing app metadata in a structured Ruby format. Unlike manually filling out forms in App Store Connect, the Deliverfile allows versioning metadata in Git and verifying changes through code review before publishing.

# Deliverfile — app metadata
app_identifier("com.company.app")
title("MyApp")
description("App store description")
keywords("mobile, app, ios, swift")
support_url("https://company.com/support")
marketing_url("https://company.com")
privacy_url("https://company.com/privacy")

# Metadata localization languages
languages(["en-US", "ru", "de"])

The languages parameter determines which languages will have metadata uploaded. A separate directory must be created for each language in the fastlane/metadata folder with corresponding description, keyword, and marketing text files. Deliver supports up to 32 App Store languages simultaneously.

For screenshot uploads, the screenshots directory inside the Fastlane folder is used. Folder structure: screenshots/[Language]/[DeviceType]_[ScreenSize]_[Number].png. Deliver automatically uploads screenshots for the specified languages and devices, matching sizes with Apple's requirements. It is recommended to use Snapshot for generating screenshots — their output format is compatible with Deliver.

The pricing tier is configured via the price_tier parameter, which accepts a pricing level number from 0 to 87. Apple's pricing tiers are automatically converted to the currencies of all countries where the app is available. Deliver allows changing the price as part of a release, useful for temporary promotions or changes in the app's business model.

Deliver commands for app publishing

Deliver interface includes commands for uploading metadata, binary files, screenshots, and full releases. The main fastlane deliver command without parameters uses data from the Deliverfile and metadata directory for a complete publishing cycle.

The fastlane deliver --preview command runs preliminary metadata verification without actually uploading to App Store Connect. --force is required for uploading — without it, Deliver operates in preview mode. The --skip_binary parameter uploads only metadata and screenshots, skipping the binary file upload — convenient for quickly updating ASO fields without a new release.

# Full release with binary upload
fastlane deliver --force --ipa "build/App.ipa"

# Upload metadata only without binary
fastlane deliver --force --skip_binary

# Update screenshots only
fastlane deliver --force --skip_metadata

The --skip_metadata parameter uploads only screenshots and the binary file, keeping existing metadata unchanged. This is useful for hotfix releases when you need to quickly ship a fix without changing the description and ASO fields. The combination of flags allows flexible management of each publishing stage separately.

Integrating Deliver into the release pipeline

Release pipeline with Deliver is a complete CI/CD process for iOS that automates all stages from commit to App Store publication. A typical pipeline includes: Match for certificates, Gym for IPA builds, Snapshot for screenshots, and Deliver for uploading all data to App Store Connect followed by moderation submission.

A key feature of Deliver in the pipeline is support for metadata.json, which stores metadata in a structured JSON format. This allows generating metadata programmatically from external CMS systems or automatically creating descriptions in multiple languages via a translation API.

# Release pipeline in Fastfile
lane :release do
    match(type: :appstore)
    capture_screenshots
    gym(scheme: "MyApp", export_method: "app-store")
    deliver(ipa: "build/MyApp.ipa", force: true, submit_for_review: true)
end

Before calling Deliver in the pipeline, ensure all metadata is up to date: the description matches the new version, screenshots are updated for new features, and the pricing tier does not need changes. Submit for review sends the app to Apple moderation, which takes 24 to 48 hours for new apps and 2 to 12 hours for updates.

Deliver supports the app_version mechanism, which allows specifying the target version for metadata updates. If the version is not specified, Deliver updates the current active version of the app in App Store Connect. To release a new version, you must first create the corresponding version through the App Store Connect interface or API.

Common errors when working with Deliver

When using Deliver, developers often encounter metadata validation errors, incorrect screenshot file structures, and authentication issues. Error diagnostics in Deliver starts with analyzing command logs — Deliver outputs detailed information about each upload stage and the reasons for rejection.

The “Invalid screenshot path” error occurs when the screenshot folder structure does not match the expected format. Solution: check screenshot file names follow the pattern DeviceType_ScreenSize_Number.png (e.g. AppleiPhone15ProMax_6.7_01.png). Deliver is case-sensitive and sensitive to separators in file names.

The “Metadata validation failed” error indicates metadata does not meet App Store requirements. Solution: check the description length (up to 4000 characters), keyword length (up to 100 characters), and name length (up to 30 characters). App Store Review Guidelines contain full requirements for each metadata field — it is recommended to check them before each release.

With the “Apple ID not found” error, the app does not exist in App Store Connect with the specified apple_identifier. Solution: create the app entry in App Store Connect through the web interface before the first Deliver call, specifying the Bundle Identifier and name. Deliver does not create new apps — it only updates existing store entries.