We build native iOS and Android products, including the hard ones where an app has to talk to hardware you are also designing.

Mobile has failure modes the web does not: an app store between you and your users, two platforms drifting apart, and a device that can be offline, out of battery or three OS versions behind. These are the six we get called about.
Everything from the web product is in there, laid out for a phone. It technically works. Nobody opens it twice, and the reviews say so politely.
The team ported features instead of asking what someone actually does on a phone, which is usually one or two things, quickly, often with one hand and bad signal. Cutting the app down tends to raise usage more than adding to it does.
They launched together. Two years on, Android is a version behind, three features do not exist there, and every release needs twice the QA it used to.
Two codebases were the right call at launch and stopped being the right call once the feature set stabilised. This is the strongest case for React Native, which is about 30% of our stack, but migrating for its own sake is rarely worth it. The question is where the shared logic actually is.
A connected product where the firmware team and the app team are different companies. The Bluetooth connection drops, and each vendor has a convincing explanation involving the other one.
Nobody owns the protocol between them. On Neuropeak Pro our team led the coordination between the app engineers and the third-party hardware developers precisely so the seam had an owner, and that is the main reason connected products go smoothly or badly.
The build is done and it has been sitting in review limbo for three weeks over something nobody anticipated: a permission string, a login requirement, a payment path.
Most rejections are predictable from the guidelines and land in the same few areas: account deletion, what you do with permissions, and whether you route payments outside the store. Reading those before designing the flow costs an afternoon and saves the three weeks.
Downloads look fine. Day-7 retention does not. The roadmap is full of features intended to fix that, none of which have.
Retention is set in the first session far more than by the feature list. If someone has to create an account, grant three permissions and read an onboarding carousel before seeing anything useful, the features further in will not rescue it.
Tested on a current iPhone on office wifi. In the field it is used on three year old Android handsets, in a basement, with 4% battery.
Offline behavior and low-end device performance were never requirements, so they were never built. Both are much cheaper to design in than to retrofit, because retrofitting offline usually means rewriting how the app stores data.
Clutch records our mobile split as an even 50 / 50 between Android and iOS, with React Native at about 30% of our stack. That balance is deliberate: we do not have a favorite platform to sell you.
Contact usSwift apps built to Apple’s conventions rather than a cross-platform approximation of them, for products where the interface is the thing people judge you on.
Kotlin apps that behave correctly across the range of devices your users actually own, which is much wider than the range your team tests on. Android is half our mobile work, not an afterthought.
Products where the app is one half and a physical device is the other. On Neuropeak Pro we built a wearable belt on the open source Movesense platform reading heart rate, accelerometer and gyroscope, with the firmware and app designed against each other.
One codebase where the feature set is genuinely shared and the interface is not the differentiator. About 30% of our stack. We will tell you when native is the better answer, which is often.
Mapping what someone does in the ninety seconds they have your app open, before anyone writes code. UX strategy is 40% of our design practice on Clutch, with usability testing and user research behind it.
The API, sync and offline behavior underneath the app. Mobile is where a careless backend hurts most, because a phone is regularly on a bad connection and cannot simply retry forever.





















Three of these publish a hard result and one does not. We have said which is which rather than implying a result the case study does not carry.
Two native mobile products, the platform behind a third, and a web app that ended manual reporting, built by the Chicago team named further down this page. We do not publish client head office locations, so these are our work rather than a claim about their addresses.




Three steps to a plan, then phased delivery. On mobile the phasing matters more, because app review sits between every release and your users.
How we handle scope changes. Scope moves on almost every software project, and pretending otherwise is how budgets get broken quietly. We price and sequence in phases so a change is a decision you make at a milestone with the cost in front of you, rather than something you discover in an invoice. Our Clutch reviews are public, including the ones that mention budget and schedule, and we would rather you read them before the call than after it.
You talk to product people and an engineer rather than a sales rep, often the same day you get in touch. We want to hear the problem before the feature list, because the feature list is usually somebody’s first guess at a solution and it is worth testing.
You get a custom development plan within a week: scope, sequence, the team assigned, what the first milestone proves and what it costs. The plan is yours whether or not you continue with us, which is deliberate. It is hard to compare quotes when nobody will write down what they actually mean.
Phased execution with the named engineers who will do the work, not a bench you never see again after the pitch. You get a working increment early rather than everything landing at the end, because that is what makes a change of direction affordable instead of catastrophic.
For moving scope or ongoing support. Billed by time worked, so you can stop any time. Harder when you need a fixed budget first.
For a build with a clear finish line. One price per phase, agreed up front. Harder when each mid-phase change means a re-quote.
For engineers working inside your own team. Billed monthly per engineer, rolling with notice. Harder when nobody on your side can direct the work.
For discovery, a first release, then a live roadmap. Fixed to launch, then hourly or monthly. Harder for projects under about six months, where the model is overkill.
A short conversation with a Chicago mobile engineer and a product person, not a sales sequence. If we are not the right fit we will say so on that call. Or call 312‑298‑9598, or visit us at 20 N Wacker Dr in Chicago.
Contact us



Connect with one of our product specialists today.
Nothing useful can be quoted without scope, so we do not print a range. The only public figures belong to Clutch: minimum project size $10,000, average hourly rate $150 to $199, and most reviewed engagements between $50,000 and $199,999. A single platform app with a simple backend sits low in that range; a connected hardware product with two native clients sits at the top.
It depends on where your differentiation is, and we have no incentive to push you either way: Clutch records our mobile work as an even 50 / 50 Android and iOS with React Native at about 30% of the stack. Native is the better answer when the interface itself is what people judge you on, when you need deep platform features, or when performance is the product. React Native earns its place when the logic is genuinely shared and the interface is not the differentiator. The wrong reason to choose cross-platform is to halve the budget, because it does not.
We build the app and work alongside the people who build the device. On Neuropeak Pro the wearable belt was built on the open source Movesense platform with third-party hardware developers, and our team built the app and led the coordination between the two sides. That matters because on connected products the expensive arguments happen at the seam between firmware and app, and a team that owns the coordination closes that seam instead of arguing across it.
A first release commonly lands three to six months from a signed plan, depending on integrations and whether there is hardware involved. Add time for app review itself, which is not fully predictable and is where avoidable delays cluster. We read the current store guidelines against your flows during discovery, because the common rejection reasons, account deletion, permission handling and payments routed outside the store, are all cheaper to design around than to fix after a rejection.
You do. The apps are published under your developer accounts, not ours, and you get the repositories, the signing setup and the documentation. This is worth asking every firm you talk to. An app published under an agency’s developer account is a genuinely difficult thing to move later, and it is not always obvious that it has happened until you try to leave.