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.
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.

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:
- Break the work into chunks and yield between them.
- Defer it with InteractionManager so it runs after animations complete.
- Move it into a worklet with Reanimated if it relates to animation.
- 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.

Alex Kugell




