React Native Interview Questions for 2026: 35 Questions With Answers (New Architecture Era)

35 React Native interview questions with short answers for 2026: New Architecture, Hermes, performance, navigation, Expo, testing and a coding task.

React Native Interview Questions for 2026: 35 Questions With Answers (New Architecture Era)

Most lists of React Native interview questions were written for a framework that no longer exists. They ask you to explain the bridge. They ask whether you would enable Hermes. They treat Expo as a toy. In 2026 the bridge is gone, Hermes is the only sensible engine, and Expo is what the official docs recommend for a new app. So here are 35 React Native interview questions for the New Architecture era, with short answers, grouped the way a real interview tends to go.

I have sat on both sides of this table. We hire React Native developers, and we get interviewed by customers’ engineers about how our SDK works inside their apps. The answers below are the length I would want to hear: two or three sentences, then stop and let the interviewer dig.

Versions referenced: React Native 0.88 (stable, October 2026), 0.89 in release candidate, React 19.3, Expo SDK 58.

Fundamentals

1. What is React Native, in one breath?

A framework that runs your React code in a JavaScript engine on the device and renders real platform views (UIView, android.view.View), not a web page. You write components once, and the renderer creates native UI on each platform. For the longer version, see React vs React Native.

2. How is it different from a WebView app and from Flutter?

A WebView app renders HTML inside a browser component. Flutter draws every pixel itself with its own engine. React Native sits between: your logic is JavaScript, your UI is the platform’s own widgets. That is why a React Native Switch looks like an iOS switch on iOS without anyone styling it. We compared the trade-offs in Flutter vs React Native.

3. What do View, Text and Pressable map to?

View is the layout container (a UIView or ViewGroup), Text is the only component that can hold strings, and Pressable is the current touch primitive that replaced the Touchable* family for new code. Text outside a Text component is an error, which catches every web developer once.

4. How does layout work?

Flexbox, computed by the Yoga engine, with two differences from the web: flexDirection defaults to column, and there is no cascade. Styles do not inherit from parent to child, except text styles inside nested Text. Dimensions are density-independent points, not pixels.

5. StyleSheet.create or inline styles?

Functionally both work. StyleSheet.create gives you validation and typed keys and keeps style objects stable between renders, which matters when a style is passed to a memoized child. An inline object is a new reference on every render.

6. How do you write platform-specific code?

Platform.OS and Platform.select for small differences, file extensions (Button.ios.tsx, Button.android.tsx) for larger ones. Metro picks the right file at bundle time. The honest follow-up: most apps need far less of this than people expect, usually around permissions, shadows and keyboard behaviour.

Architecture

This is where 2026 interviews differ most from older ones. If you only prepare one section, prepare this one. Our architecture explainer is the long form.

7. What is the New Architecture?

Three pieces: JSI, a C++ interface that lets JavaScript hold references to native objects and call them directly; Fabric, the renderer built on it; and TurboModules, native modules that load lazily and are typed through Codegen. It became the default in 0.76 and the only architecture in 0.82. Setting newArchEnabled=false is now ignored.

8. What was wrong with the bridge?

Every call between JavaScript and native was serialised to JSON, queued, and sent asynchronously in batches. That made synchronous calls impossible (you could not measure a view and use the result in the same frame) and made high-frequency traffic such as scroll events or animations expensive. JSI removes the serialisation and the queue.

9. Which threads does a React Native app have?

The UI (main) thread, which handles native rendering and touch; the JavaScript thread, which runs your React code; and background threads Fabric uses for layout. The practical rule: a long task on the JS thread no longer blocks native scrolling, but it does block everything your code needs to respond with, such as press handlers.

10. What is Hermes?

The JavaScript engine built for React Native. It compiles your bundle to bytecode at build time, so the app skips parsing on startup, and it uses less memory than a JIT engine. It has been the default since 0.70, and Hermes V1 became the default in 0.84.

11. What does Codegen do?

It reads a typed spec (TypeScript or Flow) for a native module or component and generates the C++, Java or Kotlin, and Objective-C glue. The benefit is that a type mismatch between JS and native fails at build time, not as a crash in production.

12. What does a TurboModule spec look like?

// specs/NativeDeviceInfo.ts
import type { TurboModule } from 'react-native';
import { TurboModuleRegistry } from 'react-native';

export interface Spec extends TurboModule {
  getBatteryLevel(): Promise<number>;
  getModel(): string; // synchronous, possible because of JSI
}

export default TurboModuleRegistry.getEnforcing<Spec>('NativeDeviceInfo');

The detail interviewers look for: the synchronous method. Under the bridge that signature could not exist.

13. What changes in 0.89?

Mostly deletions. The release candidate removes the bridgeless feature flags and legacy native animated module, requires @react-native/community-cli-plugin in devDependencies, and adds a useAppState() hook plus structuredClone as a global. Knowing the current RC is a cheap way to show you follow the project.

Performance

14. A list scrolls badly. What do you check?

In order: is it a ScrollView rendering everything (switch to a virtualised list), are items re-rendering because of unstable props (memoize the row, stabilise callbacks, use keyExtractor), are images oversized, and is there heavy work in renderItem. Then measure with the React Native DevTools profiler instead of guessing.

15. FlatList or FlashList?

FlatList is built in and fine for short or simple lists. FlashList recycles views instead of unmounting them, which helps most on long lists with heavy rows. The trade-off is that recycled rows must not hold local state that belongs to the item.

16. Do you still need useMemo and useCallback?

Less than before. React Compiler reached 1.0 in October 2025 and memoizes components and values automatically when your code follows the rules of React. In a codebase with the compiler on, manual memoization is for the exceptions. In a codebase without it, the old discipline still applies. Say which one you have worked in.

17. How do you get 60 fps animations?

Keep them off the JS thread. Reanimated runs animation logic in worklets on the UI thread, and Gesture Handler recognises gestures natively, so a drag keeps tracking the finger even if JavaScript is busy. The built-in Animated API with useNativeDriver: true covers transform and opacity.

18. How do you reduce startup time?

Measure first (time to first frame, time to interactive). Then: keep Hermes bytecode on, defer screens and modules that are not needed for the first screen, avoid heavy synchronous work at module scope, and trim what runs before the first render (storage reads, SDK initialisation).

19. How do you find a memory leak?

Take heap snapshots in React Native DevTools before and after repeating a flow, and compare. The usual causes are listeners and timers not cleaned up in an effect, and caches that grow without a limit. Native leaks need Xcode Instruments or the Android Studio profiler.

Navigation and state

20. React Navigation or Expo Router?

Expo Router is file-based routing built on React Navigation, so it is not a competitor so much as a layer. Pick Expo Router for a new Expo app that wants deep links and typed routes for free. Use React Navigation directly when you need full control over navigator structure or you are in a bare app.

21. Stack or native stack?

Native stack uses the platform’s navigation controllers (through react-native-screens), so transitions and gestures are the real ones and cost almost nothing in JS. The JS stack is more customisable. Default to native stack.

22. How do deep links work?

You register a URL scheme and universal links (iOS) or app links (Android), then map URL paths to screens in the navigation linking config. The parts people forget: the association files on your domain, and handling a link when the app is cold started versus already open.

23. Where does state live?

Separate server state from client state. Server state (anything fetched) belongs in a query library such as TanStack Query, which handles caching and refetching. Client state stays local until two distant components need it, then moves to a small store (Zustand, Redux Toolkit). Putting API responses into a global store by hand is the pattern to avoid.

24. How do you persist data on the device?

Preferences in a key-value store (MMKV or AsyncStorage), secrets in the Keychain and Keystore through expo-secure-store or react-native-keychain, structured data in SQLite. Tokens never go in AsyncStorage. That one is a pass or fail question at many companies, and our security checklist explains why.

Native code, builds and releases

25. When do you write a native module?

When a platform API has no maintained library, or when you need to wrap an existing native SDK. Check the Expo Modules API first: it lets you write the module in Swift and Kotlin with far less boilerplate than a raw TurboModule.

26. What is Expo, and when would you not use it?

A framework and set of services around React Native: managed native projects (prebuild and config plugins), a module library, cloud builds and over-the-air updates. The old reason to avoid it, no custom native code, went away with development builds. A fair reason today is a brownfield app, where React Native is embedded in an existing native codebase. More in What is Expo.

27. What can an over-the-air update change?

JavaScript and assets only. Anything that touches native code (a new native dependency, a permission, an SDK upgrade) needs a store release. A good answer also mentions runtime versions, so an update never lands on a binary that lacks the native code it expects.

28. How do you upgrade React Native?

For Expo, bump the SDK and run npx expo install --fix. For bare apps, apply the diff from the Upgrade Helper between your version and the target, one minor at a time. The community CLI no longer has an upgrade command. We wrote the routine down in the Upgrade Helper guide.

29. What is Metro?

The JavaScript bundler. It resolves modules (including platform extensions), transforms code with Babel, and serves the bundle with Fast Refresh in development. Knowing that most “it works on my machine” problems end with --reset-cache is a mark of experience, not of ignorance.

Testing and production

30. How do you test a React Native app?

Unit and component tests with Jest and React Native Testing Library, querying by what the user sees (text, role) instead of test IDs where possible. End-to-end flows on real builds with Maestro or Detox. Keep the E2E suite small and reserved for flows that make money: sign in, checkout, send message.

31. How do you debug a crash that only happens in release builds?

You need symbolicated stack traces, which means uploading source maps and native debug symbols to a crash reporter at build time. Then reproduce with a release build locally. Common causes: code stripped by ProGuard or R8, a missing environment variable, or behaviour that differs without the dev runtime. See error tracking with Sentry.

32. How do you handle the keyboard?

An honest answer admits this is still fiddly. KeyboardAvoidingView for simple forms, react-native-keyboard-controller when you need the input to track the keyboard frame by frame, as in a chat screen. Test on a small Android device, because that is where it breaks.

33. How do push notifications work?

The app asks for permission, gets a device token from APNs or FCM, and sends it to your backend, which calls the push service. Know the difference between a notification message (shown by the OS) and a data message (delivered to your code), and that iOS decides when a background data message wakes your app.

34. What accessibility work is expected?

accessibilityRole, accessibilityLabel and state on every custom control, touch targets of at least 44 by 44 points, support for dynamic type, and a pass with VoiceOver and TalkBack before release. Using Pressable with a role beats a View with an onTouchEnd every time.

35. Is React Native a safe bet in 2026?

Senior candidates get asked this. A balanced answer: one large company moved back to native this year, npm downloads tripled in the same twelve months, and the project now sits under the React Foundation instead of a single vendor. The numbers are in Is React Native dead?. Have an opinion and be able to defend it.

A small coding exercise to expect

Live coding in React Native interviews is usually a fetch-and-list screen. Something like: load items from an API, show loading and error states, support pull to refresh. A clean answer with no libraries:

function useItems(url: string) {
  const [state, setState] = useState<{
    data: Item[]; loading: boolean; error: string | null;
  }>({ data: [], loading: true, error: null });

  const load = useCallback(async (signal?: AbortSignal) => {
    setState((s) => ({ ...s, loading: true, error: null }));
    try {
      const res = await fetch(url, { signal });
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      setState({ data: await res.json(), loading: false, error: null });
    } catch (e) {
      if ((e as Error).name === 'AbortError') return;
      setState((s) => ({ ...s, loading: false, error: (e as Error).message }));
    }
  }, [url]);

  useEffect(() => {
    const controller = new AbortController();
    load(controller.signal);
    return () => controller.abort();
  }, [load]);

  return { ...state, reload: () => load() };
}

export function ItemsScreen() {
  const { data, loading, error, reload } = useItems('https://api.example.com/items');
  if (error) return <ErrorView message={error} onRetry={reload} />;
  return (
    <FlatList
      data={data}
      keyExtractor={(item) => item.id}
      renderItem={({ item }) => <ItemRow item={item} />}
      refreshing={loading}
      onRefresh={reload}
      ListEmptyComponent={loading ? null : <Text>No items yet</Text>}
    />
  );
}

What the interviewer is watching: do you handle the error and empty states without being asked, do you cancel the request on unmount, and do you check res.ok. Then say out loud that in a real app you would use TanStack Query for this. Both halves of that answer matter.

Questions worth asking them

  • Which React Native version is in production, and how long did the last upgrade take?
  • Expo or bare, and who owns the native code?
  • How is a release tested before it goes to the stores?
  • What is the crash-free rate, and who looks at it?

The answers tell you more about the job than the job description does. A team three minors behind with no upgrade plan is offering a different job from the one advertised.

FAQ

Do I still need to explain the bridge in an interview?

Briefly, as history. Explain what it was, why it was slow, and what replaced it. Describing the bridge as the current design is the fastest way to date your knowledge.

Are React questions asked in React Native interviews?

Always. Hooks, effects and their cleanup, rendering and reconciliation, keys, and controlled inputs come up in almost every loop. Our older post on React developer interview tips covers the general preparation side.

How much native knowledge do I need?

For a mid-level role: read a stack trace, change a build setting, add a permission, follow an install guide for a native SDK. For a senior role: write a small module in Swift or Kotlin and debug a build failure in Xcode and Gradle without help.

Should I learn Expo or bare React Native first?

Expo. It is what the React Native docs recommend for new projects, and everything you learn transfers. Open the generated ios and android folders once you are comfortable, so they are not a mystery when something breaks.

One last piece of advice from the hiring side. The candidates who do well are not the ones who memorised 35 answers. They are the ones who shipped something, hit a wall, and can tell you exactly where the wall was.

Leave a Reply 0

Your email address will not be published. Required fields are marked *