A React Native developer who understands the JavaScript-to-native execution model — how JavaScript runs on the device, what causes frame drops, and why some operations must happen on the native thread — produces meaningfully different work from a React developer who installed Expo to add mobile to their portfolio. Expect $25–50/hr for experienced offshore React Native developers, $100–160/hr US-based. Here is how to tell them apart.
Why React Native Is Different from React
React Native shares React's component model and JSX syntax, but the execution model and the constraints are different from web development in ways that matter for production mobile applications.
The architecture: how JavaScript runs on a mobile device
In React Native's original architecture, JavaScript runs in a separate thread — the JS thread — on the device's JavaScript engine (JavaScriptCore on iOS, Hermes on Android). The JS thread communicates with the native thread through a serialised JSON bridge. Every time the JavaScript code needed to update the UI — call a native API, read a sensor, respond to a gesture — the data crossed this bridge as a JSON message. This serialisation overhead is why gesture animations with logic in JavaScript caused frame drops: each frame required a bridge crossing, and each crossing added latency.
React Native's new architecture (enabled by default in RN 0.76+) replaces the JSON bridge with JSI (JavaScript Interface) — a C++ layer that allows JavaScript to call native code directly without serialisation. The JS object is not converted to JSON and back; instead, JSI exposes C++ objects to JavaScript with direct memory access. This makes Turbo Modules (the new native module system) and Fabric (the new rendering system) dramatically faster for operations that previously bottlenecked on the bridge. A developer who cannot describe the bridge-vs-JSI difference has not followed React Native's architecture evolution.
The UI thread constraint
React Native runs JavaScript on a separate thread, but UI updates must happen on the main thread (the UI thread). If a gesture handler or animation is driven by JavaScript logic — calculating the position of a dragged element in JS, then sending the result across the bridge/JSI to the UI thread — there is inherent latency. For smooth 60fps animations, calculations must happen on the UI thread, not the JS thread. This is what Reanimated 2+ solves: animation worklets run on the UI thread using its own JavaScript runtime, never crossing to the JS thread during the animation loop. A React Native developer who has not used Reanimated for gesture-driven animations has not built complex interactive UIs.
RN-Specific Skills That Distinguish Real Mobile Experience
Navigation architecture
React Navigation is the standard for React Native navigation. Its implementation details matter: the stack navigator manages a navigation stack in JavaScript state, which differs from native navigation stacks (iOS UINavigationController, Android back stack) in how back gestures work, how screens are mounted and unmounted, and how deep links are handled. A developer who has only used Expo's default navigation setup has not managed complex navigation flows — tab-within-stack, modal-within-tab, deep link routing from push notifications.
Native module integration
React Native's bridge allows JavaScript to call native Objective-C/Swift (iOS) or Java/Kotlin (Android) code through modules. When a React Native library doesn't exist for a capability you need — a specific hardware API, a proprietary SDK, a performance-critical operation — you write a native module. A developer who has only used third-party libraries and has never written a native module has a gap in their capability. Ask: "Have you ever written a native module? What for?"
Push notifications end-to-end
Push notification implementation in React Native requires understanding the full stack: Firebase Cloud Messaging (FCM) for Android, APNs (Apple Push Notification service) for iOS, a backend that stores device tokens and calls the FCM/APNs APIs, and the client-side handler that receives the notification when the app is in foreground vs background vs terminated. The most common mistake: handling foreground notifications and missing background and terminated states. Ask: "Walk me through how you've implemented push notifications including the terminated-app state."
Offline and data persistence
Mobile apps need to work without a connection. React Native's options: AsyncStorage (simple key-value, not suitable for structured data), WatermelonDB (high-performance SQLite with Observable queries, designed for React Native's async model), MMKV (fast key-value backed by C++ MMKV library). A developer who uses AsyncStorage for structured data has not hit the performance limitations that appear with real data volumes. Ask: "How do you handle offline data in your React Native applications?"
Five Interview Questions That Filter Effectively
"What's the difference between React Native's old bridge architecture and the new JSI-based architecture?"
Expected: the bridge serialised data as JSON between the JS thread and native thread — expensive for high-frequency calls like gesture tracking. JSI allows JavaScript to hold direct references to C++ objects and call native code without serialisation. This is what enables synchronous native calls and makes Turbo Modules and Fabric possible. Developers who describe only "it's faster" without the mechanism have read the headline, not the documentation.
"How do you implement a 60fps drag gesture without frame drops?"
Expected: use Reanimated 2 with useAnimatedGestureHandler and worklets — JavaScript code that runs on the UI thread rather than the JS thread, so each gesture frame update never crosses the thread boundary. The value update happens on the UI thread directly, which is what enables frame-rate independence from the JS thread. Developers who say "use PanResponder" are using a deprecated approach that runs on the JS thread.
"How do you handle deep links from push notifications when the app is killed?"
Expected: the push notification payload includes a data object with route information. On iOS, the system calls the getInitialNotification or getInitialURL method when the app launches due to a notification tap — the JavaScript code reads this on startup to navigate to the correct screen. On Android, the intent that launched the app contains the deep link. The navigation must wait for the app to fully initialise before navigating. Developers who describe only the foreground notification handler have not handled the terminated-app case.
"Why might a React web developer's code cause performance issues in React Native?"
Expected: web developers often trigger re-renders carelessly (using Math.random() as a key, creating new function references on every render without useCallback), not knowing that in React Native, each re-render crosses threads and is more expensive than on the web. They may also use setTimeout for animations instead of Animated or Reanimated, causing JS thread bottlenecks.
"How do you debug a React Native app that crashes only on release builds but not debug builds?"
Expected: Hermes bytecode in release builds produces different stack traces; enable source maps for production builds to decode them. Crashes often result from native code (check the native crash log on Android via ADB logcat, on iOS via Xcode's Device console). Proguard minification on Android can strip class names that native modules need — check the Proguard rules. Developers who say "I'd add console.log statements" have not debugged a release-build-specific crash.
Red Flags in React Native Portfolios
Only Expo managed workflow projects. Expo is fine for simple apps, but it prevents native module integration and restricts access to native APIs that require ejecting. A developer whose entire portfolio is Expo managed workflow has not written a native module, has not configured native dependencies, and may not be prepared for projects that require capabilities beyond Expo's SDK.
No Android release build in the portfolio. React Native developers often test on iOS simulators and neglect Android. Real apps ship on both platforms. Ask: "Have you deployed to the Google Play Store?" and "Have you dealt with Android-specific navigation behavior?"
A state management approach that crosses React's web patterns into mobile. Managing navigation state in Redux or using React Context for navigation is a sign the developer is applying web React patterns to mobile without adapting to React Navigation's conventions.
Rates for React Native Developers in 2026
| Region | Mid (3–5 yrs) | Senior (6+ yrs) |
|---|---|---|
| India | $22–40/hr | $35–58/hr |
| Eastern Europe | $40–68/hr | $62–90/hr |
| Latin America | $28–50/hr | $45–70/hr |
| UK / Western Europe | $65–105/hr | $90–135/hr |
| USA / Canada | $90–130/hr | $110–160/hr |
React Native developers command 10–15% more than equivalent React web developers because the mobile platform knowledge — native module integration, platform-specific behaviour, App Store / Google Play deployment — is not transferable from web development and takes significant time to acquire. See React Native developer rates for the full breakdown.
Frequently Asked Questions
Should I hire a React Native developer or a native iOS/Android developer? For most new apps targeting both iOS and Android: React Native or Flutter is more cost-effective than two native developers, and the output quality is acceptable for the majority of use cases. Native development makes sense when the app requires deep platform integration (complex AR, custom camera processing, intimate Bluetooth/NFC/hardware access) or when 60fps complex animations are central to the product. See React Native vs Flutter for the technology comparison.
Can a React developer learn React Native quickly? Basic React Native in 2–3 weeks. Production-level mobile development — handling both platforms, native modules, push notifications, App Store / Play Store submission, performance optimisation — takes 6–12 months of active work on real mobile apps. React knowledge transfers well; mobile platform knowledge does not.
Do I need a separate backend for a React Native app? Yes. React Native is a frontend framework for mobile. Your API, database, and business logic live on a server — the same as any web application. The React Native app calls your API over HTTPS. If you need real-time features (chat, live updates), your backend also handles WebSocket connections.