Skip to content
Tutorials Center
My learning

Topics

Lesson 70 of 71 ยท Practice and Review

React Native Interview Questions

Prepare for React Native interviews: architecture, Hermes, Fabric, lists, navigation, state, performance and platform differences, with short answers and live stand-ins.

A good interview answer is short, correct and backed by something you have actually done. This page collects the questions that come up most often in React Native interviews, grouped by topic, each with an answer you could say out loud in under a minute. Use it two ways: read an answer after you have tried to say your own, and follow the links to the lesson behind any answer you could not give confidently.

Read-only and stand-in. React Native needs a native runtime that this site cannot run, so code samples are shown in plain code blocks. The two live examples are honest stand-ins written in plain JavaScript: one models the difference between an asynchronous message queue and a direct call, the other shows what goes wrong with index keys. They illustrate the ideas; they are not React Native.

What interviewers listen for

Precision Name the real mechanism.
Trade-offs Every choice costs something.
Experience A bug you fixed beats a definition.
Honesty Say when you do not know.

Two correct sentences beat five vague ones.

1 / 2

Architecture and runtime

What is React Native, and how is it different from a hybrid or WebView app?

React Native lets you write the UI in React and JavaScript, but it creates real native views (UIView on iOS, android.view.View on Android) instead of HTML in a web view. A <View> becomes a native view, <Text> a native text view and so on. The result uses the platform's own scrolling, text rendering and gestures. A WebView app runs a web page inside a native shell. See What is React Native?.

Which threads matter, and what runs on each?

The JS thread runs your React code and business logic. The UI (main) thread draws native views and handles touch. Layout is calculated by Yoga, a C++ engine, and with the New Architecture it can run off the UI thread. There are also background threads for native modules. If the JS thread is busy, taps still register natively but your handlers run late; if the UI thread is busy, the screen itself freezes. See How React Native Runs Your Code.

What changed in the New Architecture?

Three main things. JSI (JavaScript Interface) lets JavaScript hold direct references to C++ objects and call them synchronously, replacing the asynchronous JSON bridge. Fabric is the new renderer: a C++ core that builds a shadow tree, runs layout and commits to the native views. TurboModules are native modules loaded lazily, with typed interfaces generated by Codegen. It is the default for new projects since React Native 0.76, and recent releases no longer support the old architecture.

Old architecture

Async bridge JSON messages in batches.
Eager modules All native modules at startup.
Delayed layout Measuring needed a round trip.
1 / 2

The stand-in below models the key difference in the cheapest way: the old bridge queues messages and delivers them later, while a JSI-style call returns immediately. The log shows the order in which things happen.

Queued messages versus a direct call

What is Hermes?

Hermes is the JavaScript engine built for React Native and the default on both platforms in current versions. It compiles your JavaScript to bytecode at build time, so the app does not have to parse and compile source when it launches. That gives faster startup and lower memory use than shipping plain JavaScript to a general-purpose engine. Hermes also supports the debugging and profiling tools described in Debugging and Performance Profiling.

Describe the path from setState to pixels.

React runs your components on the JS thread and produces a new element tree. The Fabric renderer turns changes into a shadow tree in C++, Yoga computes layout, the tree is committed, and finally the host views are created or updated on the UI thread.

flowchart LR
  A["React render<br/>(JS thread)"] --> B["Shadow tree<br/>and Yoga layout (C++)"]
  B --> C["Commit"]
  C --> D["Mount host views<br/>(UI thread)"]

From state change to native views.

Expo or the bare React Native CLI?

Expo is a framework and set of tools around React Native: project templates, a router, SDK libraries, a build service (EAS) and updates. The React Native team recommends starting with a framework, and Expo is the most widely used. It does not lock you out of native code: config plugins, expo prebuild and development builds let you add any native module. Use the bare CLI only when you want to own the whole native project setup yourself. See Setting Up with Expo and Native Modules, Expo Modules and Config Plugins.

What is the difference between Expo Go and a development build?

Expo Go is a prebuilt app that can open any project using only the native code it already contains. A development build is your own app compiled with your native dependencies and a development client. Once you need a library that is not inside Expo Go (or a custom native module), you need a development build.

Styling and layout

How does layout in React Native differ from CSS?

Everything uses Flexbox, with differences: flexDirection defaults to column, flexShrink defaults to 0, position defaults to relative, sizes are unitless density-independent points, and there is no cascade or inheritance except inside nested Text. Percentages work for sizes, and gap is supported. See Flexbox in React Native.

Why is there no style inheritance or CSS file?

Styles are plain JavaScript objects attached to each component. StyleSheet.create groups them (and gives type checking and some optimization), and style arrays merge from left to right. Because nothing cascades, a component's look depends only on the styles you pass it, which keeps components predictable. Text nested inside Text does inherit font styles, which is the one exception. See Styling with StyleSheet.

How do you handle different screen sizes?

Use Flexbox and percentages first. Use useWindowDimensions for values that depend on the window (it updates on rotation and window resize), safe-area insets for notches and home indicators, and a small breakpoint helper for tablets and foldables. Avoid hard-coded widths from one device. See Responsive Layouts and Screen Sizes.

Lists

When would you use FlatList instead of ScrollView?

ScrollView mounts all its children at once, so it suits short, bounded content. FlatList virtualizes: it renders rows near the visible area and unmounts distant ones. Use it for any list that can grow. See FlatList Essentials.

What makes a FlatList slow, and how do you fix it?

Common causes are rows that re-render needlessly (inline renderItem, unmemoized row components, changing props), expensive rows (large images, heavy layout), and unstable keys. Fixes: React.memo rows, stable callbacks, getItemLayout for fixed heights, smaller image sizes, a smaller windowSize and initialNumToRender tuned for your rows, and for very long or complex lists a recycling list such as FlashList. Measure with a profiler first. See Fast Lists.

Why do keys matter, and what goes wrong with index keys?

React uses keys to decide which row is which between renders. If the key is the index, deleting or inserting an item shifts every later row's index, so React reuses row instances (with their local state, such as an input's text or an animation) for different items. Use a unique, stable id from the data. Try it below: delete the first person in each list after you counted one click on "Ada", then compare where the counter ends up.

Index keys versus id keys

How is navigation different from the web?

Mobile navigation is a history stack of screens that stay mounted: pushing a screen puts it on top and going back removes it, usually with a native transition. Tabs and drawers are other navigators, and they can be nested. There is no URL bar, though screens can still be addressed by deep links. See Navigation Concepts for Mobile.

React Navigation or Expo Router?

Expo Router is built on top of React Navigation and adds file-based routing: files in the app directory become screens, _layout files define navigators, and every screen automatically has a URL for deep linking. React Navigation is configured in code. Choose Expo Router for new Expo apps and for web support through the same routes; choose plain React Navigation when you want explicit configuration or are on an existing app. See File-Based Routing with Expo Router.

How do you protect screens behind a login?

Render different screens depending on auth state (signedIn ? <HomeScreens /> : <SignInScreen />), or use a guard in the Expo Router layout that redirects when there is no session. Keep a loading state while the stored token is being read so the sign-in screen does not flash. See Deep Linking and Authentication Flows.

How do you pass data between screens?

Pass small, serializable params (an id, not the whole object), type them with a param list, and load the data on the destination screen. To send a result back, update shared state (context, a store, or the query cache) or navigate back with params set on the previous screen. See Route Params and Typed Navigation.

State and data

How do you decide where state lives?

Keep it as local as possible. Share it by lifting to a common parent, then context for low-frequency values such as theme or session, then a store such as Zustand or Redux Toolkit for shared client state that changes often. Server data (things you fetch) belongs in a query cache such as TanStack Query, which handles caching, deduplication and refetching. See State in React Native Apps and Server State with TanStack Query.

Where do you persist data?

AsyncStorage or MMKV for small preferences and caches, SecureStore (Keychain and Keystore) for tokens and other secrets, and SQLite for structured or large data and offline-first features. AsyncStorage is not encrypted. See Storing Data and Local Databases with SQLite.

How do you handle offline use?

Decide per feature. For reads, cache server data and show it while refetching. For writes, keep a queue of mutations (optimistic UI plus retry when the connection returns), and use NetInfo to know about connectivity. For full offline-first apps, store data in SQLite and sync in the background with a clear conflict rule. TanStack Query's online manager can pause and resume queries and mutations.

Performance

How do you find and fix unnecessary re-renders?

Profile first: React DevTools' profiler shows which components rendered and why. Then fix the cause: split big components, move state down, memoize expensive children with React.memo, stabilize props with useMemo and useCallback only where it prevents a real render, and select the minimum slice of a store. See Debugging and Performance Profiling.

Animated with useNativeDriver, or Reanimated?

Both can run animations on the UI thread. Animated with useNativeDriver: true sends the whole animation description to native code once, but it can only animate non-layout properties such as transform and opacity. Reanimated runs small JavaScript functions called worklets on the UI thread, so you can animate more properties, react to gestures frame by frame, and avoid the JS thread entirely. See Animations with the Animated API and Reanimated and Gesture Handler.

The app is slow to start. What do you check?

Splash screen behavior and what runs before first render (storage reads, large imports), bundle size and unused dependencies, lazy loading screens and heavy modules, image sizes, Hermes being enabled, and doing network work in parallel rather than in sequence. Measure startup in a release build, not in development, where the dev server and extra checks make everything slower.

The JS thread is busy. What can you do?

Move heavy work out of render, break it into chunks, defer it until after interactions or animations (for example with InteractionManager.runAfterInteractions), do computation in a native module or a worklet, and avoid large synchronous JSON parsing during touch handling. A dropped-frame counter and the profiler show where the time goes.

Platform differences

How do you write platform-specific code?

Use Platform.OS and Platform.select for small differences, and .ios.tsx / .android.tsx file extensions when the difference is large; the bundler picks the right file. Examples of real differences: shadows (shadow* props on iOS, elevation on Android, boxShadow in new versions), keyboard behavior (KeyboardAvoidingView uses padding on iOS and often height or nothing on Android), the hardware back button, permissions dialogs and notification channels. See Platform-Specific Code.

What are common beginner bugs?

Text outside <Text>, 0 or an empty string on the left of &&, a keyboard covering the input, forgetting the Android back button, images with no size, and stale closures in timers or listeners. See Common Pitfalls and Fixes.

Shipping and quality

What can an over-the-air update change?

Only the JavaScript bundle and assets. Anything that changes native code (a new native module, a new SDK version, permissions in the app config) requires a new store build. Updates target a runtime version so a bundle is only delivered to binaries that can run it. See Over-the-Air Updates and Release Strategy.

How do you test a React Native app?

Unit-test logic with Jest, test components with React Native Testing Library (query by role and text like a user, mock native modules), and use an end-to-end tool such as Maestro or Detox for a few critical flows on a simulator or device. See Testing React Native Apps.

What are the key mobile security rules?

Never ship secrets in the bundle (anything in the app can be extracted), store tokens in secure storage, use HTTPS, validate on the server, and consider certificate pinning and root detection for high-risk apps. See Mobile App Security.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What does JSI allow that the old bridge did not?

    JSI exposes C++ objects to JavaScript so calls can be direct and synchronous, instead of serialized asynchronous messages.
  2. 2. Why does Hermes improve startup time?

    The app ships bytecode, so the engine does not have to parse and compile source text at launch.
  3. 3. An over-the-air update can deliver which of these?

    OTA updates replace only the JS bundle and assets. Native changes need a new binary from the stores.
  4. 4. Which state belongs in a query cache such as TanStack Query?

    Server data has special needs (caching, deduplication, refetching), which a query cache is designed for. The others are local UI state.
  5. 5. Why are index keys risky in a list that can delete items?

    After a deletion, indexes shift, so React matches old row instances with different data.

Summary

  • React Native renders real native views; your code runs on the JS thread while the UI thread draws and handles touch.
  • The New Architecture (JSI, Fabric, TurboModules, Codegen) replaces the async bridge with direct calls and a C++ renderer; Hermes precompiles bytecode for faster startup.
  • Know the layout differences from CSS, the list-tuning checklist and why stable keys matter.
  • Navigation is a stack of screens, with typed params and conditional screens for auth; server data belongs in a query cache, secrets in secure storage.
  • Profile before optimizing, and be ready to explain platform differences and what an OTA update can and cannot change.

Finish the track with the one-page React Native Cheat Sheet.