Prepare for React Native interviews covering cross-platform architecture, performance optimization, native module integration, navigation, state management, and the New Architecture.
Start Free Practice InterviewReact Native interview questions assess your ability to build performant cross-platform mobile applications from a shared JavaScript/TypeScript codebase. Interviewers evaluate your understanding of React Native's architecture—both the legacy bridge and the New Architecture (Fabric, TurboModules, Codegen). Expect questions on performance optimization, native module integration, navigation patterns, state management, platform-specific code, and delivering native-quality experiences on both iOS and Android. Companies want developers who understand when to use React Native's built-in components versus dropping down to native code, and who can diagnose and fix performance bottlenecks. Roles range from greenfield mobile apps to migrating existing native apps to React Native, with Expo increasingly used as a production-grade framework.
Architecture questions separate strong candidates from weak ones. Interviewers expect you to articulate the legacy bridge, the New Architecture (Fabric + TurboModules + JSI), and the performance implications of each.
Why they ask it
This is fundamental to understanding React Native's design and performance characteristics. It reveals whether you grasp both the historical bridge pattern and the modern Fabric renderer.
What they evaluate
Answer framework
Sample answer
The legacy bridge uses async JSON serialization: React renders to a virtual DOM in the JS thread, changes are batched into JSON, sent across the bridge, deserialized in the native thread, and applied to native views. This latency makes smooth 60 FPS animations difficult. The New Architecture replaces this with Fabric + JSI: React's virtual DOM updates native views synchronously via the JavaScript Interface, eliminating serialization delays. TurboModules generate type-safe native module interfaces from TypeScript, replacing the bridge's loose contract. Fabric also enables better C++ optimization for rendering, making animations and complex layouts faster. Most production apps are transitioning to New Architecture for these performance wins.
Why they ask it
Fabric is the current rendering engine in React Native 0.76+. Understanding it shows you're current with React Native's direction and performance optimizations.
What they evaluate
Answer framework
Why they ask it
TurboModules are the new native module system in the New Architecture. This tests whether you understand modern patterns for JS-native integration.
What they evaluate
Answer framework
Why they ask it
This tests whether your React web knowledge translates appropriately, and whether you understand React Native's unique mobile constraints.
What they evaluate
Answer framework
StyleSheet JavaScript objects with a Flexbox-inspired layout model, no cascadeFlatList (virtualized) instead of mapping arrays; web can render everything, mobile cannotSample answer
React renders to DOM elements using HTML and CSS; React Native renders directly to native iOS UIViews and Android Views. Web uses browser navigation (URLs, back button); mobile uses view stacks and gesture-based navigation. Web styling uses CSS cascades; React Native uses JavaScript StyleSheet objects with Flexbox-inspired layout—no cascading. Component patterns, hooks, and state management all transfer. The key shift: think in terms of native components and mobile UX constraints, not DOM and browser APIs.
Why they ask it
JSI is the core technology powering the New Architecture. Understanding it shows deep knowledge of React Native's modernization path.
What they evaluate
Answer framework
Performance is the #1 interview differentiator for React Native roles. Interviewers expect you to understand the JS thread vs. UI thread, FlatList virtualization, memoization, and animation strategies—and to profile before optimizing.
Why they ask it
FlatList is the go-to component for scrollable lists. Optimizing it is a practical, high-impact skill that interviewers expect from any candidate who's worked on real apps.
What they evaluate
removeClippedSubviewsReact.memo and useCallbackgetItemLayout for scroll performanceAnswer framework
removeClippedSubviews={true} to unload offscreen views and free memory on large listsmaxToRenderPerBatch (default 10) for slower devices; increase updateCellsBatchingPeriod to batch updatesrenderItem with useCallback and wrap list item components with React.memo to prevent unnecessary re-renderskey props (never index); provide getItemLayout if all items are the same height—dramatically speeds up scroll-to-indexSample answer
FlatList virtualizes—only renders visible items. Optimize by: (1) using removeClippedSubviews={true} to unload offscreen views; (2) reducing maxToRenderPerBatch if rendering is slow; (3) memoizing renderItem with useCallback and wrapping item components with React.memo; (4) using stable key props—never index; (5) providing getItemLayout if items are fixed height, for faster scroll calculations. Profile in React DevTools before over-optimizing—find what's actually slow first.
Why they ask it
This is crucial for understanding React Native performance bottlenecks and writing smooth animations that don't stutter when JS is under load.
What they evaluate
Answer framework
useNativeDriver: true to move animations to the UI thread, or use Reanimated 3 worklets which run JS directly on the UI threadWhy they ask it
Preventing re-renders is the #1 performance lever in React Native. This tests practical optimization knowledge every production developer needs.
What they evaluate
React.memo, useMemo, and useCallbackAnswer framework
React.memo—skips re-render if props are unchanged (shallow comparison)useCallback to memoize callbacks passed as props so child components don't re-render on every parent renderuseMemo for expensive computations whose results are passed as propsstyle={{ margin: 8 }} creates a new object on every render)—extract to StyleSheet.create or useMemoWhy they ask it
Smooth animations are critical for native-quality mobile UX. This tests your understanding of performance-critical rendering.
What they evaluate
useNativeDriver: true in the Animated APIAnswer framework
useNativeDriver: true): offloads animation execution to the native thread—animations run even if the JS thread is blockeduseAnimatedStyle lets you respond to gestures and state changes with UI-thread precisionSample answer
Use Animated API with useNativeDriver: true to run animations on the native thread without JS thread involvement—even if JS is blocked, animations stay smooth. For complex, state-driven animations, use Reanimated 3: write worklets that run on the UI thread and use useAnimatedStyle to respond to gestures and state changes with 60 FPS precision. Always profile on actual devices—simulator performance is misleading. Monitor frame time with React DevTools Profiler and native tools (Instruments on iOS, Android Profiler on Android).
Knowing when and how to write native code is what separates experienced React Native developers. Interviewers test your judgment about when to reach for native, and your practical ability to build and link native modules.
Why they ask it
Building native modules is essential when you need platform-specific functionality. This tests practical integration skills beyond the JavaScript layer.
What they evaluate
Answer framework
TurboReactPackage or the legacy ReactContextBaseJavaModuleWhy they ask it
iOS and Android require different implementations in real apps. This tests your ability to manage platform divergence cleanly.
What they evaluate
Platform.OS conditionals and platform-specific extensions.ios.js / .android.js file extensions for larger divergencesAnswer framework
Platform.OS === 'ios' or Platform.select({ ios: ..., android: ... }) for small conditional valuesMyComponent.ios.tsx and MyComponent.android.tsx—Metro bundler imports the correct file automaticallyStatusBar, haptic feedback, push notifications)Why they ask it
This is a high-level architectural judgment question. The ability to make this call separates experienced developers from those who over-engineer or under-utilize native capabilities.
What they evaluate
Answer framework
Sample answer
Choose JavaScript libraries first—they're cross-platform, easier to test, and faster to develop. Use native modules when: (1) you need platform-specific APIs (Bluetooth, camera hardware, NFC, background processing); (2) performance is non-negotiable after profiling (real-time image filters, audio processing); (3) integrating with existing native SDKs. Profile JS first—most perceived performance problems are actually re-render issues that memoization fixes. Avoid the maintenance cost of unnecessary native code. Start with JS; add native only when profiling shows it's genuinely needed.
Why they ask it
Linking native libraries is a practical skill that surfaces constantly in setup and troubleshooting—interviewers want to know you can handle it independently.
What they evaluate
pod install) and Android GradleAnswer framework
npm install then cd ios && pod install is sufficient for the vast majoritypod install after adding native packages; Podfile.lock should be committedbuild.gradle; Gradle sync happens automatically in Android StudioInterviewers evaluate your testing strategy across unit, component, and E2E layers, and your ability to systematically debug crashes and performance issues on both platforms.
Why they ask it
Jest is the standard testing framework for React Native. This tests foundational testing habits and understanding of how to isolate components from native dependencies.
What they evaluate
act() wrappers and testing state updatesAnswer framework
@testing-library/react-native—test behavior not implementation detailsjest.mock() or the built-in __mocks__ directory; React Native auto-mocks most of its own APIsact() to ensure React processes all pending updates before assertionsjest.fn() or Mock Service Worker (msw) for more realistic network simulationWhy they ask it
Testing Library encourages testing from the user's perspective rather than implementation details. This tests whether your tests are resilient to refactoring.
What they evaluate
getByRole, getByLabelText) vs. testIDfireEvent and waitFor for async interactionsAnswer framework
getByRole('button', { name: 'Submit' }))—it tests the a11y tree and is resilient to UI refactorsgetByText for text content; use getByTestId sparingly as a last resort for dynamic contentfireEvent.press(element), fireEvent.changeText(input, 'value')waitFor and findBy* for elements that appear asynchronously after API calls or state updatesWhy they ask it
E2E testing validates entire user flows on real/simulated devices—critical for catching native integration issues that unit tests miss.
What they evaluate
Answer framework
waitFor), isolate test state, mock API calls for deterministic resultsSample answer
Use Detox for comprehensive E2E testing—it automatically synchronizes with the app's idle state, eliminating most timing flakiness. Tests are clean and readable. Maestro is simpler—YAML-based flows that run in the cloud—great for basic user workflows and non-developer-authored tests. Run on simulators in CI for speed; run on real devices before releases for accuracy. Focus E2E on critical flows: login, onboarding, checkout. Mock API responses to ensure determinism. Mitigate flakiness by avoiding hard timeouts and using explicit synchronization. Don't test business logic in E2E—that belongs in unit tests.
Why they ask it
Systematic debugging is a core skill. This tests whether you have a structured approach rather than guessing and whether you use the right tools for each problem type.
What they evaluate
Answer framework
Expo has matured into a production-grade framework. Interviewers expect you to reason clearly about Expo vs. bare React Native trade-offs, EAS Build/Submit, and OTA update strategies.
Why they ask it
This is a foundational architectural question. Interviewers want to see nuanced judgment—not just "Expo is easier."
What they evaluate
Answer framework
Sample answer
Expo is production-grade: EAS Build handles iOS/Android builds without managing Xcode or Android Studio. Expo SDK provides pre-built native modules that work immediately. EAS Update enables OTA updates for JS-only changes. Great for teams without native expertise and for rapid iteration. Bare React Native offers full flexibility for custom native code and legacy SDK integration but requires owning the build toolchain. My recommendation: start with Expo—Config Plugins and dev clients now cover most custom native needs without ejecting. Eject only as a last resort since it's a one-way door.
Why they ask it
EAS is Expo's CI/CD solution for mobile. Understanding it shows awareness of production build automation and its impact on team productivity.
What they evaluate
Answer framework
.ipa and .apk/.aab in the cloud—no Mac required for iOS builds; team members on Windows or Linux can ship iOS appseas.json (development, preview, production); CI triggers builds on pushWhy they ask it
OTA updates allow shipping JS bug fixes and feature tweaks without waiting for app store review. This tests practical production ops knowledge.
What they evaluate
Answer framework
eas update --branch production; apps check for updates on launch and apply them on next restartBehavioral questions reveal how you navigate real-world challenges—migrations, production crises, performance regressions, and team buy-in. Anchor answers in concrete outcomes using the STAR method.
Why they ask it
Native-to-RN migrations are complex, high-stakes projects. This tests project judgment, stakeholder communication, and ability to bridge native and React Native code during a transition.
What they evaluate
Answer framework
Why they ask it
Production debugging under pressure tests composure, systematic thinking, and technical depth. Interviewers want a structured story, not a vague "I fixed it."
What they evaluate
Answer framework
Why they ask it
Performance optimization is high-impact and highly valued. Interviewers want evidence of profiling discipline—not premature optimization—and measurable results.
What they evaluate
Answer framework
React.memo/useCallback, image compression pipeline, removeClippedSubviews, listener cleanup in useEffect returnWhy they ask it
This tests communication skills, balanced judgment, and your ability to think beyond technical details to team dynamics and business outcomes.
What they evaluate
Answer framework
AceMyInterviews generates React Native-specific interview questions based on your job description and resume. Get personalized questions on your weak areas, instant feedback, and detailed answer comparisons to refine your performance.
Beyond individual questions, interviewers assess your architectural maturity, platform instincts, and ability to diagnose problems systematically.
Deep knowledge of React Native's rendering pipeline—both the legacy bridge and New Architecture (Fabric, TurboModules, Codegen). You should articulate performance implications and when to choose one approach over another.
Ability to balance code sharing with platform-specific quality. Knowing when to use Platform.OS, native modules, or platform-specific libraries while maintaining a cohesive user experience on iOS and Android.
Systematic approach to profiling and optimizing—understanding JS thread vs. UI thread, FlatList virtualization, memoization, native driver, Reanimated worklets, and Hermes. Interviewers expect you to profile before optimizing.
Judgment about when and how to integrate native code. Building custom modules, linking dependencies, managing platform-specific APIs, and handling the sync/async boundary between JS and native correctly.
Understanding of mobile-specific patterns: navigation stacks, gesture handling, screen orientation changes, accessibility, and platform conventions. Your app should feel native, not web-like.
Systematic approach to testing (unit, component, E2E), debugging crashes and performance issues, and using tools effectively—React DevTools, native profilers, error reporting systems like Sentry or Crashlytics.
Practice explaining React Native architecture decisions out loud—communication matters as much as technical knowledge. Record yourself or do mock interviews with friends. You should be able to articulate trade-offs between approaches (bridge vs. JSI, Redux vs. Zustand, Expo vs. bare React Native) clearly and concisely. Interviewers notice candidates who not only know the right answer but can teach it.
Build depth in performance optimization—it's the #1 interview differentiator. Spend time profiling actual apps with React DevTools Profiler, Android Profiler, and Instruments. Implement FlatList optimizations, memoization, and Reanimated animations on real projects. Understand the JS thread vs. UI thread deeply—this knowledge gap separates senior candidates from mid-level ones.
Prepare 3–4 behavioral stories about React Native-specific challenges: a migration project, a performance regression you debugged, a native module you built, or a platform-specific bug. Use the STAR format (Situation, Task, Action, Result). Emphasize your systematic approach, communication with stakeholders, and measurable impact. Specific numbers and outcomes make stories memorable.
Use realistic timed practice conditions—set a timer, answer questions as if in a real interview, and record yourself. Review for clarity, pacing, and completeness. Familiarity with the format reduces anxiety and improves performance. Use tools like AceMyInterviews to simulate real conditions and get objective feedback on answer quality before your actual interview.
You don't need to be a native expert, but foundational knowledge is valuable. Understand iOS UIView hierarchy and Android View layout basics, and know how React Native maps JavaScript components to native views. More importantly, know when to use native APIs (Bluetooth, NFC, ARKit/ARCore) and when JavaScript libraries suffice. Companies expect you to bridge JS and native—not master both. Strong native experience is a genuine advantage; if you lack it, demonstrate deep React Native knowledge and willingness to learn native quickly.
Yes, absolutely. The New Architecture (Fabric, TurboModules, JSI) is the current direction and the default in React Native 0.76+. Expect questions about how Fabric differs from the legacy bridge, why JSI enables synchronous communication, and how TurboModules improve type safety. You don't need to implement New Architecture features from scratch, but you must understand the concepts, benefits, and migration path. Even companies on legacy architecture are planning migrations. Demonstrating this knowledge shows you're current and invested in React Native's future.
Substantial amounts transfer: hooks, state management, component composition, and testing patterns are nearly identical. However, don't assume web knowledge covers mobile. React Native interviews focus heavily on mobile-specific concerns: navigation stacks, gesture handling, platform differences, native API integration, performance constraints, and offline-first architecture. Candidates with React web expertise should explicitly address mobile topics. Interviewers expect you to think in terms of native components and mobile UX, not DOM and browser APIs.
Yes—highly relevant and increasingly expected. Expo is now positioned as a production-grade framework, not just for prototyping. Companies using Expo expect you to know EAS Build, EAS Submit, Expo modules, Config Plugins, and EAS Update. If you've worked exclusively with bare React Native, understand Expo's managed experience and why it appeals to teams without native infrastructure. The ability to reason about when to choose Expo vs. bare React Native demonstrates architectural maturity.
Difficulty ranges by company and level. Mid-level roles expect solid performance optimization knowledge, navigation patterns, and state management. Senior roles dig deeper into architecture decisions, large-scale optimization, and team impact. The key differentiator is performance expertise—companies invest heavily in optimization, so demonstrating profiling skills and systematic thinking distinguishes strong candidates. Prepare with realistic practice and you'll be well-positioned.
React Native interviews emphasize JavaScript/TypeScript, React patterns, the bridge/JSI architecture, and the mature ecosystem (Redux, React Navigation, Reanimated). Flutter interviews focus on Dart, widget trees, state management (Riverpod, Bloc, Provider), and Flutter-specific concepts. React Native is more approachable for JavaScript developers; Flutter attracts those coming from Dart or native backgrounds. Both assess cross-platform thinking and mobile UX understanding. Company framework choice typically follows team skill sets.
AceMyInterviews analyzes your resume and job description, generates personalized React Native questions, simulates real interview conditions with timed responses, and scores your answers against expert benchmarks. Get follow-up questions, instant feedback, and detailed scoring rubrics to pinpoint weak areas and build confidence.
Start Your Interview Simulation →Takes less than 15 minutes. Free to start.