One codebase, two app stores:
native where it actually matters
React Native lets us build one codebase that ships to both iOS and Android, which is cheaper and faster than two fully separate native apps for most products, and we drop into native Kotlin or Swift modules for the specific pieces, widgets, wallpaper rendering, background processing, that React Native cannot do well on its own. A fitness app we built this way shipped with 1,077 backend tests.
What it is
React Native is a framework that compiles one JavaScript and TypeScript codebase into real native apps on both iOS and Android, sharing most of the UI and business logic while still rendering native platform components underneath, not a web page wrapped in a native shell. Where a feature needs something React Native cannot do well, we write a small native module in Kotlin for Android or Swift for iOS and call it from the shared code.
When you need it (and when you do not)
It earns its cost for most consumer and business apps: a fitness app with AI coaching, a marketplace app, a booking app, anything where the core value is screens, data and a backend rather than deep platform-specific behavior. Building and maintaining one codebase instead of two separate native apps typically cuts both the initial build cost and the ongoing maintenance burden by roughly a third to half, since most bug fixes and features ship once instead of twice.
It is the wrong tool when the app’s core feature is something platform-specific at a deep level, a background audio engine competing for system resources, a camera pipeline doing real-time image processing, or heavy custom rendering like the wallpaper engine behind one of our own apps. Those we build natively from the start, since forcing them through a cross-platform layer costs more in workarounds than it saves in shared code.
How we build it
We start with the data model and architecture before any screen: what the app actually stores, how it syncs, what happens offline, since retrofitting this after screens are built is where most React Native projects go over budget. The backend gets automated tests from the first week, a fitness app we built reached 1,077 backend tests by launch, because a mobile app is only as reliable as the API it talks to.
For anything React Native handles natively well, navigation, forms, standard animations, lists, we build directly in the shared codebase. For the specific pieces that need real native code, a home screen widget, background location, custom wallpaper rendering, we write a native module in Kotlin or Swift and expose it to the JavaScript side through a clean interface, so the rest of the team keeps working in one codebase while that one feature gets genuine native performance.
Push notifications, deep links and offline caching get built in according to what the product actually needs, not added as an afterthought, and analytics is wired in from the first release so you have real usage data from day one instead of guessing what to build next.
What to watch
React Native upgrades occasionally bring breaking changes, especially around native module compatibility, so we pin dependencies deliberately and test upgrades rather than taking them automatically. App store and Google Play review can add a few days to a launch timeline, longer if the app touches a sensitive category like health or finance, and we plan the schedule around that rather than promising a launch date the review process does not control. Cost of ownership includes both platforms’ annual developer fees and the actual maintenance time, which we lay out honestly before the project starts.
Price and timeline
| Option | Price | What it covers | Timeline |
|---|---|---|---|
| Core app, standard features | from $5,000 | Few key screens, backend, standard integrations, both stores | 6 to 8 weeks |
| App with AI, gamification or native modules | from $12,000 | Everything above plus custom native modules and advanced features | 10 to 14 weeks |
Running cost is backend hosting plus any AI or analytics usage, typically $50 to $400 a month depending on user volume.
Related
This pairs with native iOS app development or native Android app development for the specific features that need a fully native build, and with offline-first mobile app for apps that must work without a connection. See the development service page for our full build process. For real examples, see the fitness app with AI coach and gamification and TaskWall, our own wallpaper to-do app.
Have an app idea and not sure if it needs to be fully native? Get in touch and we will tell you honestly which one fits.
FAQ
How much does a React Native app cost?
From $5,000 for an app with a handful of core screens, a backend and standard integrations, 6 to 12 weeks. An app with AI features, gamification or a full social layer runs $10,000 to $20,000+ depending on scope; we give the exact number in a written plan after the brief.
Is React Native actually as good as native?
For most app categories, yes, and it halves the cost of maintaining two codebases. Where it falls short, heavy animation, background audio or location processing, certain widget or lock-screen integrations, we write a native module in Kotlin or Swift for just that piece rather than forcing the whole app into a framework that cannot do it well.
Do you use Expo or bare React Native?
Expo for most projects, since it gets us to a working build faster and handles a lot of the native build tooling. We eject to bare React Native, or add native modules on top of Expo, when a feature needs direct native code, which is common enough that we plan for it upfront rather than hitting a wall mid-project.
Who owns the app and the backend?
You. The repository, the app store and Google Play developer accounts, and the backend are all set up in your name, with source code handed over at the end of the project, not licensed back to you.
What about ongoing maintenance after launch?
iOS and Android both ship OS updates that occasionally break something, and app store policies change. We offer ongoing support plans, or hand over a clean codebase with tests and documentation if your team prefers to maintain it themselves.