React Native Interview Questions & Answers
React Native Interview Questions & Answers
Hey everyone! This is a simple, interview-ready Q&A sheet for React Native. Every question has a short, clear answer you can say out loud. Read the answer, then repeat it in your own words. For personal/behavioral questions, use the answer as a template and fill in your real experience.
TIP: For "tell me about..." questions, use STAR: Situation → Task → Action → Result. For technical questions, always mention a TRADE-OFF — it sounds senior.
Part 1 — Introduction & Experience
1. Tell me about yourself.
"I'm a React Native developer with [X] years of experience building cross-platform mobile apps for iOS and Android. Recently I worked on [type of app — e.g. an e-commerce app], where I [one highlight — e.g. built the checkout flow and improved list performance]. I enjoy building smooth, reliable apps and I'm excited about this role because [reason tied to the company]."
Tip: Keep it ~60 seconds. Present → highlight → why you're here. Don't recite your whole resume.
2. Tell me about your React Native experience.
"I've used React Native for [X] years building apps like [examples]. I've implemented features such as authentication, REST API integration, navigation, offline support, and push notifications. I'm comfortable with tools like Redux Toolkit or Zustand, React Navigation, and Reanimated, and I've shipped apps to both the App Store and Play Store. One thing I'm proud of is [a concrete win — e.g. reducing list lag by switching to FlashList and memoizing rows]."
Part 2 — Core Fundamentals
3. What is React Native?
"React Native is a framework for building native mobile apps for iOS and Android using JavaScript and React. Unlike hybrid apps, it renders real native components — a View becomes a UIView on iOS and an android.View on Android — so the app looks and feels native while sharing most of the code across both platforms."
4. Explain the React Native architecture.
"React Native runs on three threads: the JS thread runs your React code and logic, the Shadow thread calculates layout using the Yoga engine, and the Native (UI) thread draws the views. Traditionally, JS and native communicated over the Bridge using async JSON messages. The New Architecture replaces the Bridge with JSI for direct calls, Fabric for rendering, and TurboModules for native modules."
5. What is the difference between React and React Native?
"React is a library for building UIs, and on the web it renders to the DOM using div, span, and CSS. React Native uses the same React core — components, props, state, hooks — but renders to native mobile components like View, Text, and Image, with styling done via JavaScript objects and Flexbox instead of CSS files. React is for the web; React Native is for mobile, with the same mental model."
6. What are functional components?
"Functional components are JavaScript functions that take props and return JSX describing the UI. With hooks they can manage state and side effects, so they've fully replaced class components. They're simpler, more concise, and easier to test and reuse."
7. Explain React Hooks.
"Hooks are functions that let functional components use React features. useState adds local state, useEffect handles side effects like data fetching, useContext reads context, and useMemo/useCallback memoize values and functions to avoid extra work. The rules are: only call hooks at the top level and only from React functions, so their order stays consistent."
8. What is JSX?
"JSX is a syntax extension that lets you write HTML-like markup inside JavaScript. It's not valid JS by itself — Babel transpiles it into function calls like React.createElement. In React Native the tags are native components like View and Text rather than HTML elements. It exists to make UI code readable."
9. Explain reusable components.
"Reusable components are built to be used in many places by keeping them generic and configurable through props. A good one does a single job, has a clear prop API, avoids hard-coded values, and doesn't care where it's used — for example a Button that takes a title, onPress, and variant works everywhere in the app."
10. Explain component-driven development.
"It's building the UI bottom-up from small, isolated, reusable components, often developed and tested in isolation before composing them into screens. It improves reuse, consistency, and testability, and works well with a design system and tools like Storybook."
Part 3 — State & Navigation
11. How do you manage state in React Native?
"I pick the simplest tool that fits: useState for local state, useReducer for complex local state, Context for low-frequency app-wide values like theme or auth, Zustand for a lightweight global store, and Redux Toolkit for large apps that need structure and devtools. Server data is best handled by React Query. Important state is persisted to device storage since memory is cleared on restart."
12. Explain Redux.
"Redux is a predictable state container with a single store as the source of truth. You dispatch actions describing what happened, and pure reducers compute the next state. Redux Toolkit is the modern standard — createSlice cuts boilerplate, configureStore sets it up, and useSelector and useDispatch connect components. It's best for large apps with lots of shared state."
13. What is the Context API?
"It's a built-in React feature for sharing data down the tree without prop drilling — you create a context, wrap part of the tree in a Provider, and read it with useContext. It's ideal for low-frequency global values like theme, language, or the current user. For frequently changing state it can cause too many re-renders, so a store like Zustand or Redux is better there."
14. Explain React Navigation.
"React Navigation is the standard navigation library. Mobile navigation is a stack of screens, so you push and pop instead of changing URLs. It offers Stack, Bottom Tab, and Drawer navigators, which you nest for real apps. You navigate with navigation.navigate and goBack, pass data through route params, and wrap the app in a NavigationContainer."
Part 4 — JavaScript, APIs & TypeScript
15. How do you integrate REST APIs?
"With fetch or axios, usually inside useEffect or a data-fetching hook, using async/await. I always handle loading, error, and empty states, and often use React Query for caching, retries, and background refetching, which helps on flaky mobile networks. I also add timeouts and handle the offline case."
16. Explain the Fetch API and Axios.
"fetch is built in but low-level — you parse JSON manually with .json() and it doesn't reject on error statuses, so you check response.ok. Axios is a library that auto-parses JSON, throws on 4xx/5xx, and adds interceptors, timeouts, and request cancellation. I use fetch for simple cases and axios when I want those conveniences."
17. What is async/await?
"It's syntax that makes asynchronous code read like synchronous code. Marking a function async lets you await a Promise, which pauses until it settles, and you handle errors with try/catch. It replaces nested .then chains and is the standard way to write async code today."
18. Explain JavaScript Promises.
"A Promise represents a value that will be available later. It starts pending and settles as either fulfilled with a value or rejected with an error, handled with .then and .catch or with async/await. Promises solved callback hell and are the foundation of modern async JavaScript."
19. What is TypeScript?
"TypeScript is a typed superset of JavaScript that compiles to plain JS. In React Native it catches errors at compile time, improves autocomplete and refactoring, and documents component props and API shapes. It's essentially the industry default for serious apps now, and tools like Zod can even derive types from validation schemas."
20. How do you implement authentication?
"Usually token-based: the user logs in, the backend returns an access token, often with a refresh token, and I store it securely in the Keychain or Keystore — never plain AsyncStorage. I attach the token to API requests via an axios interceptor, refresh it when it expires, and gate navigation so unauthenticated users see the auth screens. On logout I clear the tokens."
Part 5 — Performance & Optimization
21. How do you optimize app performance?
"The main principle is keeping the JS thread free, since most jank comes from blocking it. I avoid unnecessary re-renders with React.memo, useMemo, and useCallback; virtualize lists with FlatList or FlashList; run animations on the UI thread with Reanimated; right-size and cache images; and use Hermes for faster startup. And I profile first to find the real bottleneck instead of guessing."
22. Explain FlatList optimization.
"FlatList is virtualized, so it only renders visible items. To optimize further: memoize the row with React.memo, use stable keys via keyExtractor and never the index, provide getItemLayout for fixed-height rows so it skips measuring, tune initialNumToRender and windowSize, enable removeClippedSubviews, and keep rows lightweight. For very large lists, FlashList is an even faster drop-in replacement."
23. How do you optimize component rendering?
"I prevent renders that don't change the output: wrap pure components in React.memo, stabilize callbacks and derived values with useCallback and useMemo, avoid creating new inline objects or arrays in render, and split large components so a state change affects the smallest subtree. But I profile with the React DevTools Profiler first — over-memoizing just adds complexity."
24. How do you improve app startup time?
"Use the Hermes engine, which precompiles JS to bytecode so there's no parsing at launch. Keep the initial bundle lean, lazy-load heavy screens and components so they aren't evaluated up front, and defer non-critical work until after the first render. Profiling startup shows what's blocking the first paint."
25. Explain performance profiling.
"It's measuring where time and frames go before optimizing. I use the Performance Monitor for live JS and UI frame rates, the React DevTools Profiler to see which components re-render and why, Flipper for network and layout, and the Hermes sampling profiler for CPU hot spots. The rule is: measure, fix the real bottleneck, then measure again."
26. How do you ensure a smooth user experience?
"Keep interactions responsive by not blocking the JS thread, run animations at 60fps on the UI thread, always show loading and error states so screens never look frozen, handle offline gracefully, and follow platform UX conventions. Fast lists, good keyboard handling, optimistic updates, and clear feedback on every action all contribute."
Part 6 — Debugging & Production Issues
27. How do you debug React Native applications?
"I start with console logs shown in Metro, then use the dev menu to open the debugger for breakpoints and variable inspection via Hermes and RN DevTools. React DevTools shows the component tree and props/state, and a network inspector like Flipper's helps with API issues. The red screen's message and stack trace usually point straight to the error."
28. How do you resolve application crashes?
"If there's a red screen it's a JS error — I read the message and stack trace to the failing file; a common cause is reading a property of undefined before data loads. If the app just closes with no red screen, it's a native crash, so I read native logs with log-android or log-ios, or logcat and Xcode. In production I rely on crash reporting like Sentry or Crashlytics to get stack traces and reproduce it."
29. How did you resolve production issues?
"First I assess impact. For a JS-only bug I can push an OTA update via CodePush for an immediate fix without a store review. For native issues I prepare a hotfix build and can request an expedited review. Then I find the root cause from crash reports, add a regression test, and improve monitoring so it's caught earlier next time — and I keep stakeholders updated throughout."
30. What would you do if a production release failed?
"I'd first contain the damage — roll back if possible, or push an OTA update for a JS fix. Then diagnose using crash reports and logs, apply a hotfix, and communicate status to the team and stakeholders. Afterwards I'd run a post-mortem to add tests, better monitoring, and safeguards like staged rollouts so the same failure can't reach all users again."
Part 7 — Architecture & Internals
31. Explain the React Native New Architecture (Fabric, TurboModules, JSI).
"It replaces the old async JSON Bridge. JSI, the JavaScript Interface, lets JS call native C++ methods directly and synchronously with no serialization — that's the foundation. Fabric is the new JSI-based rendering system with a shared C++ core for faster, more consistent UI. TurboModules are lazily-loaded, type-safe native modules built on JSI. Together they enable Bridgeless mode, giving faster startup and smoother UI. Most app code doesn't change — you benefit under the hood."
32. What is the difference between Hermes and JavaScriptCore? Why is Hermes preferred?
"JavaScriptCore was React Native's original engine. Hermes is an engine Meta built specifically for React Native. Hermes precompiles JavaScript to bytecode ahead of time, so there's no parsing at launch — that improves startup time — and it also lowers memory usage and app size, which matters on lower-end devices. It has a built-in debugger too. Because of these mobile-focused optimizations, Hermes is now the default and preferred engine."
33. How do you create Native Modules or Native UI Components?
"When React Native lacks a feature, I write native code — Swift or Objective-C on iOS, Kotlin or Java on Android — and expose it to JavaScript. A native module exposes native functions to JS, and a native UI component wraps a native view for use in JSX. In the New Architecture these are TurboModules and Fabric components, defined with a JS spec and Codegen for type safety. In practice I usually use an existing community module and only go native for a missing SDK, heavy computation, or a brand-new OS API."
Part 8 — Testing, Offline & Storage
34. How do you write unit, integration, and end-to-end (E2E) tests?
"Unit tests with Jest cover pure functions and logic. Integration and component tests use React Native Testing Library to render components and simulate user interaction — finding elements by visible text and pressing them — testing behavior over implementation. E2E tests with Detox run the real app on a simulator and automate whole flows like login. The testing pyramid guides the mix: many fast unit tests, fewer slow E2E tests. Native modules and network calls are mocked so tests stay fast and reliable."
35. How do you handle offline support, local storage, and data synchronization?
"For local storage I use AsyncStorage or the faster MMKV for key/value data, SQLite or Realm for structured data, and the secure Keychain or Keystore for tokens. For offline support I cache server data — via React Query persistence or a local database — so the UI reads from the device when there's no network, and I detect connectivity with NetInfo. For synchronization I queue local changes while offline and replay them when the connection returns, resolving conflicts with a strategy like last-write-wins or server-authoritative."
Part 9 — Deployment & Release
36. How do you publish apps to the Google Play Store and Apple App Store?
"For Android I sign the app with a keystore and build a release AAB with Gradle, then upload it to the Google Play Console. For iOS I archive in Xcode on a Mac with a valid signing certificate and distribute to App Store Connect. Both need screenshots, a description, and a privacy policy; Apple requires a paid developer account and a stricter review. I bump the version and build number for each release."
37. Explain your release process.
"Feature branches go through pull requests with code reviews and CI running tests and lint. Then a release candidate is built and tested on internal tracks — TestFlight for iOS and internal testing on Play. After QA sign-off I do a staged or phased rollout to catch issues early, monitor crash and performance dashboards, and can halt or roll back if needed. For JS-only hotfixes I use OTA updates."
38. How do you manage app deployments?
"With versioning discipline, CI/CD for consistent builds, staged rollouts to limit risk, and monitoring after each release. I keep clear release notes, use OTA updates for quick JS fixes, and have a rollback plan. The goal is predictable, low-risk releases where problems are caught before they hit everyone."
Part 10 — AI Features
39. How would you integrate AI features into a mobile application?
"Most commonly by calling an AI API through my own backend — for example a chat or summarization feature that sends user input to a model and streams the response back. I keep API keys on the server, never in the app, and stream responses for a responsive feel. For things like image classification or OCR, an on-device option like ML Kit works well where latency and privacy matter. Key concerns are cost control, handling latency with good loading UX, error and timeout handling, user-data privacy, and rate limiting. I'd use the latest capable models and design the UX around streaming and graceful fallbacks."
Part 11 — Project & Behavioral
40. Explain your latest React Native project / your current project.
"[App name] is a [type] app for [users]. I was responsible for [your part]. The stack was [React Native, Redux/Zustand, React Navigation, etc.]. A hard problem I solved was [example — e.g. offline sync or list performance], and the result was [impact — e.g. faster load, lower crash rate, more users]."
Tip: Tell it as a story, not a feature list. Have real numbers ready.
41. What was your role in the project?
"I owned [specific screens/features/decisions], collaborated with [designers, backend, PM], and [any leadership — mentoring, reviews, tech decisions]. I use 'I' for my own work and 'we' for team efforts."
42. Describe a challenging issue you solved / What challenges did you face?
"[Symptom — e.g. the list froze on Android with large data]. I diagnosed it with the profiler, which showed [cause — JS-thread blocking]. I tried [attempts], then fixed it by [solution — virtualized the list, memoized rows, moved work off the JS thread], and the result was [measurable improvement]."
Tip: Show your debugging process, not just the final answer.
43. Have you mentored junior developers?
"Yes — I've [paired on features, reviewed code with a teaching focus, broken down tasks], and helped teammates grow by [example]. I focus on enabling them to solve problems themselves rather than doing it for them."
If limited: talk about knowledge sharing — docs, sessions, helping others debug.
44. Why should we hire you?
"I bring solid React Native depth, a track record of shipping and maintaining real apps end to end, and I understand the fundamentals — architecture, performance, threading — not just the APIs. I also collaborate well across product, design, and backend. I care about performance and user experience, and I'd help your team ship reliable apps."
Part 12 — Team & Process
45. How do you perform code reviews?
"I check correctness, readability, and maintainability — does it work, is it clear, does it follow our conventions, are edge cases and tests covered. I watch for performance issues like unnecessary re-renders and for security concerns. I give specific, kind, actionable feedback, separate blocking issues from nice-to-haves, and praise good work. The goal is better code and a growing author."
46. How do you ensure code quality?
"A combination of TypeScript for type safety, ESLint and Prettier for consistency, code reviews, automated tests in CI, and clear conventions with a shared component library. I also value readable code, small focused components, and refactoring as I go. Automation catches mechanical issues so reviews focus on design and logic."
47. How do you estimate development tasks?
"I break work into smaller pieces, estimate each by complexity and unknowns, and add buffer for testing, reviews, and integration. I flag risks and dependencies, prefer relative estimation like story points in a team, and communicate estimates as ranges, updating them as I learn more instead of committing to one optimistic number."
48. How do you prioritize your work?
"By impact and urgency — production bugs and blockers first, then high-value features aligned with product goals, then improvements and tech debt. I align with the PM on priorities, consider dependencies so I don't block others, and stay flexible when things change."
49. How do you collaborate with Product Managers?
"I engage early to understand the 'why' behind features, clarify requirements and edge cases, give realistic estimates and surface technical constraints, and propose alternatives when something is costly. I keep them updated on progress and risks — it's a partnership balancing user value with technical reality."
50. How do you work with UI/UX designers?
"I review designs early for feasibility and platform conventions, flag anything expensive or inconsistent across iOS and Android, and ask about edge states like loading, empty, error, and long text. I match the design faithfully while suggesting practical adjustments, and use a shared design system for consistency."
51. How do you collaborate with backend developers?
"I align on API contracts early — endpoints, payload shapes, error formats, pagination — ideally documented in a shared spec. I discuss what data the app needs to minimize round-trips and over-fetching, agree on auth and versioning, and use mocks so I'm not blocked while the backend is built. Clear contracts prevent most integration pain."
52. How do you handle changing requirements?
"I expect change and build flexibly — modular components and clean architecture make it cheaper. When requirements shift, I assess the impact on scope and timeline, communicate trade-offs to the PM, re-prioritize, and adjust estimates. I avoid over-engineering for imagined futures but keep the code adaptable, and stay calm and collaborative."
Final Interview Tips
┌─────────────────────────────────────────────────────────────┐ │ INTERVIEW DAY CHECKLIST │ ├─────────────────────────────────────────────────────────────┤ │ ✔ Know the fundamentals cold: architecture, threads, JSI │ │ ✔ Always mention trade-offs — it signals senior thinking │ │ ✔ Prepare 2-3 STAR stories (a challenge, a win, teamwork) │ │ ✔ Have real numbers: users, performance gains, crash rate │ │ ✔ For "how do you..." → give a process, not just a tool │ │ ✔ Be honest about what you don't know; show how you'd learn│ │ ✔ Ask THEM good questions — it shows genuine interest │ └─────────────────────────────────────────────────────────────┘
All the best — you've got this! 🚀
Post a Comment