Every comparison of iOS CI options is a comparison of build minutes and macOS hardware, because those are the numbers vendors publish. They are also the part you can buy your way out of at any time. The decision that actually determines whether a team can ship is where the signing identity lives — who holds the certificates, who can issue a build, and what happens the morning one expires. Pick your infrastructure on that, and treat compute as the commodity it is.
There is one structural fact that makes iOS continuous integration unlike the rest of your pipeline: Apple's toolchain runs on macOS. Every build, however it is arranged, ends on Apple hardware somewhere. That constraint is why this part of the pipeline costs more than the rest, and it is why most of the published comparisons are about hardware.
They are answering the easy question. We have written about the general self-hosted versus managed decision elsewhere; iOS deserves its own treatment because the thing that breaks is different.
Compute is the commodity. Signing is not.
Build compute has every property of a commodity. It is measurable, substitutable, and if you need more you buy more, today. A pipeline that is too slow is annoying and improvable.
Code signing has none of those properties. Certificates expire on a date nobody diarised. Provisioning profiles must match bundle identifiers and capabilities exactly, and when they do not, the error message is rarely about the thing that is wrong. The credential is often on one developer's laptop, because that is where it was created. And the moment you need to fix it is, reliably, the moment you most need to ship.
So the useful way to evaluate an option is to ask three questions about signing and let the build minutes be a tiebreak.
The three questions
Who holds the signing identity? Self-hosting keeps it on your own hardware. A hosted runner usually means you hold it in your own secret store and inject it at build time. A managed mobile platform typically holds it for you, which is genuinely less work and is also a decision to make deliberately rather than by default — in a regulated client's supply chain review, "a third party can sign builds in our name" is a question you will be asked.
Can you still ship if that provider is unavailable? Not a theoretical question; outages and queue times are ordinary. Hosted macOS capacity in particular is finite and shared, and waiting for a machine is a normal failure mode rather than an exceptional one. If a provider's bad afternoon means a security fix cannot go out, that is a real risk to price, and it compounds with the store review queue already sitting between you and your users.
Who can issue a build at 7pm on a Friday? The honest answer in many teams is "one person, and they are on a flight". That is not an infrastructure choice, it is a consequence of one. Whatever you pick, the signing material should live somewhere version-controlled, encrypted and restorable — the widely used pattern keeps certificates and profiles in a private encrypted repository that build machines fetch at build time. The specific tool matters far less than removing the single point of failure.
What a hosted runner does not buy you
A point worth making because it surprises people: moving to hosted macOS runners removes the hardware problem and leaves the signing problem entirely with you. You still write the steps that import the certificate, select the profile, archive, export and upload. The machine arrives clean; everything about making it trusted is yours.
Managed mobile build platforms are the ones that genuinely take signing off your plate, storing certificates and matching profiles to targets for you. That is the actual distinction between the middle and bottom rows above, and it is usually mis-stated as a difference in convenience when it is a difference in custody.
The cross-platform trap
If you build with Flutter or React Native, there is a specific decision worth getting right early: do not end up with two pipelines.
Apple's own build service is tightly integrated and handles much of the signing work, and it only builds Apple platforms. Adopt it for a cross-platform codebase and you now maintain two pipelines, two sets of conventions and two places a release can stall — and your Android release will quietly become the neglected one. For a shared codebase, a single pipeline that produces both artefacts from the same commit is usually worth more than per-platform polish, which is the same argument as the rest of the cross-platform case.
Optimise for recovery, not duration
Build duration is the metric everyone reports and it is rarely the one that hurts. The metric that hurts is how long it takes to get from a failed build to a shipped one.
A fifteen-minute pipeline that fails at signing, on a Friday, and needs a specific person's laptop, is more expensive than a thirty-minute pipeline anyone on the team can unblock. Faster builds are a productivity improvement. An unrecoverable build is an outage with a release attached.
The practical test: have someone who has never touched the pipeline produce a signed build from a clean machine, using only what is written down. Whatever they get stuck on is your actual infrastructure problem, and it is almost never compute.
Questions we get asked
Do you need a Mac to build an iOS app?
Yes. Apple's toolchain runs on macOS, so every iOS build in your pipeline ends up on Apple hardware somewhere — whether that is a machine in your office, a hosted macOS runner, or a managed build service. This single constraint is why iOS CI is structurally different from the rest of your pipeline and why it tends to be the most expensive part of it.
Should we self-host macOS runners or use a managed service?
Decide it on signing and continuity rather than on cost per minute. Self-hosting keeps the signing identity on hardware you control and removes queue times, at the price of owning Xcode upgrades, OS patching and keychain behaviour. A managed service removes that maintenance but places your signing identity with a third party. Most teams without dedicated ops capacity are better served by a managed option.
What is the hardest part of an iOS CI pipeline?
Code signing, by a wide margin. Certificates expire, provisioning profiles must match bundle identifiers and capabilities exactly, and the failure messages are famously unhelpful. Build compute is a solved problem you can buy. Signing is a credential management problem you have to design, and it is where pipelines break at the least convenient moment.
Where should iOS signing certificates be stored?
In one place that is version-controlled, encrypted and restorable — not on a developer's laptop, which is where they usually live. The widely used pattern keeps the certificates and profiles in a private encrypted repository that the build machine retrieves at build time. What matters most is that the answer to who can issue a build does not depend on one person being reachable.
Does Xcode Cloud remove the need for other CI?
Only for teams building Apple platforms exclusively. It is tightly integrated and handles much of the signing work, but it does not build your Android app, so a cross-platform team ends up running two pipelines with two sets of conventions. For a Flutter or React Native codebase, a single pipeline that builds both platforms is usually worth more than per-platform polish.
How long should an iOS build take?
Less important than how long it takes to recover from a failed one. A fifteen-minute build that fails at the signing step on a Friday and cannot be fixed without a specific person is more expensive than a slower pipeline anyone can unblock. Optimise for recoverability first, then for duration.
If one person on your team is the only one who can produce a signed build, that is worth fixing before it is tested by an incident. It is a short piece of work and it is where we usually start on mobile delivery engagements.