The business wants an iPhone app and an Android app without funding two completely separate builds. React Native can reduce duplicated product work, but it does not remove either platform from the release plan.
A shared TypeScript and React layer can carry screens, state, API access and validation across both apps. Each app still runs against a different operating system, store, device range and native dependency graph. Camera access, notifications, permissions, keyboards, background behaviour and payments are where the promise of one codebase meets two products.
Whether React Native can build this matters less than how much platform-specific work the product needs, whether its libraries are ready for the current architecture, and who will own native releases after launch.
One React Native codebase still ships two native applications
React Native renders through platform capabilities rather than placing a website inside an app shell. That gives a team access to native controls and APIs while keeping much of the application in React.
Shared code is an outcome to measure, not a quota. Forcing every screen through an identical implementation can make both platforms worse. Navigation conventions differ. Android’s back behaviour has no direct iOS twin. Text sizing, safe areas, permission prompts and accessibility services need device-specific attention.
We plan one product backlog with explicit iOS and Android acceptance. Shared business rules and API contracts are valuable; platform branches are acceptable when they produce the expected experience. The maintenance problem is unmanaged divergence; an .ios or .android file on its own is fine.
This also changes estimating. A feature is not complete because it works in one simulator. It needs representative phones, supported operating-system versions, interrupted network conditions and a store-ready production build.
React Native’s New Architecture makes dependency readiness a gate
React Native 0.82 was the first release to run entirely on the New Architecture. The official 0.82 release note explains that the former architecture flags are ignored and support for the legacy architecture is frozen in the 0.81 line.
That is relevant to any inherited app and any proposal copied from an older tutorial. Fabric, TurboModules, the JavaScript interface and concurrent React behaviour change the integration surface. React Native itself can be current while a critical analytics, payments or hardware package is not.
Before approving an upgrade, we inventory native modules, their maintainers, supported React Native versions and any local patches. A replacement package needs a small production-style test, because download count proves little. If the product depends on an abandoned native bridge, that dependency is part of the commercial risk.
For a new app, the current architecture is the baseline. For an old one, upgrading can be a staged product project: remove obsolete libraries, update tests, build both platforms and check behaviour that crosses the native boundary.
Expo changes the native work; it does not make it disappear
Expo can supply builds, signing workflows, updates, development tooling and maintained native modules around React Native. For many business apps, that is a sensible way to reduce bespoke iOS and Android plumbing.
An Expo app still produces native applications, and development builds can include custom native code. The practical choice is how much of the native project lifecycle the team wants Expo’s tooling to manage.
We prefer the managed route when the required modules are supported and the release model fits. We move closer to direct native ownership when the product needs unusual SDK configuration, specialist hardware behaviour or platform code that the managed surface cannot carry cleanly.
Either way, somebody needs Apple and Google accounts, signing access, privacy declarations, store metadata and renewal procedures. A hosted build service reduces manual work, but accountability for the app stays with a named owner in the business.
Over-the-air updates have a native compatibility boundary
JavaScript and asset updates can reach customers without a full store release when the app uses a compatible update service. That is useful for small fixes and controlled rollouts, within limits on what can change remotely.
Expo’s update documentation separates update selection from the native runtime installed on the device. Code that expects a new native module must travel with a new app-store binary. Runtime versions prevent an incompatible update from being offered to an older build when they are configured correctly.
The product needs an update policy: which changes may ship over the air, how releases are phased, what telemetry signals a problem and how the team rolls back. Apple and Google rules also remain part of the decision, and store compliance and release review apply whatever the update service can technically send.
Mobile integrations decide how much code can be shared
A CRUD companion app backed by a stable API is a good cross-platform candidate. A product centred on Bluetooth, continuous background location, audio processing, widgets or a new platform API needs earlier native investigation.
That does not rule React Native out. It changes the team shape. A native module can expose Swift, Objective-C, Kotlin or Java capability to the shared layer, but somebody must write, test and upgrade it. The supposed saving disappears if the estimate assumes those skills will never be required.
Authentication and notifications deserve the same scrutiny. Secure storage, deep links, token refresh and push delivery interact with application lifecycle events that do not occur on the web. We prove those flows after termination, after an operating-system update and with expired credentials.
If mobile is only a convenient second screen for an existing React product, we still resist copying web components directly. Business types and API clients can often travel. Layout and interaction normally need mobile components designed for touch and accessibility.
React Native performance evidence belongs on customer devices
Performance debates about cross-platform frameworks become vague quickly. The useful evidence is a release build of the intended workflow on the lower end of the supported device range.
We measure startup, navigation, long-list behaviour, image loading, memory and the responsiveness of gestures that matter to the product. Development mode and blank demonstration apps make poor benchmarks.
Shopify’s five-year account of React Native is valuable because it describes a substantial production case, including strong results alongside upgrade work and native code where needed. It shows the approach can operate at scale, though another app will not inherit Shopify’s outcome automatically.
When a prototype misses its budget, profiling should locate the boundary at fault: JavaScript work, rendering, network payload, image handling or a native module. Rewriting the whole product is an expensive first diagnosis.
Questions to answer before approving React Native
- “Why does this need an installed app rather than a responsive web product?” Name the mobile capability.
- “Which flows must feel or behave differently on iOS and Android?” Budget them explicitly.
- “Which native modules are critical, and are they current?” Audit compatibility before committing.
- “Will Expo manage the project, builds and updates?” Record where direct native ownership begins.
- “Which changes may ship over the air?” Set runtime, rollout and rollback rules.
- “What devices and operating-system versions will we support?” Build the test set around customers.
- “Who controls store accounts, certificates and privacy submissions?” Keep access with the business.
When React Native is a credible shared mobile foundation
Choose React Native when iOS and Android share substantial workflow and the team already works confidently with React and TypeScript. It is well suited to account areas, operational tools, marketplaces and companion apps whose native integrations are understood.
The case is stronger when Expo supports the required modules and release model. The team can concentrate on product behaviour while using a maintained route through builds and updates.
Approval should still include a native dependency audit, a representative device prototype and ownership of both stores. Shared code is then a useful efficiency inside a complete mobile plan.
When the mobile requirement needs a different route
Start with a responsive website or progressive web app when installation, store distribution and native capabilities add little customer value. It is cheaper to support one web product than to maintain two app-store releases for presence alone.
Choose direct Swift and Kotlin work when the experience depends on platform-specific hardware, intensive graphics or immediate access to new operating-system APIs and the business can fund two native disciplines.
Pause when the argument is limited to developers already knowing React. Team familiarity matters, but product behaviour, dependency health and release ownership matter for longer.
Approve the mobile operating model, not a promised percentage of shared code.
I use React Native when the two apps share meaningful product behaviour and the native edges are known. I want the critical modules tested on current iOS and Android builds before the framework is committed. If nobody owns stores, signing, releases and platform-specific failures, the saving is being borrowed from later.
Alexander De Sousa · Founder, Digital Royalty · LinkedIn
What remains native when React Native shares the application layer
React Native can reduce duplicate product work across iOS and Android. Devices, native modules, store releases and platform acceptance still need separate proof.
The React Native commitment in six decisions
- Best fit
- Two-platform business apps with shared workflows, a React-capable team and a manageable set of maintained native integrations.
- Customer effect
- An installed platform-aware experience with shared product behaviour, provided each operating system receives its own accessibility and interaction testing.
- Adoption cost
- Moderate when Expo and supported modules cover the product; higher when custom native code, older dependencies or a legacy architecture need work.
- Ongoing owner
- A mobile team that owns JavaScript and native dependencies, device testing, signing, store submissions, updates, crash diagnosis and OS changes.
- Exit cost
- High for screens and integrations. API contracts, domain types and some business logic may travel to another client implementation.
- Proof required
- A production build of the hardest workflow on representative iOS and Android devices, including its critical native module and release route.
Mobile delivery routes worth comparing first
-
Responsive web application or PWA
Right when: Customers need a mobile-friendly workflow but store presence, deep native APIs and platform-specific interaction add little value.
Watch for: Confirm browser support for required notifications, background work and device capabilities, especially on iOS.
-
React Native managed with Expo
Right when: Expo supports the required modules and the team wants a maintained build, signing and update workflow around a shared application.
Watch for: Understand runtime versions, service limits and the point where custom native configuration enters the project.
-
React Native with direct native ownership
Right when: The shared React layer remains valuable but the product needs custom modules or must integrate with substantial existing iOS and Android applications.
Watch for: Budget Swift, Objective-C, Kotlin or Java capability and test the native bridge as part of every relevant upgrade.
-
Separate native applications
Right when: Platform-specific experience, specialist hardware work or early OS capability matters more than sharing implementation.
Watch for: Two teams can drift in product behaviour and release timing unless the business owns a shared specification and API contract.
Research behind this React Native position
-
Official release
React Native 0.82 and the New Architecture
Confirms that 0.82 runs only on the New Architecture and that legacy architecture support remains on the 0.81 line, making dependency readiness a release gate.
-
Official architecture
React Native architecture overview
Explains the modern renderer, native module system and JavaScript interface that sit beneath the promise of shared React product code.
-
Official migration
The New Architecture is here
Describes production readiness and migration compatibility, giving inherited apps a starting point for assessing old libraries and behaviour.
-
Official update model
Expo EAS Update download behaviour
Shows how an app selects and loads an update. Native runtime compatibility and rollout policy remain application responsibilities.
-
Production case study
Shopify's five years of React Native
Reports substantial production adoption and performance results alongside upgrade effort and continued native work. It is one organisation's evidence.
-
Practitioner question
Stack Overflow: New Architecture library compatibility
Illustrates the recurring uncertainty around third-party module compatibility; current maintainer statements and a build test should decide each dependency.
-
Community experience
Reddit: current New Architecture experiences
Developers report mixed outcomes shaped by their dependency sets. The discussion is anecdotal but reinforces testing the actual app rather than the label.
-
Community migration
Reddit: reports from migrating two React Native apps
A practitioner describes module and build work across two migrations. It helps identify trial areas but does not establish a general upgrade estimate.
Tell us what you need
A few quick questions, then a straight answer from a real person — usually within a few hours.
What happens next
- 1 We reply A real person reads your answers and gets back to you, usually within a few hours.
- 2 Questions or a short call If anything isn't clear, we ask by email or book a short call. Before any call we audit your website and make the quick fixes it finds, free.
- 3 Your fixed quote A clear, fixed price in writing, within 48 hours of any call. There is no obligation to go ahead.
Tell us what you're working on
Whether it's a new site, a platform, or a process that shouldn't be manual any more — we'll tell you honestly if we can help.