React Native Cross Platform App Development: When One Codebase Is Enough
When does React Native give a small team one codebase for iOS and Android, and when should you build native instead? A practical answer for engineering leaders.

React Native cross platform app development gives a small team one codebase for iOS and Android when the app is mostly screens, forms, lists, maps, payments and push notifications backed by an API. Build native when the product's core is a platform-specific capability, such as camera pipelines, ARKit, watchOS or heavy background processing, that JavaScript bindings cannot cover well.
The short answer on react native cross platform app development
Does React Native support cross-platform? Yes, and that is the whole point of it. You write components in TypeScript, and they render as real UIKit and Android views, not a web view. One team, one repo, one pull request that changes both apps.
The word to watch is "enough." A single codebase rarely means 100 percent shared code, and nobody serious promises that. Business logic, navigation, state, API clients and most screens are shared. A few percent of the app (a widget, a Bluetooth quirk, a payment sheet) ends up as Swift or Kotlin behind a module boundary. If that native slice stays small and well-isolated, you are in good shape. If it becomes the product, you picked the wrong tool.
Most B2B tools, marketplaces, booking apps, fitness trackers, content apps and internal field apps land on the good side of that line. That is why react native app development has become the default starting point for startups that need both stores covered before they have the headcount for two mobile teams.
What changes the answer
Where one codebase holds up
The strongest cases share a pattern: the hard problems live on the server or in product design, not in the device. Think of an appointment app with push reminders, a delivery tracker using maps and background location at a modest cadence, or a learning app with offline lessons and video playback. The libraries are mature (React Navigation, Reanimated, TanStack Query, MMKV, react-native-maps), and the New Architecture with Fabric and TurboModules is the default in current React Native releases, which removed much of the old bridge overhead that gave the framework a bad reputation around 2018.
There is a quieter benefit too. When iOS and Android are two codebases, they drift. A bug fixed on one platform lingers on the other for a sprint. A copy change ships Tuesday on iOS and Friday on Android. With one codebase, parity is the default and divergence is a deliberate choice, which is what you want when the team is five people and not fifty.
Where it frays
Failure modes are specific, and they show up early if you look for them:
- Custom camera or video pipelines: frame-by-frame processing, real-time filters or AR overlays. Libraries like react-native-vision-camera cover a lot, but if the camera is the product, you will fight abstractions daily.
- Platform-only surfaces: WidgetKit, Live Activities, watchOS, CarPlay, Android Auto. These are written in Swift or Kotlin regardless. React Native can host the main app, but the extension work is native, and you need someone who can write it.
- Long-running background work: iOS is strict about what can run when the app is not in the foreground. Continuous Bluetooth LE sessions, geofencing at scale or audio processing need native expertise and real-device testing, not just a JS library.
- Heavy animation or 3D at 120 Hz: Reanimated and Skia go far, but a game-like interface may be better in a native engine.
- Upgrade debt: apps that pile on unmaintained native modules hit pain at every React Native version bump. This is a team-discipline problem, not a framework flaw, but it is real.
React Native vs native, stated plainly
React Native vs native is not a quality contest. It is a trade between shared velocity and direct platform access. Native Swift and Kotlin give you day-one access to new OS APIs, the best profiling tools (Instruments, Android Studio Profiler) and zero abstraction between you and the platform. You pay with two codebases, two skill sets and two review queues.
React Native gives you one feature pipeline and a large JavaScript talent pool. You pay in occasional lag when a new iOS or Android API arrives and no one has wrapped it yet, in a build toolchain with more moving parts, and in the need to write a native module now and then. Flutter and Kotlin Multiplatform are credible cross platform mobile app development alternatives. Flutter draws its own pixels, which suits heavily branded UI. Kotlin Multiplatform shares logic but keeps native UI. React Native sits between them and wins when your team already writes React and TypeScript for the web.
Expo or CLI?
For most new apps, start with Expo. The React Native documentation itself recommends a framework for new projects, and Expo is the one it points to. Development builds, config plugins, EAS Build and EAS Update cover the work that used to push teams toward bare CLI setups: custom native code, over-the-air JS updates and CI builds without a Mac mini in a closet. The bare React Native CLI still makes sense if you have a large existing native app you are adding React Native screens to (brownfield), or an unusual build pipeline you cannot bend. Even then, many teams use Expo modules and prebuild. The old "Expo can't do native code" objection stopped being true a while ago.
Is React Native still a good choice in 2026?
For product apps, yes. Hermes is the default JavaScript engine, the New Architecture is the standard path, and the ecosystem has consolidated around fewer, better-maintained libraries. One thing worth knowing: Microsoft retired App Center, which many teams used for CodePush, so over-the-air updates now mean EAS Update or a self-hosted alternative. That is a migration to plan, not a reason to avoid the framework. What has not changed is the main risk: a team that treats native code as someone else's problem will stall the first time a library needs a patch.
How to decide and plan the work
Skip the whiteboard debate. Run a short, evidence-based decision that you can finish this quarter.
- List the five features the product cannot live without. Mark each as standard (UI, API, push, auth, payments, maps) or platform-specific (anything touching sensors, background modes, extensions, or new OS APIs).
- Spike the riskiest platform-specific feature on a real iPhone and a mid-range Android device. Not a simulator. A few days is enough to learn whether a maintained library exists, whether it behaves under backgrounding, and whether you would need to write a native module.
- Decide your native budget. If one or two small native modules cover the gap, proceed with React Native. If the spike shows the core experience depends on constant native work, build native for that platform or reconsider the product shape.
- Choose Expo with development builds unless you have a brownfield app or a pipeline constraint. Set up EAS (or your CI of choice with Fastlane) in week one, so you can ship to TestFlight and the Play internal track before the app has any real features.
- Test on the platform you do not personally use. Most parity bugs show up on Android hardware that the founder does not own. Add Maestro or Detox flows for sign-in, the core purchase or booking path, and one offline case.
- Plan the store work early. Apple review, privacy manifests, Play data-safety forms and account-deletion requirements take calendar time that no framework shortens.
Timelines depend on integrations, design readiness, offline needs and how many native modules you need, but a focused first release for a product app typically lands in roughly eight to sixteen weeks. Scope drives that range far more than the framework does. Cost drivers are the same list: integrations, offline sync, compliance requirements and platform-specific extras. We quote each engagement after a short call about the product, because two apps that look alike on a screen can differ widely underneath.
Where a delivery partner fits
Hiring two native engineers is slow and expensive for a seed-stage team, and hiring one React Native generalist who has never shipped a native module leaves a gap you will find at the worst moment. A partner earns its place by covering both sides: the shared TypeScript app and the thin native layer underneath it, plus the release plumbing that keeps both stores moving.
That is the shape of our React Native mobile app development work. We either embed in your team or deliver a fixed scope end to end, working remotely with daily overlap into Pacific and Eastern time. Our Storia case study and the Workout App case study show how we scope and ship mobile products, so you can judge the approach against your own roadmap.
What we do early is the spike from step two above, because it settles react native cross platform development questions with evidence. If the spike says your core feature needs deep native work, we will tell you that before anyone writes a sprint plan. Sometimes the honest answer is native for one platform first, and we would rather say so than force a framework onto the wrong product.
If this is on your roadmap, tell us what you are trying to ship and we will map a concrete next step.
