← All postsBlog

Native, Flutter or React Native? Choosing a stack based on the application

AppDelegate engineers talking around the office kitchen table

Choosing a mobile tech stack is rarely a theoretical argument about developer preference – it is an architectural decision dictated by hardware limits, third-party ecosystem dependencies, and time-to-market constraints. When a client approaches us, the core question is almost never "Which framework is universally superior?" but rather "Which set of engineering trade-offs can this product live with?"

Recently, our team tackled three drastically different engineering problems that highlighted this exact tension:

  • an on-device computer vision platform that needed to process live video frames without triggering thermal throttling,
  • a multi-chain crypto wallet dependent on dozens of third-party payment and blockchain SDKs,
  • and a multi-purpose booking platform for both business users and customers.

Selecting the wrong framework for any of these apps would have introduced systemic bottlenecks that no amount of late-stage refactoring could fix.

Native technologies (Kotlin/Swift)

This is the best option for apps that need every tool of the device’s operating system at their disposal. Native Swift and Kotlin remain our non-negotiable choice whenever an application requires fine-grained control over thread allocation, raw memory management, or direct hardware pipelines like Metal, Core ML, and CameraX. On our computer vision project, native development was the only viable path: bypassing bridge overhead allowed us to maintain a continuous 60 FPS inference loop while keeping device thermals well below OS throttling limits over sustained 20-minute sessions.

Native development offers all the functionality of the device’s operating system straight away without the need for custom API wrappers. When Apple or Google introduce new platform-level UI APIs or system capabilities during major OS releases, they are immediately available for your app without waiting for cross-platform maintainers to support them.

Beyond raw hardware performance, native development gives engineers unmediated access to platform-specific profiling and debugging tools – like Xcode Instruments and Android Studio Profiler – that cross-platform abstractions inevitably obscure. When managing complex background execution routines, secure keychain access, or local database migrations, native code allows you to track memory leaks, allocation spikes, and thread contention down to the OS kernel level. This level of granular visibility is indispensable when operating under strict system background execution limits, where a single unhandled allocation spike will lead to silent process termination by the OS.

When performance and hardware access are critical and budget allows, native development is the most reliable way to build mobile applications.

Cross-platform technologies (Flutter/React Native)

If native technologies are so performant, what makes cross-platform frameworks like Flutter and React Native compelling?

The strength of cross-platform frameworks lies in engineering efficiency. Instead of maintaining two separate codebases and distinct platform teams, you work with a unified codebase. This significantly reduces long-term maintenance overhead, accelerates feature shipping across platforms, and lowers initial development timelines by up to 40%. It is an ideal fit for products requiring rapid MVP delivery that do not depend on deep, low-level OS threading.

However, adopting a unified cross-platform stack introduces its own operational tax that engineering teams must budget for. Running a cross-platform app requires bundling a framework engine or JavaScript runtime, which inherently inflates the base binary size and introduces slight cold-boot startup overhead compared to slim native binaries. Long-term maintenance also demands active dependency management across two layers: the core cross-platform package ecosystem and its underlying native bindings. When major OS updates enforce new target SDK requirements, projects can hit dependency deadlocks if third-party plugin maintainers lag behind, turning what should be a routine build update into a complex refactoring sprint.

Both Flutter and React Native are backed by major engineering organizations (Google and Meta, respectively), maintain massive open-source communities, and can rival native UI performance in standard day-to-day use cases. However, their underlying architectures differ significantly.

Flutter vs React Native

Flutter is written in Dart, an object-oriented language that aligns closely with clean architecture and domain-driven design principles familiar to Kotlin and Swift developers. React Native is built around JavaScript and TypeScript, making mobile development feel natural to web engineering teams.

This architectural difference heavily impacts third-party integration. Because JavaScript is the most widely used language in web development, specialized SDKs often support React Native long before Flutter or even native platforms. On our crypto wallet project, we deliberately chose React Native despite Flutter’s smoother rendering performance. The crypto ecosystem heavily prioritizes JS/TS SDKs; opting for Flutter would have forced our team to manually build and maintain custom platform channels for most of our payment and key-management libraries.

UI rendering is another fundamental divergence. Flutter uses its own rendering engine to draw every pixel on an isolated canvas, guaranteeing identical layout behavior and achieving shared code parity across Android and iOS. This made Flutter the clear winner for our multi-purpose booking platform. Because the app needed to support two entirely separate user personas – a dense administrative dashboard for business owners and a streamlined UI for end customers – Flutter allowed us to build a custom, pixel-perfect design system once and achieve over 95% shared code parity across iOS and Android without dealing with platform-specific layout glitches. React Native, by contrast, bridges directly to native OS widgets. While React Native apps automatically inherit new native system UI paradigms, Flutter apps must wait for engine updates or custom implementations. On the execution side, Dart compiles ahead-of-time (AOT) to native ARM code for smooth, predictable UI rendering. React Native runs JavaScript via Hermes – and while the New Architecture drastically improves bridge performance, high-frequency main-thread computations can still create bottlenecks under heavy processing loads.

Stack & takeaways

Stack: Kotlin, Swift, Flutter, Dart, React Native, TypeScript, JavaScript.

The ultimate rule of mobile stack selection is to identify your app’s primary constraint before writing a single line of code.

  • Choose native development when your core features demand low-level hardware acceleration or strict thermal and memory bounds.
  • Choose React Native when your feature set relies on an ecosystem dominated by web-first or JavaScript SDKs.
  • Choose Flutter when rapid time-to-market and flawless, identical UI execution across platforms outweigh the need for immediate native system UI adoption.

Related: Showing real card data in a mobile wallet — without ever holding it