← Back to Blog

Why use React Native for your next app?

Alfonso Cartes Alfonso Cartes
Why use React Native for your next app?

5 REASONS TO PICK REACT NATIVE FOR YOUR BUSINESS

In a previous post, I wrote about why we should use Flutter for my next project. In this post, I will be switching to React Native with Expo for the same reasons plus one important one.

After working with both native and cross-platform mobile development over the years, I have landed firmly on React Native as my go-to choice for building mobile applications. This is not a theoretical recommendation. I have shipped production apps with React Native, and I have seen first-hand how it changes the economics and velocity of mobile development.

1. DEVELOPMENT COST USING REACT NATIVE

ONE CODEBASE — ONE DEVELOPMENT TEAM

“single codebase” is essential. With one codebase, one development team, and one design team, you can get a native app that works on iOS, Android, Desktop, and the Web.

Usually, when a company wants to develop a mobile application, they have to hire a team of developers and designers for iOS that will design and code the app specifically to run on iOS devices. After the iOS development is done, another team with experience in Android design and development has to do the same thing.

You might have to double the cost and deal with two different teams of people. Shortly, that team can also develop the app for the web and desktop.

To put this in concrete terms, consider a moderately complex application with authentication, a data-driven home screen, a profile section, push notifications, and in-app purchases. Building this natively for iOS in Swift and for Android in Kotlin would require two specialised developers (or teams), two sets of tooling, two CI/CD pipelines, and two codebases to maintain. With React Native, a single team writes one codebase, and the platform-specific differences are handled by the framework and a thin layer of conditional logic where necessary:

import { Platform, StyleSheet } from "react-native";

const styles = StyleSheet.create({
  container: {
    paddingTop: Platform.OS === "ios" ? 44 : 0,
    // Platform-specific adjustments when needed,
    // but the vast majority of the code is shared
  },
  header: {
    fontFamily: Platform.select({
      ios: "San Francisco",
      android: "Roboto",
      default: "System",
    }),
    fontSize: 24,
    fontWeight: "bold",
  },
});

In my experience, over 90% of the code is shared across platforms. The remaining 10% is usually platform-specific UI adjustments or native module integrations, which React Native handles gracefully.

There are other ways of making multi-platform apps, but they use web layers like PhoneGap or Ionic that significantly impact speed, battery, and UI/UX. With React Native, we use Native platform modules.

There are also other popular cross-platform development SDKs like Flutter and Xamarin. They also do not rely on a web browser to display UI.

React Native vs. Native Development

The question I get asked most often is: “Why not just build native?” It is a fair question, and the answer depends on context.

Native development with Swift/SwiftUI for iOS and Kotlin/Jetpack Compose for Android gives you the best possible performance and the deepest access to platform APIs. If you are building a graphics-intensive game, a complex camera application, or something that pushes the hardware to its limits, native is the right choice.

But for the vast majority of business applications, social apps, e-commerce platforms, content apps, and productivity tools, the difference in performance between React Native and native is negligible. What is not negligible is the difference in development time and cost. Building and maintaining two separate native apps with feature parity is roughly twice the work, and in practice it is often more than twice because of the coordination overhead.

React Native vs. Flutter

Flutter is a strong competitor and I respect what Google has built with it. Flutter’s rendering engine, Skia, gives it pixel-perfect control over every frame, which makes it excellent for custom UI work. However, there are a few reasons I prefer React Native:

JavaScript and React ecosystem. If your team already knows React (and there is a good chance they do, given React’s dominance in web development), the transition to React Native is smooth. The mental model of components, props, state, and hooks transfers directly. With Flutter, you need to learn Dart, a language with a much smaller ecosystem and job market.

Web compatibility. React Native for Web allows you to share significant amounts of code between your mobile and web applications. Libraries like Solito bridge the gap between React Native navigation and Next.js routing. This is harder to achieve with Flutter’s web support, which, while improving, is still less mature than React Native for Web.

Third-party library ecosystem. The npm ecosystem is enormous. While not every npm package works with React Native, the overlap is significant, especially for business logic, data fetching, and state management.

2. SOFTWARE QUALITY USING REACT NATIVE

Having one team, one codebase, and one design paradigm that gets adapted to different platforms drastically decreases the chance of crashes and bugs. This provides a significant increase in the quality and stability of the final product.

Because of the vast popularity of React.js, it is very easy to find developers that are familiar with React.js and can easily adapt to React Native.

By having fewer lines of code to maintain, the app can iterate not only faster but better. The chance of something breaking is smaller. The team can focus on details to make the apps better instead of worrying about compatibility problems for each platform.

Your business gets access to a bigger user base in all parts of the world, especially to those users that do not have the latest and greatest devices.

The React Native Ecosystem for Quality

The ecosystem around React Native has matured significantly, and the tools available for building high-quality apps are excellent:

Navigation. React Navigation is the de facto standard, and it provides native-feeling navigation transitions out of the box. Stack navigators, tab navigators, drawer navigators, and deep linking all work reliably. Expo Router has taken this a step further by bringing file-based routing to React Native, similar to what Next.js does for the web.

State management. You have the full spectrum of React state management at your disposal: React Context for simple cases, Zustand for lightweight global state, TanStack Query (React Query) for server state, and Redux Toolkit when you need a more structured approach. This is the same set of tools you would use in a React web project, which means skills and patterns transfer directly.

Styling. Beyond the built-in StyleSheet API, libraries like NativeWind bring TailwindCSS utility classes to React Native. This has been a game-changer for my workflow. Being able to use the same styling conventions across web and mobile reduces context-switching and speeds up development:

import { View, Text } from "react-native";

function WelcomeCard({ name }) {
  return (
    <View className="mx-4 rounded-2xl bg-gray-900 p-6 shadow-lg">
      <Text className="text-xl font-bold text-amber-400">
        Welcome, {name}
      </Text>
      <Text className="mt-2 text-base text-gray-300">
        Your dashboard is ready.
      </Text>
    </View>
  );
}

Testing. React Native Testing Library provides a user-centric approach to testing that mirrors React Testing Library for the web. Combined with Jest, you can write comprehensive unit and integration tests that give you confidence in your app’s behaviour.

3. UPDATES AND SPEED OF DEVELOPMENT

React Native lets you add new features for your users fast. Instead of getting one team to implement a new feature in the iOS app and the other team for Android and waiting for feature parity before launching the new feature, React Native lets you do all of this at once, with one team and one codebase.

Bug fixes and UI/UX fixes can be done only once for all platforms. This is huge and makes the long term cost of the app much smaller and the launching of updates much quicker.

React Native lets you develop better apps faster. With features like Hot Reload, the speed of development is a lot faster. This is an essential feature in a world where users expect new features all the time, and you need to distance yourself from your competitors by getting to your users faster.

The development experience with React Native and Expo has improved dramatically over the years. Fast Refresh (the evolution of Hot Reload) is almost instantaneous. You change a component, and you see the result on your device or simulator within a second. Compare this to native development where a full rebuild can take 30 seconds to several minutes depending on the project size.

Over-the-air updates are another significant advantage. With EAS Update, you can push JavaScript bundle updates directly to your users’ devices without going through the App Store or Google Play review process. This means critical bug fixes can reach your users in minutes rather than days. This is not a replacement for proper app store releases, but for small fixes and content updates, it is invaluable.

4. FUTURE OF REACT NATIVE

Because of the popularity of React.js, it will likely be used in the future.

React.js and React Native are on a trend to become more aligned. This means that React Native will benefit from the huge popularity of React.js in the future.

With new platforms supported like macOS, Windows and AR/VR devices, React Native will be a much more popular choice for the future.

The New Architecture: Fabric and TurboModules

The React Native team at Meta has been working on a complete re-architecture of the framework, and it represents the most significant technical improvement since React Native’s inception.

Fabric is the new rendering system. It replaces the old asynchronous bridge with a synchronous, direct communication layer between JavaScript and native code. This means smoother animations, faster layout calculations, and better support for concurrent features from React 18 and beyond. Fabric enables features like Suspense and concurrent rendering in React Native, bringing the mobile framework closer to parity with React on the web.

TurboModules replace the old Native Modules system. They are lazily loaded, meaning the app only initialises the native modules it actually uses, reducing startup time. They also enable synchronous access to native functions when needed, which was impossible with the old bridge architecture.

JSI (JavaScript Interface) is the foundation that makes both Fabric and TurboModules possible. It allows JavaScript to hold references to C++ host objects and call methods on them directly, eliminating the serialisation overhead of the old bridge. This is a fundamental performance improvement that benefits every part of the framework.

These are not incremental improvements. They represent a ground-up rethinking of how React Native communicates between JavaScript and native code, and the performance gains are substantial. Apps built on the new architecture feel noticeably more responsive, especially during complex animations and transitions.

When React Native is NOT the Right Choice

I believe in being honest about limitations, and React Native is not the right tool for every project.

Performance-critical applications. If you are building a 3D game, a real-time video editor, or an augmented reality experience that pushes the GPU to its limits, native development will give you better results. React Native performs well for the vast majority of use cases, but it does add a layer of abstraction that matters at the extreme end.

Deep platform integration. If your app relies heavily on platform-specific features like advanced HealthKit integrations on iOS or custom Android widgets, you will find yourself writing significant amounts of native code alongside your React Native code. At some point, the balance tips and going fully native might be simpler.

Tiny, single-platform apps. If you only need an iOS app and never plan to support Android, there is less reason to use a cross-platform framework. The cross-platform benefit is React Native’s strongest selling point, and it matters less when you only target one platform.

Apps with complex custom native UI. If every screen in your app requires deeply customised native components, the abstraction layer of React Native becomes more of a hindrance than a help.

For everything else, which is the majority of applications businesses need to build, React Native is an excellent choice.

5. EXPO

Expo brings simplicity to mobile development and it’s a great way to get your app to the top of the app store.

I’ve been using Expo for years and it has been a great experience. Deployment to app stores is very easy and will be even better and easier with Expo Application Services (EAS).

Expo has transformed from a limited wrapper around React Native into a comprehensive development platform. In the early days, the “managed workflow” was restrictive, you could not use custom native modules, and ejecting from Expo was a one-way door. Today, Expo’s development builds and config plugins system means you can use any native module while still benefiting from Expo’s tooling and services.

The expo-dev-client package creates a custom development build of your app that includes all your native dependencies. This replaces the old Expo Go app for development and removes the biggest historical limitation of the Expo ecosystem. You get the best of both worlds: Expo’s developer experience with full access to native code.

I’m seeing a trend from Expo where they want to make cross-platform mobile development as easy as web development, specifically with features such as:

  • EAS Build: Compile and sign Android/iOS apps with custom native code in the cloud.
  • EAS Submit: Upload your app to the Apple App Store or Google Play Store from the cloud with one CLI command.
  • EAS Update: Address small bugs and push quick fixes directly to end-users.

Expo Router deserves special mention. It brings file-based routing to React Native, which is something I have wanted for years. Define your screens as files in an app/ directory, and the router handles navigation, deep linking, and URL support automatically:

app/
  _layout.tsx        → Root layout
  index.tsx          → Home screen
  profile.tsx        → Profile screen
  settings/
    _layout.tsx      → Settings stack layout
    index.tsx        → Settings main screen
    notifications.tsx → Notification settings

This is remarkably similar to how Next.js and Astro handle routing, and it makes the project structure immediately understandable to any web developer. Combined with universal links and deep linking support built in, Expo Router is a significant step towards making mobile development feel as natural as web development.

Success Stories

The companies using React Native in production speak to its viability: Meta (Facebook, Instagram, and Messenger all use React Native for significant portions of their apps), Microsoft (Office, Teams, Xbox), Shopify (Shop app), Discord, Coinbase, and Bloomberg. These are not small experiments. These are production applications serving hundreds of millions of users.

What these companies share is the need to move fast across multiple platforms while maintaining quality. React Native lets them do exactly that.

Final Thoughts

React Native with Expo has reached a level of maturity where the question is no longer “can it handle my use case?” but rather “is there a specific reason it cannot?” For the vast majority of mobile applications, the answer is that React Native will serve you well while saving significant development time and cost.

The combination of a familiar React programming model, a massive ecosystem of libraries and tools, Expo’s streamlined development experience, and the ongoing architectural improvements from the React Native team makes it the strongest cross-platform choice available today.

See my KUKD React Native project for a real-world example.

Interested in working together?

Let's discuss your project and bring it to life.

Get in Touch