Software Development
CI/CD for a Solo Developer: Shipping iOS Builds With Codemagic
As the only developer working on Tracademic, I don't have a team to catch a broken build before it ships, so CI/CD isn't a nice-to-have — it's the thing standing in for a second pair of eyes. This post is about the pipeline I use to ship iOS builds with Codemagic, and one gotcha in particular that cost me more time than it should have before I understood why it kept happening.
Why CI/CD matters even when you're the only developer
It's tempting to think CI/CD is mainly about coordinating a team: making sure everyone's changes integrate cleanly, catching conflicts early, enforcing a review step before merge. None of that applies when you're working alone. What does apply is everything CI/CD does after that point — running the same build and checks the same way, every time, regardless of what state your local machine happens to be in. A build that only works "on my machine" is a build I can't trust, and as a solo developer, I don't have anyone else's machine to fall back on as a sanity check.
For Tracademic specifically, the iOS build has extra reasons to need this discipline: it depends on native tooling, code signing, and a build process that's slow and fiddly enough that I don't want to be running it by hand before every submission.
The pipeline
The shape of the pipeline is fairly standard for a Capacitor app: install dependencies, build the web app, sync the native iOS project from that build, then hand off to Xcode's build and archive process, with Codemagic managing code signing and the App Store Connect upload at the end. Each of those stages runs the same way on every trigger, which is the entire point — nothing about the process depends on what I happen to remember to do locally.
The gotcha: the ios/ directory doesn't survive
The lesson that actually changed how I think about the pipeline was this: Capacitor's npx cap sync ios step regenerates the native ios/ project from the web app's configuration on every single build. That's exactly what you want for keeping the native project in sync with the web codebase — but it also means any change made by hand directly inside the ios/ folder, including small Xcode project settings, gets silently wiped out the next time CI runs cap sync.
I hit this with ITSAppUsesNonExemptEncryption, an Info.plist setting that affects export compliance declarations during App Store submission. Setting it by hand in Xcode worked — until the next CI build regenerated the project and quietly reverted it, with no error and no obvious signal that anything had changed back.
Injecting settings in the YAML instead
The fix was to stop treating that setting as something to configure once in Xcode, and instead treat it as part of the build script itself — something the pipeline sets every time, after the sync step, so it can never silently drift back to a stale value:
scripts:
- name: Sync Capacitor iOS project
script: npx cap sync ios
- name: Set non-exempt encryption flag
script: |
/usr/libexec/PlistBuddy -c "Add :ITSAppUsesNonExemptEncryption bool false" \
ios/App/App/Info.plist
The general principle behind this fix applies well beyond one plist key: anything that lives inside a directory a tool regenerates has to be treated as ephemeral. If a setting needs to persist, it has to be re-applied by the pipeline after the regenerating step, every time, rather than committed as a one-off manual change to a file that isn't actually meant to be edited by hand.
It turned out to be a configuration error, and it took me a fair few hours to track down and fix.
The takeaway
CI/CD for a solo developer isn't about coordinating other people — it's about making the build itself trustworthy and repeatable, so you're not relying on memory or a correctly-configured local machine before every release. And when a tool regenerates part of your project on every run, as Capacitor does with ios/, anything that needs to survive that regeneration belongs in the pipeline script, not in a file you edited by hand once and hoped would stick. It's a small habit, but it's the difference between a setting that's actually set and one that only looks set until the next build quietly undoes it.
That same iOS build is what eventually had to satisfy App Store review — the specific guidelines that came back are in What App Store Rejection Taught Me.