One codebase, both platforms
React Native with TypeScript. Platform-specific native code only where it is genuinely required, and documented when it is.
Software Development
One codebase. Both app stores. Handled.
React Native apps that feel native, ship to iOS and Android together, and don't need two separate teams. Including the review and submission process, which is where most first-time launches lose a month.
Two platforms, two teams, two backlogs, twice the drift.
Native builds mean two codebases. Every feature gets specified once and implemented twice, the platforms drift out of sync, and you carry double the maintenance forever. For most products that is a cost with no matching benefit.
React Native shares the great majority of code across both platforms while still rendering real native components, so it feels like an app rather than a website in a shell. When something genuinely needs platform-specific native code, we write that piece natively rather than fighting the framework.
The other thing that derails launches is store review. Apple rejects for reasons that are not obvious in advance, and each round trip costs days. We handle submission, metadata, and the rejections, because knowing the common causes in advance is worth more than any amount of optimism.
What the build includes
Store submission handled
App Store and Play Store setup, metadata, screenshots, privacy declarations, and the review process, including responding to rejections.
Over-the-air updates
Configured so you can ship most fixes to users without waiting for another review cycle. This changes how fast you can respond to a problem.
Offline behaviour designed, not assumed
We decide explicitly what works without a connection and what happens when it returns. Mobile networks fail constantly and pretending otherwise produces bad reviews.
Push notifications that respect the user
Set up properly, with permission timing that does not get denied immediately and preferences users can actually control.
Analytics and crash reporting from launch
Instrumented before release, so your first week of real usage produces data instead of guesses.
What we build with
App
- React Native
- Expo
- TypeScript
- React Navigation
Backend
- Node.js
- Postgres
- Firebase
- REST & tRPC
Mobile services
- Push notifications
- Over-the-air updates
- Crash reporting
- In-app purchases
AI
- Anthropic API (Claude)
- On-device speech input
- In-app AI assistants
Everything handed over.
Listed explicitly so there is no argument later about what was in scope.
- iOS and Android apps published to both stores
- Full React Native source in your Git organisation
- App Store and Play Console accounts configured under your ownership
- Over-the-air update pipeline
- Push notification infrastructure
- Crash reporting and analytics
- 30 days of post-launch bug fixes at no charge
Honest scope
Is this right for you?
We would rather lose the enquiry than take on work we are the wrong people for.
A good fit if…
- You need both iOS and Android without funding two teams
- Your app is content, commerce, booking, social, or workflow shaped
- You want to iterate after launch rather than ship once
- You would rather someone else dealt with store review
Not for…
- Games, or anything requiring heavy 3D or sustained high-frame-rate rendering. Use a native or game engine
- Apps whose entire value is a very deep platform integration, where native is simply the right call
- Products that would serve users better as a website; we will say so, and it will save you a lot of money
- Anyone needing an app on the stores in under a month, unless scope is genuinely tiny. Review timelines are not ours to control
Ways to start
Pick an entry point.
Larger engagements vary enough that a headline number would mislead, so those are quoted after a free call. We always tell you what drives the number.
Mobile Discovery
Scoping the app properly, and confirming it should be an app at all.
Quoted
Priced on the size of the app
2 weeks
- Requirements and user-flow workshops
- Clickable prototype of the core journey
- Technical plan, including native requirements
- Costed delivery plan and store-readiness checklist
- Implementation
App Build
Getting a real app into both stores.
Quoted
Priced after discovery, when the scope is real
4-7 months typical
- iOS and Android from one codebase
- Backend and API build if needed
- Store submission and review handling
- Analytics, crash reporting, and push
- 30 days of post-launch fixes
App Care
Keeping a live app healthy. OS updates break things on a schedule.
Quoted
Monthly, priced on the app's complexity
Rolling monthly
- iOS and Android OS compatibility updates
- Dependency and security patching
- Crash triage and fixes
- Store metadata maintenance
Questions, answered.
React Native or fully native, which do we need?
React Native for the large majority of products: one codebase, genuinely native components, and roughly half the ongoing maintenance. Go fully native when your app's core value depends on sustained high-performance rendering, heavy 3D, or very deep platform-specific hardware integration. We will tell you honestly which case you are in during discovery, including when the answer costs us the project.
Do you handle getting it into the App Store?
Yes, end to end: developer account setup, metadata, screenshots, privacy and data-use declarations, submission, and responding to rejections. The accounts are created under your ownership, so you are never dependent on us for access to your own listing.
How long does it really take?
Four to seven months is typical for a first version with a real backend. Add one to three weeks for store review on the first submission. Apple's timeline is not ours to control, and first-time apps are rejected more often than experienced teams admit publicly.
Can you update the app without going through review every time?
For most changes, yes. We configure over-the-air updates so JavaScript-level fixes and content changes reach users directly. Changes to native code or store metadata still require a review cycle, but that is a much smaller share of typical updates.
Start with a free conversation.
Thirty minutes, no pitch. We will tell you what we would do, what it would take, and whether you need us at all.