Managing Monorepos with the Right Mobile CI/CD Strategy

7 Key Strategies to Manage Mobile Monorepos Efficiently in CI/CD

1. Implement Selective Builds: The most important strategy is to avoid building everything for every change. Instead, trigger only the pipelines affected by a specific change. This is not optional at scale. Skipping this step leads to longer CI pipeline durations, and developers lose trust in their build results over time.

2. Clear Naming Conventions and Triggering Rules: Tags, branch names, commit messages, and directory names should follow a consistent pattern across all projects in the repo. Whether teams use tag-based triggers, path-based triggers, or external orchestration, the rules should be clear and predictable.

3. Map Shared Code to Dependent Projects: Shared modules should be mapped to the apps that depend on them. If a shared authentication module changes, every app using that module should be rebuilt or tested.

4. Leverage Concurrent Builds: When multiple projects need to build, for example, after a shared library change, running them concurrently rather than sequentially can significantly reduce overall CI time. Instead of waiting for Android to finish before iOS starts, both pipelines run at the same time.

5. Monitor Build Performance Over Time: Track build duration, failure patterns, and queue times across all projects. Monorepo performance can degrade gradually as the repository grows, and catching regressions early keeps pipelines healthy and developer feedback loops fast.

6. Keep Distribution and Publishing Separate Per Project: Each app in your monorepo should have its own distribution and publishing process. A build from the iOS pipeline should only reach iOS testers, and a release to Google Play should never be triggered by an unrelated build. Separate workflows also make it easier to manage different release cadences across platforms.

7. Access Control and Governance: Use your CI/CD platform’s role and permission settings to ensure each team can only configure and manage the pipelines they are responsible for. Clear ownership at both the repository and pipeline level reduces the risk of accidental misconfigurations.

Sample Monorepo Structure:

In this example, we have a monorepo including an Android project, an iOS project, and a shared module containing common code used by both platforms.

Let’s walk through how to set this up.

1. Build Monorepo Apps with Appcircle

1.1 Create a Build Profile Per Project

Create a separate build profile in Appcircle for each project in your monorepo. When connecting the repository, you can use the autofill feature to automatically pull in configuration settings such as project path, scheme, and module.

All profiles point to the same repository, but each has its own configuration and workflow. Having a dedicated profile per project brings several advantages:

• Each pipeline can be triggered independently, avoiding unrelated builds
• Platform-specific build flows, signing, and environment variable groups can be defined separately
• Different build machines and platform-specific stacks can be utilized more efficiently
• Distribution and publishing settings remain isolated, giving each app its own release flow

1.2 Structuring Workflows per Platform

After successfully connecting the repository and setting up your configuration, it is time to customize your workflows. Each build profile can use a platform-specific workflow tailored to its own build steps, signing configuration, and distribution settings. Once everything is in place, you can start building manually or set up triggers to automate the process.

Note: Appcircle’s Git Clone step includes performance optimizations for faster repository fetching. For faster builds, you can also take advantage of advanced caching in your workflows.

1.3 Set Up Tag Push Triggers for Build Isolation

For controlled build flows, Appcircle’s Tag Push trigger can be used to route builds to specific profiles.

How it works:

Each build profile listens for a specific tag pattern. When you want to build only the Android app, you push a tag matching the Android profile’s pattern. The iOS profile ignores it.

Android profile trigger:

• Go to Triggers → On Tag Push
• Set Tag(s): android-app/*
• Set Config and Workflow

iOS profile trigger:

• Go to Triggers → On Tag Push
• Set Tag(s): ios-app/*
• Set Config and Workflow

Triggering a build:

The tag you push determines which build profile starts building. Here are two examples:

Only the Android profile starts building.

Only the iOS profile starts building. This can help avoid starting unrelated build profiles.

Handle Shared Code Changes

When something in shared/ changes, such as an API client, a config file, or a shared utility, both apps may need to rebuild. Add an all-apps/* tag pattern to both profiles for exactly this scenario:

Add to both profiles:

• Android profile → android-app/* + all-apps/*
• iOS profile → ios-app/* + all-apps/*

Conclusion

Monorepos can help mobile teams manage shared code, multiple apps, and cross-platform development more consistently. However, as teams and codebases grow, CI/CD design becomes critical.

The main challenge is not simply storing multiple projects in one repository. The real challenge is making sure that only the right builds run at the right time, shared changes are validated correctly, each project reaches the right distribution channels, and pipelines remain fast as the codebase scales.

With Appcircle, teams can structure mobile monorepos using separate build profiles, platform-specific workflows, tag-based build routing, and distribution strategies, keeping their repository centralized while maintaining clear, scalable, and independent mobile CI/CD pipelines. Ready to manage your mobile monorepo with Appcircle? Start for Free!

FAQs

1. Is monorepo better than polyrepo?

Not always. A monorepo can be useful for teams with multiple related apps, shared libraries, and coordinated platform work. A polyrepo approach may be better when projects are fully independent and require strong separation.

2. Does a monorepo slow down CI/CD?

It can if every change triggers every pipeline. With selective builds, caching, and clear workflow design, monorepos can be managed efficiently.