30 React Native iOS/Android Interview Questions for 2026

Practice 30 React Native iOS/Android interview questions for 2026, from basics to release bugs, architecture, notifications, and performance.

React Native iOS Android: 30 Most Asked Interview Questions (2026)

React Native iOS/Android interview questions test whether you actually understand the cross-platform promise — and where it breaks down per platform. Interviewers don't just want definitions. They want to know if you've shipped to both app stores, hit platform-specific bugs, and made real trade-off decisions under production pressure.

This guide covers 30 questions organized by experience level: fresher, mid-level, experienced, and scenario-based. Each answer is direct and built for speaking out loud, not for copying into a doc you'll never reread. If you want to practice delivering these answers under realistic conditions, Verve AI's Interview Copilot can run mock technical interviews and give you structured feedback on clarity and depth — worth doing for the scenario questions especially.

What interviewers actually test in React Native iOS/Android interviews

Hiring panels generally probe three layers:

• Fundamentals and cross-platform mechanics. Can you explain how React Native renders to native views, what the bridge does, and why it's not a WebView? Fresher questions live here.
• Performance and architecture. Do you understand the new architecture (Fabric, JSI, TurboModules), when to use Hermes, and how to keep the JS thread unblocked? Mid-level and senior questions live here.
• Platform-specific behavior. Where does iOS diverge from Android in permissions, notifications, deep linking, layout, and release tooling? This is where interviewers separate candidates who've read the docs from candidates who've debugged a production crash at 2 AM.

Difficulty scales predictably: fresher questions test definitions, mid-level questions test implementation choices, and senior questions test trade-offs and real production decisions.

Fresher level React Native iOS/Android interview questions

Q1 — What is React Native and how does it differ from a native iOS/Android app?

React Native uses JavaScript to build mobile UIs that render to actual native components — not a WebView. Your JS runs on a separate thread and communicates with the native side. In the classic architecture, that communication goes through an async bridge that serializes data as JSON. The 2026-relevant update: the new architecture (Fabric renderer, JSI) replaces the bridge with synchronous, direct JS-to-native calls, which removes the serialization bottleneck.

Q2 — What are the core components, and which ones behave differently on iOS vs. Android?

`View`, `Text`, `TextInput`, `ScrollView`, `FlatList` are the building blocks. The one that trips people up: `SafeAreaView` handles the iOS notch and Dynamic Island automatically, but on Android it does nothing by default — you need to account for the status bar separately (or use a library like `react-native-safe-area-context` that normalizes both platforms).

Q3 — What is the difference between state and props?

Props are passed in from a parent and are read-only. State is owned by the component and triggers a re-render when updated. A concrete example: a `UserCard` receives `name` as a prop but manages its own `isExpanded` state for toggling a detail view. The behavior is identical on iOS and Android — this is pure React, not platform-dependent.

Q4 — What does useEffect do, and when does it run?

`useEffect` runs after the component renders. With an empty dependency array it runs once on mount. With dependencies, it re-runs when those values change. The cleanup function matters for subscriptions and timers — if you forget it, you get memory leaks on both platforms, but they tend to surface faster on Android devices with lower RAM.

Q5 — What is the difference between ScrollView and FlatList?

`ScrollView` renders all children at once — fine for short lists, bad for long ones because it loads everything into memory. `FlatList` (built on `VirtualizedList`) only renders visible items. On both platforms the performance difference is dramatic once you pass a few dozen items.

Q6 — How does Flexbox work in React Native compared to CSS Flexbox?

Default `flexDirection` is `column`, not `row`. You don't need `display: flex`. The layout engine (Yoga) is cross-platform, so Flexbox behavior is consistent between iOS and Android — one of the few areas where you genuinely don't need to think about platform differences.

Q7 — What is AsyncStorage and what are its limitations?

`AsyncStorage` is a simple key-value store. It's unencrypted, string-only, and has size limits that vary by platform. Never store auth tokens or sensitive data here. For secure storage, use `react-native-keychain` (iOS Keychain / Android Keystore) instead.

Q8 — What is SafeAreaView and why does it matter on iOS vs. Android?

On iOS, `SafeAreaView` automatically insets content away from the notch, home indicator, and Dynamic Island. On Android, it historically did nothing — the status bar overlap is handled differently. The cross-platform solution is `react-native-safe-area-context`, which provides consistent insets on both platforms.

Q9 — What is the Platform module and how do you write platform specific code?

`Platform.OS` returns `'ios'` or `'android'`. `Platform.select()` lets you pick values inline. For larger divergences, use file extensions: `Component.ios.js` and `Component.android.js`. The bundler picks the right file at build time.

Q10 — What is the difference between TouchableOpacity and Pressable?

`Pressable` is the modern replacement. It gives you `onPressIn`, `onPressOut`, `onLongPress`, and a `style` function that receives pressed state — more control than `TouchableOpacity`. On Android, `Pressable` also supports `android_ripple` for the native Material ripple effect, which `TouchableOpacity` doesn't.

Mid level React Native iOS/Android interview questions

Q11 — How does the bridge work, and what are its performance limitations?

The classic bridge serializes all JS-to-native communication as JSON over an async queue. That serialization is the bottleneck — high-frequency updates (like gesture-driven animations) stall because every frame has to cross the bridge. The new architecture replaces this with JSI (JavaScript Interface), which lets JS call native functions synchronously without serialization. TurboModules use JSI to load native modules lazily instead of at startup.

Q12 — What is Hermes and when would you disable it?

Hermes is a JS engine optimized for React Native: faster startup, lower memory, ahead-of-time bytecode compilation. It's the default in new projects. You'd disable it only if a third-party native library is incompatible with Hermes's bytecode format — rare in 2026, but it happens with some older native SDKs.

Q13 — How do you handle navigation in a React Native app?

React Navigation is the standard. Stack, tab, and drawer navigators cover most patterns. You pass params between screens via `navigation.navigate('Screen', { id: 42 })` and read them with `route.params`. For deep linking, React Navigation integrates with the `Linking` API — you define a linking config that maps URL paths to screens.

Q14 — What is the difference between Animated and LayoutAnimation?

`Animated` gives you fine-grained control: you define values, interpolate, and compose sequences. `LayoutAnimation` automatically animates layout changes on the next render — simpler but less precise. On Android, you must call `UIManager.setLayoutAnimationEnabledExperimental(true)` to enable it. On iOS it works out of the box.

Q15 — How do you handle push notifications on iOS vs. Android?

iOS uses APNs (Apple Push Notification service); Android uses FCM (Firebase Cloud Messaging). The permission model differs: iOS requires an explicit user prompt before you can send any notification. Android 13+ also requires a runtime permission (`POST_NOTIFICATIONS`), but earlier versions grant it at install. Foreground handling differs too — on iOS you need to explicitly show notifications when the app is in the foreground via `UNUserNotificationCenter`.

Q16 — How do you manage app permissions on iOS and Android?

On Android, use the `PermissionsAndroid` API for runtime permission requests. On iOS, you declare usage descriptions in `Info.plist` (e.g., `NSCameraUsageDescription`) and the system prompts the user. The key difference: Android lets you check `shouldShowRequestPermissionRationale` to detect if the user previously denied; iOS doesn't expose that state directly.

Q17 — What are the trade offs between Expo managed workflow and bare React Native?

Expo managed: faster setup, OTA updates via EAS Update, limited native module access. Bare React Native: full control over native code, more configuration overhead. EAS Build bridges the gap — you can use Expo's build service even with custom native modules. In 2026, most new projects start with Expo and eject only when they hit a native dependency that Expo doesn't support.

Q18 — How do you handle different screen sizes and pixel densities?

`useWindowDimensions` gives you the current width and height. `PixelRatio` helps with density-aware sizing. Percentage-based layouts and Flexbox handle most responsive needs. For truly adaptive UIs, combine dimension checks with `Platform.OS` to handle tablets, foldables (Android), and different iPhone aspect ratios.

Q19 — What is useCallback and useMemo, and when do they actually help?

`useCallback` memoizes a function reference. `useMemo` memoizes a computed value. Both are only useful when the memoized result is passed to a child that checks reference equality (e.g., `React.memo` or a `FlatList` `renderItem`). Premature use adds complexity without performance gain. The real use case: stabilizing references in hot render paths like long lists.

Q20 — How do you debug a React Native app on iOS and Android?

Flipper is the primary debugger — it shows network requests, layout hierarchy, and React DevTools. For Android-specific issues, `adb logcat` gives you native crash logs. For iOS, the Xcode console shows native-side errors and warnings. Metro logs surface JS-level errors on both platforms. Chrome debugger still works but runs JS in Chrome's V8 instead of Hermes, so behavior can differ — use it as a fallback, not a default.

Experienced level React Native iOS/Android interview questions

Q21 — Explain React Native's new architecture: Fabric, JSI, and TurboModules

JSI replaces the bridge with a C++ layer that lets JS hold references to native objects directly — no JSON serialization. Fabric is the new rendering system built on JSI: it enables synchronous layout measurement and concurrent rendering. TurboModules replace the old Native Modules system with lazy loading and typed interfaces generated from a schema. Together, these remove the async bottleneck that limited React Native's performance ceiling for the past several years.

Q22 — How do you integrate a native SDK that has no JS bindings?

Write a Native Module. On Android, create a Java/Kotlin class that extends `ReactContextBaseJavaModule`, implement the methods you need, and register it in a package. On iOS, create an Obj-C or Swift class that conforms to `RCTBridgeModule`. For the new architecture, define a TurboModule spec in a `.js` file with Flow or TypeScript types, and implement the native side against that spec. The TurboModule path is more work upfront but gives you type safety and lazy loading.

Q23 — How do you implement offline first functionality?

Local database options: SQLite (via `react-native-quick-sqlite` or `expo-sqlite`), WatermelonDB for reactive queries, MMKV for fast key-value storage. The pattern: write locally first, queue mutations, sync to the server when connectivity returns. Conflict resolution is the hard part — last-write-wins is simple but lossy; operational transforms or CRDTs are more robust but complex. The choice depends on your data model and how many users can edit the same record.

Q24 — How do you manage OTA updates securely?

EAS Update (Expo) or CodePush (App Center, now deprecated — migrate to EAS). Sign your JS bundles so the app verifies integrity before applying. Implement a rollback strategy: if the new bundle crashes on launch, revert to the previous version automatically. On iOS, Apple's App Store guidelines restrict what you can update OTA — you can change JS and assets, but not native code. Android has no equivalent restriction.

Q25 — What are common React Native performance pitfalls?

JS thread blocking from synchronous computation. Unnecessary re-renders from unstable references or missing memoization. Heavy `FlatList` items that aren't optimized with `getItemLayout`, `removeClippedSubviews`, or `maxToRenderPerBatch`. Unoptimized images — use a caching library like `react-native-fast-image`. And forgetting `InteractionManager.runAfterInteractions` to defer expensive work until animations complete.

Q26 — How do you set up CI/CD for both iOS and Android?

Fastlane handles both platforms: `match` for iOS certificate management, `supply` for Android Play Store uploads. EAS Build abstracts most of this if you're in the Expo ecosystem. GitHub Actions or Bitrise run the pipelines. The iOS-specific complexity: provisioning profiles, certificates, and code signing. The Android-specific complexity: keystore management and Play Store track promotion. Keep secrets in CI environment variables, never in the repo.

Q27 — How do you handle deep linking and universal links on both platforms?

Android uses App Links (verified via `assetlinks.json` hosted on your domain). iOS uses Universal Links (verified via `apple-app-site-association` file). React Navigation's linking config maps URL paths to screens. Testing: on Android, use `adb shell am start -a android.intent.action.VIEW -d "https://yourapp.com/path"`; on iOS, use `xcrun simctl openurl booted "https://yourapp.com/path"`. The most common failure: forgetting to add the associated domains entitlement in Xcode or misconfiguring the `intent-filter` in `AndroidManifest.xml`.

Scenario based React Native iOS/Android interview questions

Scenario Q28 — Your app crashes in Android release build but not debug. What do you do?

The most common cause: ProGuard or R8 minification stripping classes that are accessed via reflection. Check `proguard-rules.pro` for missing keep rules. Enable logging in the release build temporarily (`isDebuggable true` in `build.gradle`) to capture the stack trace. Reproduce locally with `npx react-native run-android --variant release`. If the crash is in a native module, the module's documentation usually lists required ProGuard rules — check there first.

Scenario Q29 — Push notifications work on Android but silently fail on iOS. How do you debug?

Start with the basics: is the APNs certificate (or key-based auth) configured correctly in your push provider? Check the Xcode project: Background Modes must include "Remote notifications" and the Push Notifications capability must be enabled. Verify that `UNUserNotificationCenter` permission was actually granted — users can deny silently. Check whether you're sending to the sandbox or production APNs environment — a mismatch causes silent failures with no error on the client. Finally, test with a tool like Pusher or the APNs HTTP/2 API directly to isolate whether the issue is in your server or your app.

Scenario Q30 — Your FlatList feed drops frames while scrolling on both platforms. How do you fix it?

First, provide `getItemLayout` if your rows have a fixed height — this skips async layout measurement entirely. Set `removeClippedSubviews={true}` to unmount offscreen items. Tune `maxToRenderPerBatch` and `windowSize` to control how many items render per frame. Wrap your `renderItem` function in `useCallback` so it doesn't create a new reference every render. If items contain images, use a caching library and specify dimensions upfront. Move any heavy computation out of `renderItem` and into a memoized selector or `useMemo`. Profile with Flipper's performance plugin to confirm which frames are dropping and why.

How to practice these React Native iOS/Android interview questions

Reading answers is not the same as delivering them. The gap between knowing the content and articulating it clearly under pressure is where most candidates lose points — especially on scenario questions where the interviewer expects you to think out loud, not recite.

Practice speaking your answers, not just reading them. Record yourself. Listen for filler, hesitation, and missing structure.

Verve AI's Interview Copilot lets you run mock technical interviews with real-time feedback on your answer structure, clarity, and depth. It's particularly useful for the scenario-based questions above — the kind where you need to walk through a debugging process step by step and explain your reasoning as you go. You can also replay sessions afterward to spot patterns in how you communicate under pressure. Try it free.

These 30 questions cover the arc from first-interview fundamentals to senior-level production decisions. Revisit the ones you stumbled on after each practice round. The questions don't change much year to year — but the quality of your delivery does.