Senior engineers · since 2023
Mobile app development
React Native with Expo for one-codebase iOS and Android, or fully native Swift and Kotlin where the build genuinely needs it. EAS builds, App Store and Google Play submission included.
01 — What we build
Built for production, end to end.
Cross-platform from one codebase
One React Native codebase ships to both iOS and Android, which is the right call for roughly 80% of briefs. You get two stores from a single team, written in TypeScript so the app layer stays typed end to end.
Native Swift and Kotlin when it counts
When low-level APIs like vision, ARKit or sensors are the product surface, we go fully native in Swift on iOS and Kotlin on Android. Same engineering rigour either way: typed networking, deterministic state, predictable releases.
EAS builds and store submission
Expo's EAS pipeline handles the platform-specific signing and packaging for both stores. App Store and Google Play submission is part of every engagement, including review prep, screenshots and privacy declarations, not a separate retainer.
OTA updates and release safety
EAS Update ships JavaScript-layer fixes without waiting on a new store review, with staged rollouts and instant rollback if a bundle misbehaves on a specific OS version. Only native changes need a full release; everything above that ships within the day.
In-app purchases and subscriptions
Purchases and subscriptions run through RevenueCat so entitlements and restores work across iOS and Android without rebuilding billing on each platform. We wire it once and keep your store receipts and access in sync.
Native performance and feel
Animations and gestures run on Reanimated to stay on the UI thread at 60fps instead of stuttering through the JavaScript bridge, and lists are virtualised. We profile on real low-end devices, because that is where jank shows up first.
Mobile here means React Native with Expo for most projects, and native Swift and Kotlin reserved for the builds that genuinely need them. React Native is the default because one codebase that ships to iOS and Android, with Expo's EAS build pipeline handling the platform-specific signing and store submission, is the right answer for roughly 80% of client briefs.
When to go native
Going native is the call when the build needs platform-specific UI patterns that React Native fights, when low-level APIs (vision, ARKit, sensors) are the product surface, or when a long-lived app already has native code that would be expensive to re-platform. In those cases we ship in Swift for iOS and Kotlin for Android with the same engineering rigour: typed networking layers, deterministic state, predictable releases. Recent native builds — KinBridge in SwiftUI on Supabase (VisionKit OCR, EventKit calendar sync, HealthKit dashboard, WidgetKit lock-screen) and AI Study Coach in Kotlin and Jetpack Compose (ML Kit OCR, foreground-service Pomodoro timer, AlarmManager reminders that survive reboots) — both earned the native decision on the strength of the system APIs they depend on.
Payments, notifications and the services apps actually need
The features that make an app feel finished live in the platform services. In-app purchases and subscriptions go through RevenueCat so entitlements work across iOS, Android and restores without rebuilding billing logic on each platform. Push notifications, analytics and crash reporting run on Firebase. Where a feature needs something React Native doesn't expose, we drop to a native module in Swift or Kotlin rather than forcing a brittle workaround.
Performance and feel
A cross-platform app should still feel native. Animations and gestures run on Reanimated so they stay on the UI thread at 60fps instead of stuttering through the JavaScript bridge, lists are virtualised, and we profile on real low-end devices, not just the latest flagship, because that's where jank shows up first.
Store submission, not a separate retainer
App Store and Google Play submission are part of every engagement, not an extra. That includes review prep, screenshot generation, privacy declarations, and the rejection-appeal cycle when Apple decides your in-app purchase implementation needs a different ten lines of code.
OTA updates and release safety
EAS Update lets us ship JavaScript-layer fixes without a new store review, with staged rollouts and an instant rollback if the new bundle misbehaves on a specific OS version. Native crashes still need a full release; everything above the native layer ships within the day.
02 — The right stack
Stack-agnostic, by design.
We're stack-agnostic by design. We pick the right tool for the problem in front of us, then ship it to production properly, not whatever we happened to use last time.
How we select: We weigh the problem, your team's skills, the hiring market and the long-term maintenance cost. The goal is software you can run and grow without us.
FRONTEND
React Native
React Native is our default for mobile because one codebase ships to iOS and Android with native UI components, not a webview. The component model and ecosystem mean features land fast while the app still feels native.
Best for: Cross-platform iOS and Android apps from a single codebase
INFRASTRUCTURE
Expo / EAS
Expo and its EAS service handle the build, signing and store-submission plumbing we would otherwise hand-roll per platform. EAS Update also lets us push JavaScript-layer fixes over the air with staged rollout and rollback.
Best for: Build pipelines, OTA updates and App Store / Play submission
FRONTEND
Swift (iOS)
When a brief needs platform-specific UI or low-level iOS APIs like ARKit or the camera, we build native in Swift. We also reach for it to write native modules when React Native does not expose a capability.
Best for: Native iOS apps and custom iOS modules
FRONTEND
Kotlin (Android)
Kotlin is our language for native Android, used when the requirements warrant a fully native build or a native module that React Native cannot reach. Typed networking and deterministic state carry over from the cross-platform work.
Best for: Native Android apps and custom Android modules
BACKEND
Node.js
Node.js powers the APIs and services a mobile app talks to, from auth to syncing data. Sharing TypeScript across the app and the backend keeps types consistent from the device to the server.
Best for: App backends, APIs and real-time sync services
03 — Why teams choose us
Senior engineering, clear accountability.
Fixed quote in 48 hours
We scope the work in writing within 48 hours, with price and timeline fixed before anything starts. No open-ended hourly drift.
Direct senior access
You work with the senior engineer who scopes and builds your project — no middle layer.
You own 100% of the code
Code, documentation and infrastructure are handed over at the end. No lock-in, no proprietary black boxes, nothing held hostage.
Reply within 4 hours
In UK business hours you hear back within four hours, and async over Loom for everything else. You always know where things stand.
AI where it earns its place
We use AI to move faster where it helps. A senior engineer decides what actually ships.
Rescue welcome
About a third of our work is inherited projects. We audit first, then fix or rebuild with the trade-offs spelled out plainly.
04 — The process
Agile, collaborative, and completely transparent.
Discovery & scoping
A short, focused kickoff. We learn the problem, agree the scope, and put price and timeline in writing within 48 hours.
UX/UI design
Wireframes then visual design, reviewed with you before a line of production code is written. No surprises later.
Development
Senior engineers build in weekly increments. You get a live preview and a Loom walkthrough every Friday.
QA & testing
We test as we go and again before launch, across devices and the edge cases that actually break things.
Deployment
We ship to production carefully, with monitoring in place and a rollback ready if anything misbehaves.
Post-launch
Code, docs and a handover walkthrough. Then support or a maintenance retainer if you want us close by.
05 — Selected work
Recent work in this space.
What clients say
“They exceeded my expectations and made my ideas come to reality, with great communication, and helped guide me to make informed decisions as this is all new to me. Highly recommend them, worth every penny!”
06 — FAQ
Common questions.
One codebase for iOS and Android, or fully native?
React Native with Expo for around 80% of briefs. We go fully native in Swift and Kotlin when low-level APIs or platform-specific UI demand it.
Do you handle App Store and Google Play submission?
Yes, submission is included, review prep, screenshots, privacy declarations and the rejection-appeal cycle.
Can you add in-app purchases or subscriptions?
Yes, via RevenueCat so entitlements work across iOS, Android and restores without rebuilding billing on each platform.
Can you fix bugs without a full app-store release?
Yes. EAS Update ships JavaScript-layer fixes with staged rollout and instant rollback, only native changes need a new review.
RELATED SERVICES
07, START A PROJECT
Got a project in mind?
Tell us what you're building. We reply within 4 hours during UK business hours.