What is React Native?

React Native is Meta's open-source framework for building native iOS and Android mobile applications using JavaScript or TypeScript. Unlike web-based hybrid frameworks that render HTML in a WebView, React Native renders genuine native UI components — a React Native button is a UIButton on iOS and an Android Button on Android, not an approximation. React Native uses a JavaScript runtime to handle application logic, which communicates with the native platform to drive the real native UI. The framework was introduced by Meta in 2015 and has been used in production by Facebook, Shopify, Microsoft, and thousands of other companies. In 2026, React Native benefits from the new architecture (Fabric and TurboModules) which significantly improved performance by replacing the old asynchronous JavaScript bridge with a synchronous C++ interface.

Should I choose React Native or Flutter for my app?

Choose React Native if your development team already works in JavaScript or TypeScript, if you have an existing React web application and want to share business logic with a mobile app, or if your team's JavaScript depth makes learning Dart (Flutter's language) a real productivity cost. Choose Flutter if you are starting fresh with no existing JS/React commitment, if your app requires highly consistent visual rendering across iOS and Android, or if animation-heavy UI is central to the product. CV Infotech builds both frameworks and recommends Flutter as the default for new cross-platform projects — React Native is the right choice when the team's existing JavaScript expertise is the deciding factor. Neither is universally superior; the decision is a product of your team's skills and your project's requirements.

What is the React Native new architecture?

The React Native new architecture refers to two primary changes introduced from React Native 0.68 and stabilised in 0.71 and later. The first change is the replacement of the old asynchronous JavaScript bridge — which caused performance bottlenecks by serialising messages between JS and native — with the JSI (JavaScript Interface), a synchronous C++ layer that allows direct communication between JavaScript and native code. The second change is Fabric, the new rendering system, which replaces UIManager and provides a more consistent rendering model across platforms. Together, these changes significantly reduce the latency for UI updates, improve animation performance, and make React Native apps perform closer to native on both Android and iOS. In 2026, the new architecture is the default for new React Native projects.

What is Expo and should I use it?

Expo is a framework built on top of React Native that provides a set of pre-built native modules, a simplified development toolchain, and cloud services for building and distributing React Native apps. The Expo managed workflow lets you build a React Native app without ever writing native iOS or Android code — the Expo SDK provides modules for camera, location, push notifications, biometric authentication, and many other native capabilities. The Expo bare workflow gives you Expo's tooling and module ecosystem while allowing you to add custom native code when the managed workflow's pre-built modules are insufficient. In 2026, Expo is the recommended starting point for most React Native projects because of the significant time it saves on environment setup, native build configuration, and over-the-air update distribution via Expo Updates.

How do I navigate between screens in React Native?

React Navigation is the standard navigation library for React Native and Expo projects. It provides stack navigation (a stack of screens where you push and pop pages), tab navigation (bottom tabs or top tabs for switching between sections of the app), and drawer navigation (a slide-in side menu). React Navigation v7 (the current version in 2026) uses a file-based routing approach inspired by Next.js, which simplifies navigation setup significantly compared to earlier versions. Expo Router, which is built on React Navigation, extends this with file-system-based routing that automatically creates routes from your file structure. For most new React Native projects, Expo Router is the recommended navigation solution because of its cleaner developer experience and tight integration with Expo's build tooling.

What state management should I use in React Native?

The state management recommendations for React Native mirror those for React web applications. For server state (data fetched from an API), React Query (TanStack Query) is the standard recommendation — it handles caching, background synchronisation, loading and error states, and pagination in a way that eliminates most manual useEffect data-fetching patterns. For local client state that is shared across multiple components, Zustand is the recommended solution for most projects — it is lightweight, has minimal boilerplate, and is straightforward to test. Context API with useReducer is appropriate for simple apps where the state complexity does not warrant an external library. Redux Toolkit remains appropriate for large codebases with complex state logic and large teams that benefit from its strict architectural conventions.

How does React Native handle native device features?

React Native accesses native device features (camera, GPS, Bluetooth, push notifications, biometric authentication) through native modules — JavaScript interfaces that wrap native iOS (Swift/Objective-C) and Android (Kotlin/Java) code. The Expo SDK provides pre-built native modules for the most common device features, which eliminates the need to write any native code for standard use cases. For device capabilities not covered by Expo's module library, the React Native community has published hundreds of open-source native modules on npm. When no existing module covers a specific requirement, a custom native module can be written in Swift or Kotlin and bridged to JavaScript using React Native's native module API or the newer native module spec (TurboModules).

How do I test a React Native application?

React Native testing uses the same tooling as React web: Jest as the test runner, React Native Testing Library for component tests, and Detox or Maestro for end-to-end tests. Unit tests test individual JavaScript functions and business logic in isolation. Component tests render React Native components in a simulated environment and verify their behaviour — button presses, navigation actions, data display. End-to-end tests run the full application on a real device or simulator and automate user flows from login through core tasks. Coverage targets: 70%+ on business logic and critical user flows. End-to-end tests are slower and more brittle than unit and component tests, so a pragmatic test suite favours unit and component tests for breadth and reserves end-to-end tests for the most critical user journeys.

How do I submit a React Native app to the App Store and Google Play?

App Store (iOS): Expo EAS Build generates the iOS .ipa binary in the cloud without requiring a local Mac. You need an Apple Developer account ($99/year) and certificates configured in EAS. App Store Connect is used to create the app listing, upload screenshots, and submit the build for review. Apple's review process typically takes 24 to 48 hours for new submissions. Google Play: EAS Build generates the Android .aab for Play Store submission. A Google Play Developer account costs $25 one-time. The Play Console handles the listing, content rating, and phased rollout. Over-the-air updates via Expo Updates allow you to push JavaScript changes to users without a new App Store submission, though changes to native code still require a full build and submission.

How long does React Native development take?

A simple React Native app with 5-8 screens, a REST API integration, and standard navigation takes 8 to 14 weeks. A mid-complexity app with 15-25 screens, authentication, push notifications, and backend integration takes 14 to 24 weeks. A complex app with custom native modules, real-time features, offline support, and complex animations takes 24 to 40 weeks. These timelines assume a complete brief at project start, an approved design before development begins, and client feedback within 48 hours at each sprint review. Adding Expo to the stack can reduce setup and native configuration time by 1-3 weeks on most projects.

How much does React Native development cost?

React Native app development at CV Infotech costs $30 per hour. A simple app costs $8,000 to $18,000. A mid-complexity app costs $18,000 to $40,000. A complex app with custom native modules and advanced features costs $40,000 to $90,000. These costs cover the React Native mobile app — backend development (API, database) is scoped separately. US-based React Native agencies charge $100 to $200 per hour for the same scope. The cost difference on a $25,000 project scope: $25,000 with CV Infotech versus $80,000 to $165,000 with a US agency.

Can CV Infotech build my React Native app?

Yes. CV Infotech builds React Native apps for clients in the USA, UK, Australia, and Canada. We recommend Flutter for most new cross-platform projects, and React Native when the team's JavaScript expertise makes it the practical choice — this position is stated consistently across our mobile service pages. Our rate is $30 per hour with a 100% in-house team and 512 verified 5.0 reviews on Freelancer.com. The discovery call is 30 minutes and free. We assess the right framework for your project before any scoping.

Mobile App Development

React Native App Development Guide 2026: Build, Test, and Ship

CV Infotech builds apps in both React Native and Flutter. Our recommendation — Flutter for most new cross-platform projects, React Native when the team already knows JavaScript — is consistent across all our mobile pages. This guide reflects how we actually build React Native apps in 2026.

Akash Singh, CTO — CV InfotechPublished: July 202612 minute readCovers React Native 0.74, new architecture, Expo SDK 51

React Native remains one of the most widely used cross-platform mobile frameworks in 2026, with approximately 35% of cross-platform developers using it according to the Stack Overflow Developer Survey. Its primary advantage is straightforward: if your team already knows JavaScript and React, React Native's learning curve is dramatically lower than Flutter's Dart. You are using the same language, the same component model, and in many cases the same business logic you already have in your React web application.

The framework has changed significantly since its introduction in 2015. The new architecture — stable since React Native 0.71 — replaced the old asynchronous JavaScript bridge with a synchronous JSI layer, closing much of the performance gap that used to favour Flutter. Expo, which has evolved from a convenience layer into a comprehensive React Native framework, has eliminated most of the environment setup friction that made React Native projects frustrating to start. In 2026, getting a React Native app running with authentication, navigation, and a backend connection takes significantly less time than it did three years ago.

This guide covers the architecture decisions, framework choices, and implementation patterns that produce a maintainable, production-ready React Native app — not just a working prototype. We cover what to use for navigation, state management, and native modules, and we are honest about when React Native is the right choice and when Flutter might serve your project better.

TL;DR:

React Native: JavaScript/TypeScript. Native UI components. Meta-backed. 0.74+ has new architecture stable.
Use when: your team knows JS/React, you want to share code with a React web app.
Start with Expo: it eliminates most native configuration pain.
Stack: Navigation Expo Router (file-based). State Zustand + React Query. Testing Jest + RNTL + Detox.
Cost at $30/hr: Simple $8K-$18K. Mid $18K-$40K. Complex $40K-$90K.
Compared to Flutter: Flutter wins on visual consistency; React Native wins on JS-team productivity.

What React Native is New architecture Expo Navigation State Native modules Testing App Store Cost FAQ

React Native — What It Is and How It Differs from Other Frameworks

React Native is a JavaScript framework for building native mobile apps that is fundamentally different from hybrid frameworks like Ionic or Cordova. Hybrid frameworks run a web app inside a WebView — the user is technically using a browser embedded in a native shell. React Native does not do this. It uses a JavaScript runtime (Hermes, the optimised JS engine Meta created specifically for React Native) to run your application logic, and then communicates with the native platform to render actual native UI components — the same components that a Swift or Kotlin app would use. A React Native button is a UIButton on iOS. A React Native text input is an EditText on Android. Users interact with real native controls, which means the app behaves the way iOS and Android users expect.

The architecture that enables this communication changed significantly with the React Native new architecture. The old architecture used an asynchronous JavaScript bridge — messages between JS and native code were serialised to JSON, sent across the bridge, and deserialised on the other side. This worked, but the serialisation overhead and the asynchronous nature of the communication created performance bottlenecks, particularly for animations that needed to update the UI at 60 frames per second. The new architecture replaces this bridge with JSI — the JavaScript Interface — a synchronous C++ layer that allows JavaScript to hold a reference to a native object and call methods on it directly, without serialisation. This change is what enabled React Native's performance to approach Flutter's in benchmarks that previously showed a clear gap.

The component model in React Native is deliberately parallel to React for the web. If you know how to build a React component — JSX, props, state, hooks — you can build a React Native component. The main differences are in the primitives: instead of div and span, you use View and Text. Instead of an HTML input, you use TextInput. Instead of CSS (though Tailwind-style libraries like NativeWind bring familiar styling) you use StyleSheet.create with a React Native-specific subset of CSS properties. The business logic — API calls, data transformation, validation, state management — is identical to what you write in React for the web, which is the source of React Native's biggest productivity advantage for teams with existing JavaScript expertise.

Expo — Why Most React Native Projects Should Start Here

Expo is a framework and set of tools built on React Native that addresses one of React Native's historically frustrating aspects: the environment setup and native build configuration. Setting up a raw React Native project requires Xcode (Mac only for iOS), Android Studio, Java, CocoaPods, and a series of configuration steps that frequently break when dependencies update. Expo abstracts most of this away. You can create a new Expo project with a single command, run it on your phone immediately using Expo Go (no Xcode or Android Studio needed for development), and build production binaries using EAS Build — Expo's cloud build service — without a Mac.

Expo SDK 51 (the current major release in 2026) provides pre-built native modules for: camera, location, push notifications, biometric authentication (Face ID, fingerprint), file system access, calendar, contacts, audio, and many other device capabilities. These modules are maintained by the Expo team and are tested to work with every Expo SDK version. The alternative — managing native module dependencies yourself in a bare React Native project — frequently leads to version conflicts and build failures. Using Expo's managed module ecosystem eliminates this entire class of problem for most standard mobile app requirements.

The Expo bare workflow gives you the best of both worlds: Expo's SDK and tooling with the ability to add custom native code when required. If you start with the Expo managed workflow and later discover a native feature that Expo's SDK does not cover, you can eject to the bare workflow and add the custom native module. This progression — start managed, eject when necessary — is the practical approach for most production apps. Expo Router, the file-based navigation solution built on React Navigation, has become the default navigation approach for Expo projects and significantly simplifies the routing setup that used to require considerable manual configuration.

Navigation in React Native — Expo Router and React Navigation

Navigation is one of the first architectural decisions in any React Native project. The standard library is React Navigation, now in version 7, which has been the community standard for React Native routing since 2018. React Navigation provides stack navigation, tab navigation (bottom tabs, top tabs), and drawer navigation, composable into the navigation structure your app requires. It manages the navigation state, handles the native transition animations on each platform (iOS push/pop slide, Android swipe back gesture), and provides a hooks-based API for navigating programmatically and reading the current navigation state.

Expo Router, introduced in Expo SDK 48 and significantly matured by SDK 51, brings file-system-based routing to React Native — the same paradigm Next.js uses for web routing. Your app's screens are files in an app/ directory; the file path determines the route. A file at app/profile/settings.tsx creates the /profile/settings route automatically. Deep linking configuration, which traditionally required significant manual setup in React Navigation, is handled automatically by Expo Router. For new Expo projects in 2026, Expo Router is the recommended navigation approach — it reduces the routing configuration boilerplate considerably while remaining built on React Navigation under the hood.

The choice between Expo Router and bare React Navigation depends on whether you are using Expo. If you are on the Expo managed or bare workflow, Expo Router is the right choice. If you are using bare React Native without Expo, React Navigation v7 directly is the approach. In both cases, the core navigation primitives — Stack, Tabs, Drawer — are the same. What changes is how routes are declared and how deep linking is configured.

State Management in React Native — What to Use in 2026

The state management landscape for React Native in 2026 has converged significantly. The pattern that works best for most apps separates server state from client state. Server state — data fetched from an API — is handled by React Query (TanStack Query). Client state — UI state like modal open/closed, form values, and application settings — is handled by Zustand for anything shared across components, and useState for local component state. This separation is cleaner than putting everything in a global Redux store and manages the different concerns of caching, synchronisation, and UI state independently.

React Query dramatically reduces the code required to fetch, cache, and synchronise data from an API. Instead of writing useEffect to fetch on mount, loading and error state management, manual cache invalidation, and retry logic, you call useQuery with a query function and a key. React Query handles all the rest: caching the result for the key, refetching in the background when the component remounts, invalidating the cache when you mutate data, and retrying failed requests with exponential backoff. This removes a significant amount of imperative data-fetching code from React Native apps that would otherwise live in useEffect blocks.

What to avoid: GetX is a popular React Native and Flutter state management library that combines routing, dependency injection, and state management in one package. Its appeal is the speed of initial setup, but the combination of concerns creates testing difficulties and makes large codebases harder to reason about. For new projects, avoid GetX and prefer the separation of concerns that Zustand + React Query provides. Redux Toolkit remains appropriate for very large codebases with complex state requirements and large engineering teams that benefit from its strict conventions and Redux DevTools tooling.

Accessing Native Device Features

Native device features — camera, GPS, Bluetooth, push notifications, biometric authentication, Apple Pay and Google Pay — are accessed in React Native through native modules. A native module is a JavaScript interface that wraps native iOS (Swift or Objective-C) and Android (Kotlin or Java) code. For Expo projects, the Expo SDK provides pre-built native modules for the most commonly needed device features. expo-camera for camera access, expo-location for GPS, expo-notifications for push notifications, expo-local-authentication for biometric authentication, and react-native-purchases (RevenueCat) for in-app purchases.

The React Native community ecosystem on npm provides hundreds of additional native modules for device features not covered by the Expo SDK. When evaluating community modules, check: when was it last updated (maintenance status), does it support the new architecture (TurboModules or the legacy bridge), and does it have Expo config plugin support (required for Expo managed workflow). Modules that have not been updated since 2022 may not support the new architecture and can cause build issues.

When no existing native module covers a specific requirement, a custom native module can be written using React Native's native module spec (NativeModule) API. In the new architecture, custom modules use the TurboModule system which uses JSI for communication. Writing a custom native module requires Swift or Kotlin knowledge and access to Xcode and Android Studio. At CV Infotech, custom native module work adds $3,000 to $8,000 per module to the project cost depending on the complexity of the native API being wrapped.

Testing a React Native App

React Native testing uses the same tools as React web testing. Jest is the test runner. React Native Testing Library (RNTL) renders React Native components in a simulated environment and provides utilities for querying the rendered output and simulating user interactions. Detox or Maestro are used for end-to-end tests that run the full app on a real device or simulator. The testing pyramid applies: many unit tests, fewer component tests, even fewer end-to-end tests. Unit tests for business logic (data transformation, validation, API parsing) run in milliseconds and should cover the bulk of the critical logic. Component tests verify that UI components render correctly and respond to interactions. End-to-end tests validate the most critical user journeys.

React Native Testing Library encourages testing components as users experience them rather than testing implementation details. Queries like getByText, getByRole, and getByTestId find elements by visible attributes rather than internal component structure. This makes tests more resilient to refactoring — changing how a component is implemented should not break a test as long as the visible behaviour remains the same. Mock native modules using Jest's module mocking: jest.mock('@react-native-async-storage/async-storage') with the community-provided mock to prevent tests from failing on native code that cannot run in Node.js.

Maestro has become the preferred end-to-end testing framework for Expo and React Native projects because it is significantly easier to set up and maintain than Detox. Maestro uses a YAML-based test specification that reads like plain English: launch the app, tap 'Login', enter email, enter password, tap 'Sign In', assert the home screen is visible. Tests run on iOS simulators, Android emulators, and real devices. Maestro Cloud provides hosted test infrastructure for running end-to-end tests in CI/CD pipelines without maintaining your own device fleet.

Submitting a React Native App to the App Store and Google Play

Expo EAS Build generates the production binaries for both App Store and Google Play in the cloud, without requiring a local Mac for iOS builds. EAS Build manages code signing certificates, provisioning profiles, and Keystore files automatically. You configure your app identifier, bundle ID, and signing credentials once via eas.json, and subsequent builds are triggered with a single command: eas build --platform all. Build times are typically 15 to 30 minutes for iOS and 10 to 20 minutes for Android using EAS Build's infrastructure.

App Store submission requires an Apple Developer account ($99/year) and compliance with Apple's App Store Review Guidelines. For eCommerce apps, you cannot use custom payment processors for digital goods without going through Apple's in-app purchase system (which takes a 30% commission). Physical goods (clothing, food, physical products) can use Stripe or other payment processors directly. React Native apps must include a privacy manifest for apps using certain APIs that access device signals (from iOS 17 onwards). Expo handles this automatically for Expo SDK modules. Review time: 24 to 48 hours for new app submissions, typically faster for updates.

Over-the-air (OTA) updates via Expo Updates allow you to push JavaScript changes to production users without a new App Store submission. When you push an OTA update, the app downloads the new JavaScript bundle in the background and applies it on the next launch. This is useful for fixing bugs and making UI changes quickly. OTA updates cannot change native code — any change that requires a new native module, updated native dependency, or change to the iOS or Android configuration still requires a full EAS Build and App Store submission. OTA updates are available on Expo's free plan with limited monthly active users and more generous limits on paid plans.

React Native Development Cost in 2026

App Type	CV Infotech $30/hr	US Agency $150/hr	Timeline
Simple (5-8 screens, REST API)	$8K-$18K	$40K-$90K	8-14 weeks
Mid-complexity (15-25 screens, auth, push notifications)	$18K-$40K	$90K-$200K	14-24 weeks
Complex (50+ screens, custom native modules, offline)	$40K-$90K	$200K-$450K	24-40 weeks

Custom native modules add $3,000 to $8,000 each — they require Swift and Kotlin code.
Offline support with sync adds $5,000 to $15,000 depending on conflict resolution complexity.
Third-party integrations (Stripe, Braintree, social login) add $1,500 to $4,000 each.
Complex animations add $3,000 to $10,000 depending on the number and complexity of animated sequences.

See our app development cost guide for a full breakdown and our Flutter vs React Native comparison for the cost implications of the framework choice. Our React Native development service covers how we scope and deliver React Native projects from discovery to App Store.

React Native App Development — Frequently Asked Questions

Build Your React Native App With the Team That Also Knows Flutter

Discovery call is free. We recommend the right framework for your project — not the one we happen to specialise in. $30/hour. 512 verified reviews.

See React Native Service