Developing CI-CD Pipelines for Flutter with fastlane and codemagic

Introduction

Building robust CI/CD pipelines is essential for modern Flutter development. Combining fastlane’s powerful automation with Codemagic’s Flutter-native CI/CD infrastructure accelerates release cycles and ensures consistency across builds. In this advanced tutorial, you’ll learn how to configure fastlane lanes, secure credentials, and author a codemagic.yaml that orchestrates your entire workflow—from unit tests to App Store deployment. We’ll also touch on versioning strategies and parallel workflows to optimize build times. Whether you’re targeting iOS, Android, or both, this guide assumes you already have a Flutter project in Git and basic familiarity with fastlane and YAML.

Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Setting up Codemagic for Flutter

First, sign in to Codemagic and connect your repository (GitHub, GitLab, Bitbucket). Under Settings, define environment variables for sensitive data:

• APP_STORE_CONNECT_API_KEY (your base64-encoded key)

• MATCH_PASSWORD (for fastlane match)

• FIREBASE_TOKEN (if you deploy functions or hosting)

Enable “Automatic code signing” only if you prefer managed profiles; otherwise, use fastlane match to keep certs in a private Git repo:

1. Create a match repo:
   

   fastlane match init  
   # Securely store certificates and profiles  
   fastlane match appstore
   
   

2. Add your SSH deploy key in the Codemagic UI to clone the match repo at runtime.

Select the “macOS” build machine for iOS. For Android or Linux builds, you can pick “Ubuntu” and specify Java/Kotlin toolchains in the YAML.

Configuring Fastlane for Flutter

In your project root, run fastlane init and choose “Manual setup.” In fastlane/Fastfile, define lanes:

default_platform(:ios)

platform :ios do
  desc "Push a new beta build to TestFlight"
  lane :beta do
    increment_build_number(
      build_number: ENV['BUILD_NUMBER'] || latest_testflight_build_number + 1
    )
    build_app(scheme: "Runner")
    upload_to_testflight
  end

  desc "Release to App Store"
  lane :release do
    capture_screenshots
    match(type: "appstore")
    build_app(scheme: "Runner", export_method: "app-store")
    upload_to_app_store
  end
end

platform :android do
  desc "Publish to Play Store internal track"
  lane :android_beta do
    gradle(task: "clean assembleRelease")
    supply(track: "internal", json_key: ENV['GOOGLE_PLAY_JSON'])
  end
end

This Fastfile covers version bumping, screenshot capture, code signing (match), and deployment.

Integrating fastlane with Codemagic

Create a codemagic.yaml at your repo root. Key sections:

workflows:
  flutter_cicd:
    name: Flutter CI/CD with fastlane
    max_build_duration: 60
    environment:
      vars:
        BUILD_NUMBER: $CM_BUILD_NUMBER
        APP_STORE_CONNECT_API_KEY: Encrypted(...)
        MATCH_PASSWORD: Encrypted(...)
    scripts:
      - name: Install dart dependencies
        script: |
          flutter pub get
      - name: Run unit & widget tests
        script: |
          flutter test --coverage
      - name: Run fastlane beta
        script: |
          cd ios && bundle install
          cd .. && fastlane ios beta
      - name: Run Android lane
        script: |
          fastlane android android_beta
    artifacts:
      - build/ios/ipa/*.ipa
      - build/app/outputs/**/*.apk
    publishing:
      email:
        recipients:
          - team@example.com
        on_build_success: true

Key points:

• Use $CM_BUILD_NUMBER for unique builds.

• Separate iOS and Android lanes and leverage fastlane’s platform blocks.

• Archive artifacts for manual download or integration with Slack/email.

Advanced Deployment Flows

Parallelizing tests and builds can slash your feedback loop. Define multiple workflows:

workflows:
  test:
    scripts:
      - flutter pub get
      - flutter test

  build_and_deploy:
    depends_on:
      - test
    scripts

For multi-environment releases (dev, staging, production), parameterize your lanes:

lane :deploy do |options|
  env = options[:env] || "staging"
  build_mode = env == "production" ? "release" : "debug"
  build_app(scheme: "Runner-#{env.capitalize}", export_options: {method: build_mode})
  if env == "production"
    upload_to_app_store
  else
    firebase_app_distribution(
      app: ENV['FIREBASE_APP_ID_'+env.upcase],
      testers: "qa-team@example.com"
    )
  end
end

Invoke with fastlane ios deploy env:production. On Codemagic:

scripts

Combine with feature flags in Dart:

import 'dart:io';

void main() {
  final env = Platform.environment['FLAVOR'] ?? 'staging';
  runApp(MyApp(env: env));
}

Vibe Studio

Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Conclusion

By coupling fastlane’s scripting power with Flutter codemagic’s streamlined CI/CD, you can automate testing, signing, and deployment for both iOS and Android in one place. Use environment variables, encrypted keys, and parallel workflows to minimize manual intervention. Advanced techniques—like dynamic lanes, multi-environment builds, and Firebase distribution—ensure your team moves fast without sacrificing reliability.