Tell me about yourself and your experience with React Native

Start with your current role and the most relevant React Native experience that matches the job description. Focus on the past 5 to 10 years, highlighting recent mobile projects and any leadership or architecture responsibilities you held. Give a concise story structure, for example: "I’m a React Native developer at X where I led a migration from pure native to React Native, improving feature velocity and reducing maintenance cost." Include one measurable result when possible to show impact. Keep this answer under two minutes and practice it so it sounds natural. Avoid reciting your whole resume or unrelated early-career details unless they directly support your fit for the role.

How does React Native architecture differ from React for the web?

Explain that React Native uses the same component and state model as React, but it renders to native UI components instead of the DOM, and uses a bridge and native modules for platform APIs. Emphasize differences in rendering, styling, and the need to manage platform-specific behavior. Give a concrete example: in web you might use CSS and the DOM, while in React Native you use StyleSheet and native view components, and you may need a native module to access a platform-specific sensor. Describe how that influenced a past implementation decision, such as choosing to write a small native module versus finding an existing library. Mention common pitfalls like assuming web performance patterns map directly to mobile, and avoid heavy logic in render paths. Show awareness that debugging, performance profiling, and packaging differ from web workflows.

How do you optimize performance in a React Native app?

Start by profiling to find actual bottlenecks, using tools like React DevTools, Hermes profiling, and Android or iOS performance instruments. Prioritize large renders, expensive JavaScript operations, unnecessary re-renders, and heavy bridge traffic. Give a specific technique: memoize components with React.memo, avoid inline functions and objects in props where appropriate, use shouldComponentUpdate or useCallback, and virtualize long lists with FlatList or SectionList. Also mention offloading heavy work to native or worker threads and enabling Hermes for faster startup. Avoid speculative optimization; focus on measurable improvements and incremental changes. Watch for common gotchas like overusing PureComponent without addressing prop identity and creating too many small setState calls that trigger extra renders.

How do you manage state in a React Native application?

Describe your approach based on app size: use component state and Context for local or small apps, and consider Redux, MobX, or Zustand for larger apps requiring predictable global state and time-travel debugging. Explain why you chose one solution in a past project, touching on complexity and team familiarity. Provide an example: for a medium app I used Redux with redux-toolkit to keep actions and reducers simple, and used selectors to avoid unnecessary re-renders. For simple screens I preferred Context with useReducer to keep dependencies low and minimize boilerplate. Note common mistakes such as putting all UI state in global store and creating deep prop chains that cause re-renders. Keep state close to where it is used, and use derived state only when necessary.

Explain how navigation works in React Native and what libraries you use

Start with the two main patterns: stack-based navigation and tab/drawer navigation, and mention react-navigation as the most common high-level library versus react-native-navigation for native-driven navigation. Explain trade-offs: react-navigation is flexible and JS-driven, while native-driven navigation can offer better performance for complex transitions. Give a practical example: in one project I used react-navigation with native-stack and deep linking to support both stack flows and tab navigation, and I handled param passing and navigation guards via listeners. Describe how you managed state between screens, for instance by using Context for transient UI state and Redux for cross-cutting concerns. Call out pitfalls like nesting many navigators without clear structure, or handling hardware back button behavior inconsistently. Test navigation flows thoroughly and keep navigation-related logic minimal in screens.

How do you test React Native applications?

Outline a testing strategy that includes unit tests for logic, component tests for UI behavior, and end-to-end tests for full flows. Mention common tools like Jest for unit and snapshot tests, React Native Testing Library for components, and Detox or Appium for end-to-end tests on devices or emulators. Give an example: I wrote Jest tests for reducers and utility functions, used React Native Testing Library to assert component rendering and interactions, and ran Detox for a critical onboarding flow before releases. Describe how you integrated tests into CI to run on pull requests and catch regressions early. Warn against over-reliance on snapshots without behavioral assertions and the flakiness that can come from brittle end-to-end tests. Keep tests focused, deterministic, and fast where possible.

How do you handle native modules and bridging when you need platform-specific functionality?

Explain the decision process: first search for maintained community libraries, then evaluate writing a native module when no library meets requirements or performance needs. Describe how you design the JS-to-native API to be simple and testable, and keep heavy logic on the native side for performance-sensitive tasks. Provide an example: I wrote a small iOS Swift module to access a custom BLE peripheral and exposed a Promise-based JS API that emits events for updates. I documented the API, added unit tests where possible, and kept the native code minimal to reduce maintenance burden. Mention common pitfalls like leaking platform-specific behavior into shared business logic and failing to handle backward compatibility for native APIs. Ensure clear versioning and documentation for any custom native code.

How do you handle offline storage and data synchronization?

Start by choosing the right storage for the data type: AsyncStorage for small key-value items, SQLite or realm for relational or larger datasets, and secure storage for sensitive tokens. Then design a sync strategy with a queue and conflict resolution rules, and use background tasks or headless JS for periodic sync where appropriate. Give a concrete technique: in an app I used realm for local data, kept a change queue for offline actions, and reconciled conflicts on the server using last-write-wins for simple cases and manual merges for critical content. I also used network listeners to trigger sync when connectivity was restored. Warn about common issues like storing sensitive data insecurely, not limiting local database growth, and not handling partial sync failures. Implement retries, exponential backoff, and clear user feedback for sync status.

How do you handle animations in React Native?

Explain the options: Animated API for imperative control, LayoutAnimation for simple layout changes, and Reanimated for complex or performance-critical animations. Choose the tool based on the complexity, performance needs, and whether the animation must run on the native UI thread. Provide an example: for a high-performance gesture-driven animation I used Reanimated combined with react-native-gesture-handler to run animations on the UI thread and avoid JS frame drops. For simple fade-ins I used Animated.timing with useNativeDriver set to true when applicable. Point out pitfalls like animating properties not supported by the native driver, which can cause janky animations, and overusing animations that distract from usability. Profile animations on low-end devices and prefer native-driven approaches where smoothness is critical.

How do you debug crashes or performance issues in a React Native app in production?

Start by collecting reliable data: crash reports, device logs, and performance traces using tools like Sentry, Bugsnag, or Firebase Crashlytics, along with Android and iOS system logs. Reproduce the issue locally with similar device configurations, or use symbolicized stack traces and source maps to map errors back to your code. Give a practical workflow: I triaged crashes by grouping similar stack traces in Sentry, prioritized high-traffic issues, and reproduced them on emulators or devices by simulating network conditions or specific inputs. For performance issues I used Hermes profiling, Android Systrace, or Instruments on iOS to identify JS or native hot paths. Avoid fixing without reproducing or sufficient data, and be cautious about making broad changes that might introduce new regressions. Add monitoring for the fix and roll it out gradually when possible.

Tell me about a time you disagreed with a technical decision on your team

Situation: Our team decided to standardize on a heavy third-party UI library to speed development, but I was concerned about bundle size and platform inconsistencies. Task: I needed to present an alternative that met deadlines while addressing my concerns about long-term maintainability. Action: I benchmarked the library against a lightweight component set, measured bundle size and render performance, and prepared a short prototype showing both approaches. I presented trade-offs to the team, proposed a hybrid approach where critical screens used custom components and less critical screens used the library, and volunteered to build the custom components for the first release. Result: The hybrid approach met our deadline, reduced initial bundle size by 12 percent on Android, and the team agreed to gradually replace more screens with custom components where it mattered most. The decision improved performance and reduced platform-specific fixes over the next two releases.

Describe a time you missed a deadline and how you handled it

Situation: In one release we underestimated the effort to migrate a large feature set to React Native and missed a stability gate. Task: As the lead on that migration, I needed to get the project back on track and rebuild trust with stakeholders. Action: I immediately communicated the delay and root causes to stakeholders, broke the remaining work into smaller deliverables, and prioritized stabilization tasks like automated tests and smoke tests. I reallocated team bandwidth to focus on the highest-risk items and set up daily check-ins to surface blockers early. Result: We delivered a stable incremental release six weeks later with fewer regressions than previous releases, and the improved testing cadence reduced hotfix frequency by 30 percent over the next two months. Stakeholders appreciated the transparency and the practical steps we took to improve predictability.

Give an example when you had to mentor someone on your team

Situation: A junior developer joined the team and struggled with asynchronous patterns and debugging in React Native. Task: I was asked to mentor them so they could contribute reliably to feature work within a quarter. Action: I paired with them on real bugs, explained debugging tools and async patterns with short focused sessions, and assigned progressively harder tasks with feedback loops. I also created a small checklist for diagnosing common React Native issues to help them become more independent. Result: Over three months their bug turnaround time improved and they resolved medium-complexity issues without pairing, which freed up senior engineers for architecture work. The junior developer reported higher confidence and the team benefited from a smoother onboarding process.

Show an optimized FlatList implementation and explain key props to improve performance

Explain that FlatList is designed to render only visible items and provide props to tune its behavior, such as keyExtractor, getItemLayout, initialNumToRender, maxToRenderPerBatch, windowSize, and removeClippedSubviews. Use getItemLayout when item height is fixed to avoid layout measurement overhead. Example code: const renderItem = ({ item }) => ; item.id} initialNumToRender={10} maxToRenderPerBatch={10} windowSize={5} getItemLayout={(data, index) => ({ length: ITEM_HEIGHT, offset: ITEM_HEIGHT * index, index })} />. This reduces rendering churn and improves scroll smoothness on long lists. Common pitfalls include using complex inline functions or objects as props, not memoizing renderItem components, and failing to provide stable keys. Profile on low-end devices to find the right balance between memory and responsiveness.

How do hooks like useEffect behave in React Native compared to class lifecycle methods?

Explain that useEffect runs after render and can replace componentDidMount, componentDidUpdate, and componentWillUnmount depending on dependency arrays. Clarify that effects run on every render when dependencies change and cleanup functions run before the next effect or on unmount, aligning with React behavior across platforms. Give an example: useEffect(() => { const sub = subscribe(); return () => sub.unsubscribe(); }, [id]);. This pattern replaces adding and removing listeners in class components and helps avoid leaks when dependencies change. Watch for common mistakes such as missing dependencies leading to stale closures, over-triggering effects by using non-memoized objects in dependency arrays, and performing heavy synchronous work inside effects which can block the JS thread.

Provide a simple example of creating a native module for Android and exposing it to JS

Summarize the steps: create a Kotlin/Java class implementing ReactContextBaseJavaModule, annotate exported methods with @ReactMethod, register the module in a Package, and rebuild the app to access it from JS via NativeModules. Keep the JS API promise-based or event-driven as appropriate for the use case. Example snippet: public class MyModule extends ReactContextBaseJavaModule { public MyModule(ReactApplicationContext ctx) { super(ctx); } @ReactMethod public void echo(String msg, Promise p) { p.resolve("Echo: " + msg); } } Then register it in a Package and access via const { MyModule } = NativeModules; MyModule.echo('hi').then(console.log); Be careful with threading and avoid long blocking operations on the UI thread, and handle exceptions so rejected promises map to meaningful errors in JS. Document the API and test on both debug and release builds.

How does Hermes help React Native apps and how do you enable it?

Explain that Hermes is a JavaScript engine optimized for React Native that can reduce app startup time, decrease memory usage, and improve performance on Android and iOS when supported. Enabling Hermes requires build configuration changes and testing, because certain JS features or third-party libraries may need compatibility checks. Practical steps: enable Hermes in android/app/build.gradle by setting enableHermes: true in react.gradle and for iOS use the appropriate Pod setup, then rebuild the app. After enabling, run profiling to measure startup and memory differences and test thoroughly for regressions. Watch for issues with source maps and debugging tools, and ensure you update your CI pipeline to build with Hermes. Measure before and after to validate that the change benefits your specific app.

Explain how to avoid memory leaks in React Native

Start by identifying common leak sources: retained references from listeners, timers, subscriptions, and uncleaned native resources. Ensure you remove listeners in cleanup functions, clear timers, and dispose of subscriptions when components unmount or dependencies change. Example: useEffect(() => { const id = setInterval(sync, 5000); const sub = NetInfo.addEventListener(() => {}); return () => { clearInterval(id); sub(); }; }, []);. This pattern prevents timers and listeners from persisting after the component lifecycle ends. Also watch for closures that keep large objects alive, and be careful with long-lived caches or global singletons. Use profiling tools and heap snapshots to find leaks in development and address them proactively.

react native developer Interview Questions: Complete Guide

React native developer interview questions typically cover JavaScript fundamentals, React concepts, native integrations, performance, and debugging. Expect a mix of phone screens, coding exercises, take-home projects, and behavioral interviews, and prepare to discuss trade-offs in past decisions.

Common Interview Questions

Behavioral Questions (STAR Method)

STAR Method: Structure your answers using Situation, Task, Action, and Result to tell compelling stories about your experience.

Technical Questions

Questions to Ask the Interviewer

Show your interest by asking thoughtful questions

•What does success look like in this role after six months, and what are the highest priority deliverables?
•Can you describe the team structure and how the mobile team collaborates with backend and QA?
•What are the biggest technical challenges the team is facing on the mobile codebase right now?
•How do you handle platform-specific issues and code ownership between iOS, Android, and shared React Native code?
•What testing and release processes do you have for mobile, and how do you measure app quality in production?

Interview Preparation Tips

1
Practice a live coding problem that focuses on component design and state management, and explain your thought process while you code.
2
Prepare a short case about a past mobile performance issue you fixed, include metrics, your approach, and the final outcome.
3
Bring a concise list of platform-specific trade-offs you’ve made before, so you can discuss pragmatic decisions during the interview.
4
Test your development environment beforehand, and be ready to share your screen with a clear editor, running simulator, and any necessary logs.

react native developer Interview Questions: Complete Guide

Michael Rodriguez

Common Interview Questions

Behavioral Questions (STAR Method)

Technical Questions

Questions to Ask the Interviewer

Interview Preparation Tips

Related guides

react developer Interview Questions: Complete Guide

react Interview Questions: Complete Guide

.net developer Interview Questions: Complete Guide

android developer Interview Questions: Complete Guide

react native developer Interview Questions: Complete Guide

Michael Rodriguez

Common Interview Questions

Q1Tell me about yourself and your experience with React Native

Q2How does React Native architecture differ from React for the web?

Q3How do you optimize performance in a React Native app?

Q4How do you manage state in a React Native application?

Q5Explain how navigation works in React Native and what libraries you use

Q6How do you test React Native applications?

Q7How do you handle native modules and bridging when you need platform-specific functionality?

Q8How do you handle offline storage and data synchronization?

Q9How do you handle animations in React Native?

Q10How do you debug crashes or performance issues in a React Native app in production?

Behavioral Questions (STAR Method)

B1Tell me about a time you disagreed with a technical decision on your team

B2Describe a time you missed a deadline and how you handled it

B3Give an example when you had to mentor someone on your team

Technical Questions

T1Show an optimized FlatList implementation and explain key props to improve performance

T2How do hooks like useEffect behave in React Native compared to class lifecycle methods?

T3Provide a simple example of creating a native module for Android and exposing it to JS

T4How does Hermes help React Native apps and how do you enable it?

T5Explain how to avoid memory leaks in React Native

Questions to Ask the Interviewer

Interview Preparation Tips

Related guides

react developer Interview Questions: Complete Guide

react Interview Questions: Complete Guide

.net developer Interview Questions: Complete Guide

android developer Interview Questions: Complete Guide