React Native

Essential React Native Interview Questions and Answers

Key Takeaways

  • The Bridge is gone. React Native 0.76 made the New Architecture the default, and 0.82 removed the old one entirely. JSI, Fabric, TurboModules, and Codegen replaced it.
  • React Native has no virtual DOM. Interviewers use this to catch candidates working from outdated material. It builds a shadow tree instead.
  • Questions about componentDidMount still appear, usually to see whether you can map the old model onto the new one.
  • Performance questions dominate mid-level interviews, especially around list rendering, re-renders, and keeping animations off the JavaScript thread.
  • Expo is now the recommended starting point in React Native’s own documentation.
  • Security questions come up far more often in fintech interviews than elsewhere, and AsyncStorage being unencrypted is the single most common thing candidates get wrong.

Preparing for a React Native interview has gotten harder in the last couple of years, and not because the questions got tougher. The framework changed underneath everyone.

React Native replaced its entire architecture.

The Bridge that older guides describe in detail no longer exists; Fabric and TurboModules are no longer “new,” and a candidate who explains the old serialized message queue as though it were current will signal that their knowledge stopped somewhere around 2024.

Whether you are conducting interviews or trying to pass them, you need to be up to date with the latest happenings in React Native to ensure you can vet or answer effectively.

Let’s look at what gets asked now, broken down by seniority, with answers that reflect the framework as it actually works in 2026.

If you are on the hiring side and finding the interview process heavy going, the same questions work as a screening structure.

We at Trio interview React Native developers regularly, and we can help with staff augmentation, outsourcing, or building a dedicated team.

Our senior React Native developers also have production experience in industries like fintech and are familiar with the ever-shifting regulatory landscape.

View capabilities.

React Native fundamentals

Expect these regardless of the role. They establish whether your mental model is current.

What is React Native, and how does it differ from React?

React Native is an open-source framework from Meta for building iOS and Android applications from a single JavaScript or TypeScript codebase.

The difference from React comes down to what gets rendered. React renders to the browser DOM. React Native renders to actual native platform views, so a <View> becomes a UIView on iOS and a ViewGroup on Android.

You write components the same way, using the same hooks and the same state model, but the output is a native app rather than a web page.

React Native cross-platform development with Android and iOS

Does React Native use a virtual DOM?

No, and this question exists specifically to find out whether you learned React Native from current material.

React Native has no DOM, so it cannot have a virtual DOM. What it has is a shadow tree, maintained on the native side, that mirrors your React component hierarchy. React reconciles changes in JavaScript, the shadow tree computes layout using Yoga, and the result gets applied to real native views.

The confusion is understandable, since the concepts rhyme. Both avoid expensive direct manipulation by diffing an in-memory representation first. Saying “virtual DOM” in a React Native interview is a small thing that reliably costs candidates credibility.

How do you create a new React Native project?

Two routes, and the recommended one has changed.

React Native’s official documentation now points developers toward Expo first for most new projects:

npx create-expo-app@latest MyApp

For a bare React Native project without Expo, the community CLI handles it:

npx @react-native-community/cli@latest init MyApp

Worth knowing that react-native init was the standard command for years and has since been removed. Guides still recommending it are out of date, which makes this a useful question for interviewers.

Explain the difference between state and props.

State holds data local to a component that changes over time, and changing it triggers a re-render. Props pass read-only data from a parent down to a child to configure it.

The practical distinction here is that a component owns its state and cannot modify its props. If a child needs to change something a parent holds, the parent passes down a function for the child to call.

What are hooks, and which ones come up most?

Hooks let functional components use state and other React features, which removed most of the need for class components.

The ones worth being fluent in:

  • useState for local component state
  • useEffect for side effects, with the dependency array controlling when it runs
  • useContext for consuming context without prop drilling
  • useMemo and useCallback for memoizing expensive values and stable function references
  • useRef for mutable values that persist across renders without triggering one

Interviewers often follow up on useEffect dependency arrays, since getting them wrong causes either infinite loops or stale closures, and both show up constantly in real codebases.

How do you handle platform-specific code?

Two approaches, used for different sizes of difference.

The Platform module handles small branches inline:

import { Platform } from ‘react-native’;

const padding = Platform.OS === ‘ios’ ? 20 : 16;

Platform.select() tidies this up when several values vary at once.

For anything larger, use file extensions. MyComponent.ios.js and MyComponent.android.js sit alongside each other, and the bundler picks the right one automatically when you import MyComponent.

This keeps platform divergence out of your component logic, which matters once the differences grow past a few constants.

What is JSX?

JSX is a syntax extension for JavaScript that lets you write markup-like code inside your JavaScript files.

It compiles down to function calls that create React elements. In React Native, it describes a tree of native components rather than HTML elements, so you write <View> and <Text> rather than <div> and <span>.

How do you manage state in React Native?

Start with what the problem needs rather than reaching for a library by default.

Local component state goes in useState or useReducer. State shared across a few components can use Context, though Context re-renders every consumer when its value changes, so it suits infrequently changing data like theme or auth status better than anything that updates often.

For application state, the current landscape has moved on from Redux-by-default:

  • Zustand has become a common choice for its small API and minimal boilerplate
  • Redux Toolkit remains the standard where Redux makes sense, and removes most of the ceremony the original had
  • Jotai and Recoil take an atomic approach
  • TanStack Query handles server state, which is worth separating from client state conceptually

We’ve seen that last distinction come up in interviews far more than it used to. Cached server data has different needs from UI state, and candidates who treat everything as one undifferentiated store tend to get asked about it.

The New Architecture

This section carries the most weight in 2026 interviews, and it is where outdated preparation shows most clearly.

What is the React Native New Architecture?

The New Architecture replaced the legacy Bridge with four connected pieces:

  • JSI (JavaScript Interface) lets JavaScript hold direct references to C++ objects and call native methods synchronously, with no serialization
  • Fabric is the rendering system, rebuilt to support concurrent React and synchronous layout
  • TurboModules is the native module system, with lazy loading so modules initialize only when first used
  • Codegen generates type-safe native interface code from TypeScript or Flow definitions at build time

It became the default in React Native 0.76 in late 2024, and 0.82 removed the ability to opt out. New projects have no old architecture to fall back to.

Explain the legacy Bridge and why it was replaced.

Interviewers still ask this, now as a historical question. The goal has shifted to testing whether you understand what problem the current design solves.

The Bridge was an asynchronous message queue between JavaScript and native. Every call got serialized to JSON, batched, and passed across, with the response coming back the same way. Nothing could happen synchronously.

Three consequences made it a bottleneck.

Serialization cost CPU time on every interaction. The asynchronous-only model meant JavaScript could never read a native value immediately, so measuring a view before painting required a round trip. And heavy traffic, like a fast scroll through a long list, could saturate the queue and drop frames.

JSI removes the serialization entirely by exposing native objects directly to JavaScript as host objects. The call becomes a direct function invocation rather than a message.

What is Fabric, and what does it change?

Fabric is the rendering system. It builds an immutable shadow tree in C++, shared between JavaScript and native, which allows two things the old renderer could not do.

Layout can be calculated synchronously, so a component can measure itself and render in the same frame. And rendering supports React’s concurrent features, meaning React can interrupt a low-priority render to handle something more urgent like user input.

Practically, we see this showing up as smoother interaction under load rather than as a feature you call directly.

What are TurboModules?

TurboModules are the current native module system. They differ from the old NativeModules in two ways that matter.

First, TurboModules load lazily, so a module initializes the first time JavaScript actually uses it rather than at app startup. On an app with many native dependencies, this measurably improves launch time.

And they are type-safe, generated by Codegen from a TypeScript spec, so a mismatch between the JavaScript signature and the native implementation fails at build time rather than at runtime in production.

What is Hermes?

Hermes is the JavaScript engine React Native uses by default on both platforms. Meta built it specifically for mobile.

It precompiles JavaScript to bytecode at build time rather than parsing source at startup, which cuts time to interactive noticeably. It also uses less memory and produces a smaller app binary than JavaScriptCore did.

What you need to be ready for: Hermes supports debugging through Chrome DevTools, and React Native’s debugging story has shifted around it over recent versions.

How do you create a custom native module now?

Write the native implementation in Kotlin or Java for Android and Swift or Objective-C for iOS, then define a TypeScript spec describing the interface. Codegen reads that spec and generates the binding code at build time, which gives you type safety across the boundary.

The older pattern of manually bridging with RCT_EXPORT_METHOD and registering through NativeModules still appears in legacy codebases, so being able to describe both is useful. New work should use the TurboModule approach.

Performance

Mid-level interviews lean heavily here, usually with a scenario rather than a definition.

How do you optimize a slow React Native app?

Work out where the time actually goes before changing anything. The common causes, roughly in order of how often they turn out to be the problem:

  • Unnecessary re-renders: Wrap components in React.memo, memoize expensive computations with useMemo, and stabilize callbacks with useCallback so child components do not re-render on every parent update. Worth noting that memoizing everything has its own cost, so profile first.
  • List rendering: Replace ScrollView with FlatList for anything long, since ScrollView renders every child immediately. Set keyExtractor, and provide getItemLayout when row heights are fixed so the list can skip measurement. For very large or complex lists, FlashList from Shopify generally outperforms FlatList.
  • Animations on the JavaScript thread: Pass useNativeDriver: true to the Animated API so the animation runs on the native thread, or use react-native-reanimated, which executes animation logic natively through worklets and keeps running smoothly even when JavaScript is busy.
  • Images: Resize to display dimensions rather than shipping full-resolution assets, use react-native-fast-image for caching, and lazy load anything below the fold.
  • Startup time: Confirm Hermes is enabled, and check whether any heavy native modules initialize at launch that could be deferred.

What is the difference between the JavaScript thread and the UI thread?

React Native runs your JavaScript on a separate thread from the one rendering the UI. The UI thread handles native rendering and gesture responses, so it must stay free to maintain 60fps.

Blocking the JavaScript thread with a heavy computation does not freeze rendering outright under the New Architecture, but it does stop your components from responding, which users experience as a frozen app.

It is best to move heavy work to native modules, break it into chunks, or defer it with InteractionManager until animations finish.

How do you find a performance problem rather than guessing at it?

Profile before optimizing. React DevTools Profiler shows which components re-render and how long each render takes. Flipper and the Hermes profiler give you a flame graph of JavaScript execution. On the native side, Xcode Instruments and Android Studio Profiler show memory and CPU.

Candidates who jump straight to solutions when asked this tend to get pushed on it, since the answer interviewers want starts with measurement.

How do you handle heavy computation?

You’ve got a couple of options. In roughly increasing order of effort, you can:

  1. Break the work into chunks and yield between them.
  2. Defer it with InteractionManager so it runs after animations complete.
  3. Move it into a worklet with Reanimated if it relates to animation.
  4. Implement it in a native module through JSI where the performance gap justifies the complexity.

Navigation, data and storage

How do you handle navigation?

React Navigation is the standard library. Install the core package plus the navigator you need, define your screens, and wrap everything in a NavigationContainer.

The common navigator types are stack for pushing screens onto a history, tab for bottom or top tab bars, and drawer for a slide-out menu. These compose, so a tab navigator whose tabs each contain a stack is a normal pattern.

Expo Router is worth knowing about as the file-based alternative, where your directory structure defines your routes in the way Next.js handles web routing.

How do you handle offline storage?

Depends entirely on what you are storing.

AsyncStorage handles simple unencrypted key-value data like user preferences. MMKV has largely replaced it for performance-sensitive cases, since it is substantially faster and supports synchronous reads.

Structured data that needs querying calls for a database. WatermelonDB, Realm, or SQLite through react-native-quick-sqlite all work, with the choice usually coming down to how much data you hold and whether you need reactive queries.

Anything sensitive needs encrypted storage, covered below.

How do you fetch and cache server data?

Most teams have moved past writing useEffect plus fetch by hand. TanStack Query or RTK Query handle caching, background refetching, retry logic, and loading states, which removes a large amount of code that tends to be subtly wrong when written manually.

An interviewer asking this often wants to hear you distinguish server state from client state, since the two have genuinely different lifecycles.

Security

These come up everywhere, and in fintech interviews they come up early.

How do you store sensitive data securely in React Native?

Not in AsyncStorage, which is the answer most interviewers are listening for. AsyncStorage writes unencrypted data to the device filesystem, readable on a rooted or jailbroken device and sometimes recoverable from backups.

Tokens, credentials, and personal data belong in platform secure storage: the iOS Keychain and the Android Keystore. react-native-keychain wraps both behind one API. For encrypted bulk storage, MMKV supports encryption at rest.

What other security issues come up in mobile apps?

Several worth being able to discuss:

  • Secrets in the bundle. Anything in your JavaScript bundle can be extracted from the app package. API keys in environment variables compiled into the build are not secret.
  • Certificate pinning, which prevents interception of your API traffic through a proxy with a trusted root certificate installed.
  • Jailbreak and root detection, common in banking apps, usually paired with a decision about whether to block or just warn.
  • Deep link validation, since an unvalidated deep link can be used to drive the app into unintended states.
  • Code obfuscation and tamper detection for higher-risk applications.

What does React Native security look like in a fintech app specifically?

This question separates general mobile developers from people who have shipped financial products, and fintech teams ask it deliberately.

A banking or payments app layers several things most consumer apps do not:

  • Biometric authentication through Face ID or fingerprint, with a secure fallback and careful handling of the case where biometrics change on the device
  • Session management with short-lived tokens, refresh rotation, and automatic logout after inactivity
  • Transaction signing, where a payment gets cryptographically signed on-device rather than simply submitted
  • Certificate pinning, which is close to mandatory rather than optional
  • Screenshot and screen-recording prevention on screens showing balances or card numbers, using FLAG_SECURE on Android and the equivalent iOS handling
  • PCI DSS scope management, usually meaning card details are tokenized through a provider SDK so they never touch your application code

It’s not uncommon, and definitely recommended, for an interviewer to follow up by asking how you would keep card data out of PCI scope. The expected answer involves a payment provider’s SDK capturing the details directly, so your app handles a token rather than a PAN.

Candidates who can speak to compliance constraints alongside the code tend to stand out considerably in this sector, since the overlap between strong React Native developers and people who have worked under financial regulation is fairly thin.

Testing, deployment and tooling

How do you test a React Native app?

Usually, there are three layers.

  • Jest handles unit tests for logic and hooks.
  • React Native Testing Library covers component tests, querying by what a user would see rather than by implementation detail.
  • Detox or Maestro run end-to-end tests against a real build on a simulator or device.

Interviewers sometimes ask what you would prioritize with limited time. A reasonable answer puts unit tests on business logic first, since those break most often and cost least to write.

How do you ship updates without going through app review?

Over-the-air updates let you push JavaScript changes directly. Expo Updates through EAS handles this for Expo projects, and react-native-code-push has been the common alternative, though Microsoft’s hosted service has been retired and teams have been migrating off it.

However, there is an important constraint that you need to keep in mind here. OTA updates can only change JavaScript and assets. Anything touching native code requires a new binary through the app stores.

Both Apple and Google permit OTA updates within limits, and pushing something that materially changes the app’s purpose risks a policy problem.

How do you debug a React Native app?

The debugging story has changed, so answers vary by version. Current React Native ships with a built-in debugger based on Chrome DevTools, reachable from the dev menu, which replaced the older remote debugging approach that ran your JavaScript in the browser.

For crashes in production, Sentry, Bugsnag, or Firebase Crashlytics collect stack traces from real users. Source maps need uploading for those traces to be readable, which candidates frequently forget to mention.

What are the benefits and drawbacks of Expo?

Expo removes most of the native setup work, handles builds through EAS, manages updates, and gives you a large set of well-maintained modules. React Native’s own docs now recommend it as the default starting point.

The historical drawback, that you could not use arbitrary native code, has largely gone away.

Development builds and config plugins let you add native dependencies while staying in the Expo ecosystem. What remains is a somewhat larger app size, dependence on Expo’s release cadence for SDK upgrades, and the occasional library that needs manual configuration.

Ejecting to bare workflow is still possible, though the newer prebuild model makes it less often necessary than it used to be.

Scenario and system design questions

Senior interviews tend to move away from definitions toward problems.

An app crashes intermittently, and you cannot reproduce it. How do you investigate?

Start with crash reporting data, since intermittent problems usually have a pattern visible in aggregate even when they resist local reproduction. Group the crashes by device model, OS version, and app version.

Memory-related crashes cluster on older devices. Race conditions cluster on faster ones.

Then look at what the traces have in common. If they point into a native module, check whether it is New Architecture compatible, since partial compatibility causes exactly this kind of intermittent failure.

Add breadcrumb logging around the suspect area and ship it, then wait for data rather than guessing.

How would you architect a large React Native app across several teams?

A reasonable answer covers feature-based directory structure rather than grouping by file type, a shared component library with its own versioning, clear boundaries so teams do not reach into each other’s internals, and a single source of truth for design tokens.

Outside of just structure, it’s also a good idea to mention the operational side.

CI that runs tests and builds on every pull request, a release train rather than ad-hoc releases, feature flags so incomplete work can merge safely, and a strategy for keeping React Native versions current rather than falling three years behind and facing a painful migration.

How do you handle background tasks?

This is where React Native’s cross-platform abstraction leaks most, and interviewers know it. iOS and Android have genuinely different background execution models, so the honest answer acknowledges that rather than claiming one API covers it.

On Android, WorkManager, through a library like react-native-background-fetch, handles deferred work.

iOS restricts background execution much more tightly, offering background fetch with no timing guarantee, background processing tasks, and silent push notifications as a way to wake the app.

Anything requiring reliable scheduled execution usually ends up server-driven through push rather than handled on-device.

All of this can be incredibly overwhelming if you do not have the background in React Native required to understand these concepts yourself.

That’s where a company like Trio comes in. We can help connect you with pre-vetted fintech developers so that you can get all your development needs taken care of without needing to wait several weeks to go through the entire hiring process.

Request a consult.

Frequently Asked Questions

What are the most common mistakes candidates make?

The most common mistakes candidates make in React Native interviews are describing the Bridge as current, saying virtual DOM, reaching for Redux reflexively without considering whether the problem needs it, and answering performance questions with solutions before mentioning measurement. On the softer side, candidates frequently describe what a technology does rather than a time they used it, which gives an interviewer nothing to probe. Having two or three specific production problems you can walk through tends to be worth more than broad familiarity with the API surface.

How do I prepare for a React Native interview at a fintech company?

To prepare for a React Native interview at a fintech company, add security and compliance to whatever you were already preparing. Know why AsyncStorage is unsuitable for tokens and what to use instead; be able to discuss certificate pinning, biometric authentication, session handling, and screenshot prevention on sensitive screens. Understanding how card data gets tokenized through a provider SDK to stay out of PCI DSS scope is worth knowing even if you have not implemented it. Fintech teams also probe reliability more than most, so expect questions about offline behaviour, retry logic, and what happens when a payment request times out with an uncertain outcome.

Should I learn Expo or bare React Native for interviews?

You should learn both Expo and bare React Native for interviews, with Expo as the primary. React Native’s official documentation now recommends Expo as the starting point for new projects, and most new work uses it. Understanding bare React Native still matters, since plenty of production codebases predate the recommendation and interviewers often ask about the trade-offs. Being able to explain when you would choose one over the other is more useful than being fluent in only one.

What is the difference between junior, mid-level, and senior React Native interview questions?

Junior interviews focus on fundamentals: components, props and state, hooks, basic navigation, and core components. Mid-level moves to performance optimization, platform-specific handling, state management choices and their trade-offs, and debugging. Senior interviews lean on architecture and judgment, covering native module design, release strategy, large-codebase structure, and open-ended scenarios where the interviewer wants to see how you reason rather than whether you know a specific API.

Does React Native use a virtual DOM?

No, React Native has no DOM, so there is nothing to shadow with a virtual one. It maintains a shadow tree on the native side that mirrors your component hierarchy, computes layout with Yoga, and applies the result to real native views. The idea is similar in spirit to the virtual DOM, which is why the confusion persists, but saying “virtual DOM” in an interview marks you as working from outdated material.

Do I still need to know about the React Native Bridge?

Yes, you still need to know about the React Native Bridge as history. The Bridge was removed from React Native, so you will not work with it in a current codebase, but interviewers ask about it to check that you understand what problem JSI solves. Be able to explain that the Bridge was an asynchronous, serialized message queue, that serialization and the lack of synchronous access created the bottleneck, and that JSI replaced it by exposing native objects directly to JavaScript.

What should I expect in a React Native interview in 2026?

In a 2026 React Native interview, expect the New Architecture to come up early, since it is the clearest way to tell whether a candidate’s knowledge is current. Beyond that, interviews typically cover React fundamentals and hooks, performance under list rendering and animation, navigation, state management, and native module integration. Senior rounds add system design, release process, and scenario questions about debugging production issues. Security questions appear in most interviews and dominate in fintech.

Alex Kugell
Alex Co-founder

10 Years of Experience

Fintech leaders work with Alex to build engineering teams that scale securely and move fast. With over a decade in software outsourcing, he helps companies hire high-performing developers suited for regulated environments and complex financial systems. After co-founding Trio with his partner Daniel, Alex now focuses on helping fintech teams hire top software talent from Latin America and shares practical insights drawn from real hiring and delivery experience.

Expertise

  • JavaScript
  • NGX
  • HTML
  • Node.js
  • Vue.js

Choose what you share. Your choice lasts for six months, and you can change it at any time through Cookie settings.

Separately, Cloudflare provides cookieless counts of public page visits and page performance. This measurement runs independently of the cookie choices below and respects your browser’s Do Not Track and Global Privacy Control signals. It does not collect form entries.

Essential Always on

Security verification, form submission, and remembering your privacy preferences.

See how Google uses information. These preferences do not subscribe or unsubscribe you from emails. Use the email subscription options or the unsubscribe link in an email.

Talk to Trio
A CONVERSATION STARTS HERE

Let’s talk about your team.

Connect with Trio on LinkedIn to discuss your hiring plans.

Please use your company email to continue.

Prefer a call? Schedule an intro call