React Native Developer Interview Questions India 2026: Components, Navigation, and Performance

React Native developer salary India (2024-25):

Junior React Native developer (0-2 years): 5-14 LPA at startups; 3-7 LPA at IT services. Mid-level React Native engineer (3-5 years): 14-32 LPA at product companies. Senior React Native engineer (5-8 years): 28-60 LPA.

React Native vs native Android/iOS salary comparison: React Native developers typically earn 10-20% less than equivalent native Android (Kotlin) or iOS (Swift) engineers at the same company, because native expertise is considered rarer and more platform-specific. However, React Native engineers who can write native modules bridge the gap.

Companies using React Native in India:

• Many Series A-C startups where one engineer can ship both platforms
• Myntra (fashion ecommerce: some features)
• Microsoft India (some internal productivity tools)
• US tech companies with India engineering teams that chose React Native for cross-platform consistency
• IT services companies building mobile apps for enterprise clients

Best use case for React Native: startups and companies where shipping to both Android and iOS with a single team is more important than maximum platform-native performance.

React Native architecture questions:

1. The old architecture (bridge): JavaScript thread: your React code runs here. Native thread: the native UI is rendered and native modules run here. The bridge: an asynchronous, serialised JSON message passing channel between the two threads. Every UI update, native API call, and event from the native layer must be serialised to JSON and passed across the bridge. Problems: the asynchronous bridge introduces latency for complex animations; the JSON serialisation adds overhead for large data payloads; it prevents synchronous access to native APIs.

2. The new architecture (Fabric + JSI): JSI (JavaScript Interface): a C++ layer that allows JavaScript to hold references to native objects and call native functions synchronously, without serialisation. Fabric: the new renderer that uses JSI to render UI components; enables concurrent rendering (React 18 features on React Native). Turbo Modules: lazily loaded native modules via JSI; previously all native modules were loaded at startup. Benefits: synchronous access to native APIs, concurrent rendering, faster startup.

3. When does the new architecture matter? For most apps: the performance difference is not significant; the old architecture is fast enough. The new architecture matters for: complex animations that need synchronous native access (e.g., gesture-driven UI), worklets and Reanimated 3 (uses JSI for UI thread animations), and very large apps where startup time and module loading matter.

React Native ecosystem questions:

1. React Navigation (the standard navigation library): Stack Navigator: push and pop screens; maintains a navigation history stack. Tab Navigator (Bottom Tabs): tab bar at the bottom of the screen; each tab has its own navigation stack. Drawer Navigator: slide-out hamburger menu.

Key concepts: useNavigation hook (access navigation from any component), route.params (pass parameters between screens), Deep Linking (handle app links from notifications or browser URLs; configured in linking.ts), and Navigation lifecycle (useFocusEffect: runs when screen comes into focus, equivalent to componentDidMount on route change).

2. State management in React Native: The same options as React web: Redux (mature, verbose), Context API + useReducer (simple, built-in), Zustand (simple and lightweight, growing fast), and React Query/TanStack Query (for server state management: fetching, caching, and synchronising remote data). For local component state: useState and useReducer. For global app state: Zustand or Redux Toolkit are the current best choices for React Native.

3. Performance optimisation: FlatList vs ScrollView: always use FlatList for lists with more than 20-30 items; it uses windowed rendering (only renders items currently visible on screen); ScrollView renders all children immediately. React.memo: prevents re-renders of components when their props have not changed. useMemo and useCallback: memoize computed values and callbacks to prevent unnecessary recomputation. Hermes: the optimised JavaScript engine for React Native (enabled by default in RN 0.70+); compiles JavaScript to bytecode at build time for faster startup. Image caching: use react-native-fast-image instead of the built-in Image component for proper disk and memory caching.

Native modules and Expo:

1. When do you need native modules? React Native covers most device APIs out of the box (camera, geolocation, push notifications). Native modules are needed for APIs not yet covered by React Native or community libraries, or for accessing device features that require very low-level access (Bluetooth LE with custom GATT profiles, custom audio processing, hardware security keys).

2. Writing a native module: Java/Kotlin (Android) or Objective-C/Swift (iOS) implementation; registered with React Native's module registry; accessed from JavaScript via NativeModules.MyModule.myMethod(). This is why React Native engineers who can write native modules earn more: it requires knowing React Native AND a native platform.

3. Turbo Native Modules (new architecture): Native modules using JSI; synchronous access from JavaScript; lazily loaded (not at startup). CodeGen: auto-generates TypeScript interface and C++ boilerplate from a schema file. More complex to set up than the old @ReactMethod pattern but significantly faster.

4. Expo vs bare React Native: Expo: a managed workflow that provides a set of pre-built native modules (camera, push notifications, maps, file system) and a build service (EAS Build); much faster to start; limited access to native code. When to use Expo: for apps that can live within the managed library ecosystem (most consumer apps). Bare React Native: full access to native code; required for custom native modules or full control over the build configuration. Most large Indian product companies using React Native use bare React Native (not Expo) for production apps.