Decision in brief
Choose React Native when iOS and Android need substantially the same product flow, your team can own its native dependencies, and release builds meet your slowest supported device targets. Choose Swift and Kotlin when the product regularly depends on platform-specific behavior or a measured performance limit survives a focused optimization pass. For a working app, trial one screen or flow before funding a rewrite.

Choose around the part of the app you will maintain
React Native can share feature code across platforms. App signing, platform SDK changes, store releases, accessibility checks, and integrations still need iOS and Android ownership. Separate genuinely shared logic from platform adapters and dependencies in the estimate. A move to Swift and Kotlin may simplify one integration while increasing the number of places where a feature or bug fix needs review.
An incremental approach can help if most of the current app meets its targets. React Native documents embedding a view or a user flow in an existing native app. When using a mixed stack, budget both build systems and exercise navigation, state handoff, accessibility focus, and rollback at the boundary.
| Situation | Start with | What would change the decision |
|---|---|---|
| Small team, shared product flow | React Native release prototype | A required SDK needs ongoing native work that the proposed team cannot own. |
| Hardware, heavy animation, or platform-specific interaction | Native prototype of the hardest journey | React Native meets the same device targets after a bounded profiling pass and has a clear maintenance owner. |
| One costly screen in an otherwise stable app | Keep the app and test a narrow replacement | The boundary adds more setup, state bugs, or regression work than it removes. |
| Existing app rewrite | Price migration and future changes together | Both targets pass feature parity and recovery checks, and operating gains cover migration effort. |
Measure React Native vs native performance on the same flow
Test signed release or equivalent production builds on the same devices, OS releases, display settings, network conditions, and seeded data. Compare time to the first usable screen separately from the first frame. Record slow frames and tap or scroll latency during the same list, navigation, and animation journeys. React Native exposes separate JavaScript and UI frame rates, so a slow interaction needs a trace before assigning the cause.
Run a small change through both architectures after the baseline. Record clean CI and local incremental build times, minutes to diagnose a seeded bug, platform differences, dependency upgrade work, and reviewer time. Compare those recurring costs alongside the runtime results.
What teams on Hacker News ran into
In the Shopify thread, fnthawar2 attributed the decision to revisit mobile architecture partly to changed assumptions about the cost of implementing native code. Shopify's engineering write-up also describes the work it had been doing to optimize performance and maintain dependencies. Treat that as a case about one team's economics. Its staffing, release tooling, and existing product do not set a baseline for yours.
On a separate project, justAnotherHero described trouble integrating Rive animations into a React Native app with a small team. In another thread, sync reported having no particular performance issues to flag with Expo UI in a comparable TypeScript stack. These are self-reports with different workloads. Test the animation and integration your app actually uses before extrapolating.
Run a four-step pilot before committing
- Select one common journey and one costly edge case, such as loading and scrolling a list with offline data or an interaction that needs a device SDK. Set the release budget, device list, accessibility checks, and minimum acceptable response times before implementation.
- Implement the same journeys in each stack, with the same backend fixture and behavior. Use release builds. Repeat cold and warm startup and the critical interaction on matching low and midrange devices, recording medians and slow-tail timings separately.
- Deliver the same small feature change and exercise one dependency or SDK update in both. Log build, debugging, remediation, and review time for each platform. For a rewrite, verify account continuity, local data, and the staged release rollback plan.
- Accept the candidate only if every critical journey meets the device and accessibility limits and its estimated support cost is within budget. Pause a rewrite if parity, migration rollback, or platform ownership is missing. Retest a targeted fix against the same baseline before selecting a whole-app replacement.
Native development includes multiple platforms and frameworks. The decision table compares implementations of the same mobile task.