Ruby in Mobile Development: Fastlane, CI/CD and Automation

What is Ruby?

Ruby is a dynamic interpreted open-source language created by Yukihiro Matsumoto in 1995. Ruby's core principle is "optimal simplicity" (principle of least surprise). The language is known for blocks (closures), a pure object-oriented approach (everything is an object, including numbers), and a powerful metaprogramming system.

Ruby runs on the YARV (Yet Another Ruby VM) interpreter with JIT compilation since version 3.1. The current version Ruby 3.4 (2025) includes decorators, an improved Prism parser, and experimental type support through RBS. RubyGems — the package manager — contains over 200,000 gems.

Ruby on Rails is the most famous web framework built with Ruby, but in mobile development Ruby is used differently. Its main niche is Fastlane: an ecosystem of Ruby scripts and gems for automating all stages of the mobile app lifecycle — from code signing to store publishing.

Ruby Syntax Basics for Fastlane

Working with Fastlane requires only basic Ruby understanding: methods, do-end blocks, symbols (:symbol), and hash syntax { key: value }. Unlike Python, Ruby uses end to close blocks instead of indentation. Methods can be called without parentheses — this is actively used in the Fastlane DSL.

# Basic Ruby syntax used in Fastlane
def download_assets(version, platform: "ios")
  paths = {
    ios: "ios/Assets.car",
    android: "android/app/src/main/assets"
  }
  url = "https://cdn.example.com/assets/#{version}/#{paths[platform.to_sym]}"
  puts "Downloading from: #{url}"

  unless File.exist?("temp/assets")
    Dir.mkdir("temp/assets")
  end
  result = system("curl -o temp/assets.zip #{url}")
  raise "Download failed" unless result
end

download_assets("1.2.3", platform: "android")

In the example, the download_assets method takes a version argument and an optional named parameter platform (defaulting to "ios"). String interpolation with #{...} embeds values directly into strings. unless is the opposite of if — it executes code when the condition is false.

Fastlane: Mobile Build Automation with Ruby

Fastlane is an open-source tool written in Ruby. Installed via gem install fastlane, it provides a set of commands for automating the most routine mobile developer tasks: creating screenshots, code signing, publishing to TestFlight and Google Play Console.

Fastlane consists of tools: sigh (certificate management), match (certificate synchronization in teams), gym (iOS builds), gradle (Android builds), deliver (iOS publishing), supply (Android publishing), snapshot (screenshots), scan (testing). All tools are accessible from a single Fastfile.

In large projects, Fastlane handles 50+ actions in a single pipeline: version increment, asset download from CDN, building, signing, uploading to App Store Connect, sending Slack notifications. The entire pipeline runs with a single command: fastlane release.

Fastfile: Build Pipeline Configuration

Fastfile is a Ruby-like DSL file describing a sequence of actions (lanes). Each lane is a separate task: beta (test build), release, screenshots. Lanes can call other lanes with passed parameters.

# Fastfile — iOS app build pipeline configuration
fastlane_version "2.220.0"

default_platform :ios

platform :ios do
  desc "Building and deploying TestFlight build"
  lane :beta do |options|
    increment_build_number(
      build_number: options[:build]
    )
    match(type: :appstore)
    gym(
      scheme: "MyApp",
      export_method: "app-store",
      configuration: "Release"
    )
    upload_to_testflight(
      app_identifier: "com.example.myapp"
    )
    slack(
      message: "Build #{options[:build]} uploaded to TestFlight"
    )
  end
end

The beta lane executes sequentially: increment build number (increment_build_number), sync certificates (match), build archive (gym), upload to TestFlight (upload_to_testflight), and send Slack notification. The :build parameter is passed to the lane as a named argument.

Android Configuration in Fastfile

Fastlane supports both platforms in a single Fastfile. For Android, use a lane inside platform :android with gradle, supply, and google_play_track_version_codes actions.

platform :android do
  desc "Building APK and publishing to Google Play Internal Testing"
  lane :beta do
    gradle(
      task: "assemble",
      build_type: "Release",
      flavor: "Production"
    )
    supply(
      track: "internal",
      apk_paths: ["app/build/outputs/apk/release/app-release.apk"]
    )
  end
end

Key Fastlane Actions for iOS and Android

Fastlane includes over 200 built-in actions. Below are the most important ones for mobile development, organized by category.

Match: Secure Certificate Management

match is a Fastlane gem for synchronizing iOS certificates and provisioning profiles among developers. All secrets are stored in an encrypted Git repository or S3. Match automatically generates certificates if they are missing and renews them upon expiration.

# Initializing match for a new project
$ fastlane match init

# Creating and syncing App Store certificates
$ fastlane match appstore

# Creating Development certificates for the team
$ fastlane match development

# Renewing all certificates upon expiration
$ fastlane match --force

Match stores private keys with a passphrase known only to developers. Each developer clones the certificate repository and runs match to install the current profiles. Apple certificates are valid for 1 year; match automatically renews them.

Integrating Fastlane with CI/CD Systems

Fastlane integrates with any CI/CD platform: GitHub Actions, GitLab CI, CircleCI, Bitrise, Jenkins, and Xcode Cloud (via xcode-build). Fastlane runs on CI using fastlane <lane_name> and returns an error code if any step fails.

GitHub Actions setup includes installing Ruby, fastlane, and running the lane via bundle exec fastlane. iOS builds require a macOS runner. Android builds can use ubuntu-latest, which is cheaper.

# .github/workflows/deploy.yml — CI/CD with Fastlane
name: Deploy Mobile App
on:
  push:
    branches: [main]

jobs:
  ios-deploy:
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: "3.3"
      - run: bundle install
      - run: bundle exec fastlane beta
      - env:
          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}

The workflow runs on push to main. The macOS runner executes bundle exec fastlane beta from the Fastfile. MATCH_PASSWORD is passed through GitHub Secrets for certificate decryption. After the lane completes, a Slack action sends a notification.

Ruby Gems and Fastlane Plugins

RubyGems is the package manager for Ruby. Fastlane is extended through plugins — gems that add new actions. The fastlane-plugin-versioning plugin manages versions, fastlane-plugin-firebase_app_distribution uploads builds to Firebase. There are over 500 Fastlane plugins on GitHub.

The Gemfile at the project root pins versions of all dependencies for reproducible builds. bundle install installs gems from Gemfile.lock. Essential gems for mobile development include: fastlane, cocoapods (iOS dependencies), xcodeproj (.xcodeproj manipulation).

# Gemfile for a mobile project
source "https://rubygems.org"

gem "fastlane", "~> 2.220"

plugins_path = File.join(File.dirname(__FILE__), 'fastlane', 'Pluginfile')
eval_gemfile(plugins_path) if File.exist?(plugins_path)

Fastlane vs Alternatives: Approach Comparison

Fastlane is not the only automation tool. Let's compare it with the main alternatives based on criteria important for a mobile team.

Fastlane remains the most flexible tool for complex pipelines. Bitrise is convenient for teams without a Ruby developer. Xcode Cloud works for simple iOS projects. GitHub Actions is ideal if the team already uses GitHub.