Back to Blog
iOS DevelopmentMobile DevOpsSwiftDeveloper ToolsRuntime ControlApp StoreMobile Infrastructure
Your iOS Hotfix Is Ready. Your Users Won't Get It for 14 Days
PipeKit Team
It's 11 PM on a Thursday. A restaurant chain operating across three countries just discovered that a tax calculation bug is silently undercharging customers. The fix? Four lines of Swift. The time to reach users? Fourteen days — if you're lucky.
We've lived this reality. For years, we managed iOS applications running on tens of thousands of point-of-sale devices. These weren't consumer apps where a bug means a slightly broken animation. These were devices processing real money, managing real inventory, and printing real receipts for real customers sitting at real tables.
When something went wrong — and in production, something always goes wrong; the distance between "fix written" and "fix deployed" was measured in days, sometimes weeks. The App Store review cycle doesn't care that your client is losing money. It doesn't care that the fix is a single-line config change. The process is the process.
Backend Teams Can Deploy in Minutes. Why Can't You?
A configuration change on the backend? Push it. A feature flag toggle? Flip it. A hotfix? Deploy in minutes. Backend teams have runtime control over their services.
Mobile teams have… hope that Apple will review the binary quickly.
That gap: between how backend teams operate and how mobile teams are forced to operate; is where PipeKit was born.
We had a feature flag that needed to change for a subset of devices running a specific firmware version. On the backend, this would have been a five minute configuration update. For us, it meant a new build, a new submission, a new review cycle, and then a phased rollout hoping nothing else broke in the process.
The question we kept coming back to: why doesn't a control plane exist for mobile apps?
Not remote config; we had that. Not A/B testing, we had that too. We meant a genuine control plane. The ability to orchestrate runtime behavior, observe what's happening on production devices, and respond to problems without shipping a new binary.
The tools available were either too narrow (feature flags only), too broad (full observability platforms with no action capability), or designed for web applications first with mobile as an afterthought.
So we built one.
Define the Behaviors at Build Time. Decide Which Are Active at Runtime.
The phrase "control plane" comes from networking, the layer that decides how traffic flows, separate from the data plane that actually moves the packets. The decision making layer.
For mobile apps, that means: after your app ships, you keep the ability to make operational decisions about how it behaves. Not by injecting arbitrary code; that would be reckless and would rightly violate App Store guidelines. But by pre declaring the points of control in your application and orchestrating them remotely.
PipeKit lets you annotate Swift functions with a @Rewire macro. That annotation registers the function as a remotely controllable node. From the PipeKit dashboard, you can trigger that function, compose it into multi step flows, observe its execution, and replay the session to see exactly what happened.
@Rewire("clear-cache")
func clearCache() async -> NodeResult {
await CacheManager.shared.purge()
return .success(["freed": "128MB"])
}That function is now visible on your dashboard. Execute it on a specific device, a group of devices, or your entire fleet. Compose it into a flow: clear cache → refresh config → log the result. Every execution is recorded; tied to a session replay so you can see the full context.
What PipeKit Isn't (And Why That Matters)
We've seen too many developer tools overpromise. Here's what PipeKit is not:
Not a way to push arbitrary code to production devices. Every function that can be remotely triggered must be declared in your codebase, compiled into your binary, and shipped through the App Store. We don't circumvent the review process — we make the time between reviews less painful.
Not analytics, crash reporting, or A/B testing. There are excellent tools for each of those jobs. PipeKit is the orchestration and control layer that sits alongside them.
Not magic. It requires you to think about your app's architecture, to identify the points where runtime control would be valuable and to declare them explicitly. That intentionality is a feature, not a limitation. Every remotely controllable function is auditable, traceable, and deliberate.
Why This Wasn't Possible Until Now
Swift macros have matured. The @Rewire macro that powers PipeKit's node registration would have been impossible before Swift 5.9. Macros give us compile time code generation that's type safe and IDE friendly. The developer experience of annotating a function and having it become remotely controllable, that elegance only exists because of where Swift is today.
Mobile teams are being held to backend level expectations. The tolerance for "we'll fix it in the next release" is shrinking. Users expect apps to just work. Product teams expect instant iteration. The gap between what's expected and what's possible with traditional mobile release cycles grows wider every quarter.
The iOS ecosystem in emerging markets is exploding. Companies across the Middle East, Southeast Asia, and Latin America are building increasingly complex iOS applications where reliability is a competitive advantage. These teams need infrastructure grade tools, and most existing solutions are designed for Silicon Valley use cases first.
Zero Dependencies. Minutes to Integrate.
The SDK is native Swift, distributed as a drag-and-drop XCFramework with zero external dependencies. Add it to your Xcode project and you're running in minutes.
The iOS SDK is shipped. The dashboard is live. The docs are written. Session replay works.
Join the First 100 Teams
PipeKit is in early access. The free tier gives indie developers and small teams everything they need to experience runtime control for the first time.
For the first 100 teams that join, founding member pricing locks in 50% off for life when paid plans launch.
If you've ever sat waiting for an App Store review while your users sit with a bug you fixed hours ago, PipeKit was built for you.
If you've ever wished your mobile team had the same operational agility as your backend team, PipeKit was built for you.
If you believe that shipping a binary shouldn't be the last time you get to make decisions about how your app behaves, PipeKit was built for you.
Ship logic, not binaries.
PipeKit is the runtime control plane for iOS applications. We help mobile teams orchestrate production logic, replay sessions, and modify app behavior without App Store updates.
Turn it off without shipping a build.
Feature flags, kill switches and session replay for iOS and Android. One SDK, one dashboard.
Get Started Free