DEV Community

Cover image for 15 React Native Interview Questions From Junior to Staff, With the Follow-Ups That Matter
Mike Salari
Mike Salari

Posted on

15 React Native Interview Questions From Junior to Staff, With the Follow-Ups That Matter

A React Native interview can begin with a familiar question about components or state and end with a discussion about native threads, memory, release risk or architecture.

That progression matters.

A junior engineer might need to show that they understand how to build a reliable screen. A senior engineer should also be able to explain what breaks in production and how to investigate it. At staff level, the discussion increasingly concerns platform constraints, ownership and decisions that affect multiple teams.

These 15 questions are designed as a practice exercise. The sample answers are deliberately short. For each question, the more useful exercise is to answer the follow-up yourself.

Junior: Get the fundamentals right

1. What's the difference between props and state?

Props are inputs provided to a component. State represents information the component or its owner manages over time.

Follow-up: If two screens need to edit the same value, where should it live, and why?

2. Why do lists need stable keys?

React uses keys to associate elements across renders. Unstable keys can cause incorrect identity reuse and unexpected component state behaviour.

Follow-up: What can go wrong if you use the array index as a key in a list where users insert and delete items?

3. When would you use FlatList instead of ScrollView?

For a potentially large collection, FlatList provides windowed rendering instead of eagerly rendering the entire list.

Follow-up: Why might a FlatList still appear blank during fast scrolling?

4. What happens when a component unmounts?

React runs the relevant effect cleanup. Any work that outlives the component may need explicit cancellation, unsubscription or protection against publishing stale results.

Follow-up: Does removing a component from the screen automatically cancel a network request started by your own service?

5. How do you handle an API request failure?

Represent loading, success and failure distinctly. Give the user an appropriate recovery path.

Follow-up: How does your behaviour change when the request creates or modifies something rather than simply fetching data?

Mid-level: Explain the failure modes

6. Why does a component keep re-rendering?

State changes, context updates, changing props and parent renders may all contribute. Re-rendering is not automatically a performance defect.

Follow-up: How would you establish whether the re-render is expensive enough to matter?

7. How would you optimise a slow FlatList?

First reproduce and measure the problem. Then investigate row complexity, image work, unstable props, unnecessary renders and list configuration.

getItemLayout can help when item dimensions are predictable. It is not a universal fix for dynamic-height rows.

Follow-up: Which optimisation would you reject if it improved scrolling but caused missing content?

8. How does your application handle foreground and background transitions?

React Native provides AppState for observing application states, but backgrounding is not the same as process termination.

Follow-up: What happens to an unsaved form if the operating system later kills the process?

9. When would you write a native module?

When a requirement needs platform functionality or characteristics that cannot reasonably be achieved through the available JavaScript-facing APIs and libraries.

Follow-up: How would you test the boundary between JavaScript and native code, including error handling and lifecycle behaviour?

10. How would you debug a crash that only happens in release builds?

Start with a reproducible release configuration, symbolicated native crash reports where available, JavaScript error evidence and the differences between development and production behaviour.

Follow-up: How would you distinguish a JavaScript failure from a native crash, and what evidence would you collect before changing code?

Senior: Defend the trade-offs

11. How would you design reliable offline writes?

I would expect a durable representation of pending work, explicit retry and conflict handling, and a way to establish whether the server accepted an operation.

Follow-up: Your user presses Pay, loses connectivity and retries. How do you avoid creating two payments?

12. How would you investigate intermittent screen freezes?

Separate JavaScript work, React rendering, native UI work, expensive synchronisation and I/O. Build a timeline rather than assuming that every freeze comes from the JavaScript thread.

Follow-up: What instrumentation would let you connect a user-visible hitch to the work causing it?

13. How would you migrate an established application to the New Architecture?

Start with dependency compatibility, platform support, a controlled rollout and measurements that matter to the application.

The fact that an architecture is newer is not evidence that every app will become faster.

Follow-up: A critical third-party dependency is incompatible. Do you replace it, isolate it, defer the migration or accept the cost? What drives the decision?

Staff: Think beyond one application feature

14. Multiple teams share one mobile foundation. Who owns breaking changes?

A platform boundary needs documented contracts, compatibility expectations, versioning and a process for changes that affect downstream teams.

Follow-up: A feature team needs an urgent exception to a platform rule. Who can approve it, and how do you keep the exception from becoming permanent architecture?

15. Your React Native app has performance problems across several product teams. What do you do first?

I wouldn't begin with a rewrite.

I would define the user-visible failures, establish comparable measurements, identify the most expensive recurring causes and determine which changes require platform ownership rather than local fixes.

Follow-up: How would you prove that a shared optimisation improved the product without simply moving the cost elsewhere?

How to practise these questions

For a junior round, make sure you can explain the concept and demonstrate a working example.

For a mid-level round, add a production failure and how you would test your response.

For a senior round, be ready to explain your chosen trade-off, a rejected alternative, the evidence you would collect and how you would recover.

For a staff-level conversation, expect the interviewer to change the scope. The decision may now affect multiple teams, multiple releases or users on several app versions.

And don't invent production stories to make your answer sound senior.

If you have not worked on a system of that scale, explain how you would approach it and which assumptions you would need to verify.

That's stronger than pretending.

Further preparation

I wrote Top 300 React Native Interview Questions to help engineers practise these increasingly difficult conversations, including production depth, common pitfalls and what each question is intended to evaluate.

The free sample explains the answer structure and how expectations change from junior through staff.

The point of practising isn't to memorise 300 definitions.

It's to become comfortable when the interviewer asks the question that follows your first answer.

These 15 questions are a starting point.

I wrote Top 300 React Native Interview Questions for engineers who want to go beyond definitions and prepare for the follow-ups that reveal their actual level.

It covers junior foundations through staff-level architecture, reliability and platform decisions, with production depth, common pitfalls and what the interviewer is testing.

Explore the book and read a free sample.

Top comments (0)