React Native Interview Questions (2026)

core components matters in React Native because it changes screen behavior, state ownership, device support, or release safety on React Native apps across Android and iOS.

A product example is verified with Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports. That makes core components concrete instead of a framework definition.

For core components, the practical check is whether a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes reflects the intended behavior and whether Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports confirms it.

hooks is a platform decision in React Native. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

hooks becomes useful when it changes a real choice: safer design, faster execution, clearer ownership, or better failure detection.

FlatList is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

The main risk with FlatList is bridge or native module issues, list performance problems, navigation state bugs, and store build failures; detection of that risk is part of the technical substance.

SectionList connects code to device behavior: the API or pattern and how it behaves during lifecycle, network, or release changes.

SectionList maps back to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, which connects the concept to implementation and release evidence.

SectionList connects one concrete artifact, one measurable signal, and one reason the simpler option may not be enough.

React Navigation matters in React Native because it changes screen behavior, state ownership, device support, or release safety on React Native apps across Android and iOS.

A product example is verified with Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports. That makes React Navigation concrete instead of a framework definition.

In day-to-day work, React Navigation is judged by the result it protects: correctness, reliability, maintainability, cost, security, or user impact.

deep linking is a platform decision in React Native. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

deep linking has a boundary, behavior inside that boundary, and evidence outside it.

native modules is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

native modules is worth discussing only if it changes an action: what to build, what to test, what to monitor, or what to avoid.

TurboModules connects code to device behavior: the API or pattern and how it behaves during lifecycle, network, or release changes.

TurboModules maps back to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, which connects the concept to implementation and release evidence.

The useful distinction for TurboModules is where responsibility sits: code, data, configuration, platform, process, or owner.

Hermes matters in React Native because it changes screen behavior, state ownership, device support, or release safety on React Native apps across Android and iOS.

A product example is verified with Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports. That makes Hermes concrete instead of a framework definition.

Hermes often fails quietly, so the validation should be observable through Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

Expo is a platform decision in React Native. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

Expo is specific: where it applies, where it does not, and what changes the decision.

Metro bundler is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

Metro bundler connects theory to delivery when the explanation includes input, output, owner, risk, and proof.

permissions connects code to device behavior: the API or pattern and how it behaves during lifecycle, network, or release changes.

permissions maps back to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, which connects the concept to implementation and release evidence.

permissions goes beyond definition when it includes the operating constraint and verification step.

gestures matters in React Native because it changes screen behavior, state ownership, device support, or release safety on React Native apps across Android and iOS.

A product example is verified with Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports. That makes gestures concrete instead of a framework definition.

gestures is tied to the problem it solves, not just the tool or syntax that exposes it.

safe areas is a platform decision in React Native. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

The decision around safe areas should be reversible or at least measurable, especially when bridge or native module issues, list performance problems, navigation state bugs, and store build failures is possible.

AppState is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

AppState needs both the normal path and the edge case that breaks it.

For building a React Native screen, the user path, device state, network condition, and release target before choosing the implementation comes first.

building a React Native screen connects to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, and release proof comes from Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

building a React Native screen is complete only when the result is visible in Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports and the next owner can repeat the check.

Handle optimizing FlatList by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

The safe path for optimizing FlatList is small scope, known baseline, controlled change, and a rollback or correction option.

Begin setting up navigation with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if setting up navigation breaks after rollout.

For setting up navigation, the important artifact is a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes; without it, the task is just activity without proof.

For handling deep links, define success in user terms first, then map it to code, logs, build output, and release checks.

Syntax is not enough. The evidence trail is Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

handling deep links preserves the user or system outcome first, then optimizes speed, cost, or convenience.

For requesting permissions, the user path, device state, network condition, and release target before choosing the implementation comes first.

requesting permissions connects to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, and release proof comes from Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

The risk in requesting permissions is bridge or native module issues, list performance problems, navigation state bugs, and store build failures, so the task needs an explicit prevention or detection step.

Handle calling native modules by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

calling native modules usually touches more than one layer, so separate input, processing, output, and ownership before changing anything.

Begin debugging Android build errors with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if debugging Android build errors breaks after rollout.

debugging Android build errors stops at a verified result, not a completed command or a passed local run.

For debugging iOS pod issues, define success in user terms first, then map it to code, logs, build output, and release checks.

Syntax is not enough. The evidence trail is Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

debugging iOS pod issues needs a defined expected output, allowed side effects, and evidence source before execution.

For using Expo config, the user path, device state, network condition, and release target before choosing the implementation comes first.

using Expo config connects to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, and release proof comes from Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

using Expo config needs a negative case as well as the happy path, especially when the failure is expensive or hard to see.

Handle testing components by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

The simplest useful version of testing components is the one that can be reviewed, repeated, and explained from the evidence.

Begin profiling bridge cost with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if profiling bridge cost breaks after rollout.

For profiling bridge cost, document the assumption that matters most because that is where follow-up failures usually start.

For handling offline mode, define success in user terms first, then map it to code, logs, build output, and release checks.

Syntax is not enough. The evidence trail is Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

handling offline mode leaves a trace: test result, log line, metric, report, ticket, or review note.

For building OTA update flow, the user path, device state, network condition, and release target before choosing the implementation comes first.

building OTA update flow connects to a TypeScript mobile screen with navigation, state, native permissions, tests, and release notes, and release proof comes from Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports.

The practical choice in building OTA update flow is often between a quick local fix and a maintainable change that survives the next release.

Handle preparing store builds by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

preparing store builds becomes reliable when setup, execution, validation, and cleanup are separate and visible.

Begin monitoring crashes with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if monitoring crashes breaks after rollout.

monitoring crashes controls blast radius by separating what changes now from what stays unchanged.

For FlatList scroll jank, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

FlatList scroll jank ends with a decision based on Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports, not a guess based on the first symptom.

Handle navigation state resets by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

The first priority in navigation state resets is limiting impact while keeping enough evidence to prove the actual cause.

Treat Android build fails as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

For Android build fails, the useful split is symptom, cause, fix, validation, and prevention.

Debug iOS pods conflict with a device matrix, not one local run. The record must show which device, OS version, and build variant was checked.

The safest fix avoids broad rewrites, untested store changes, and fixes checked only on one emulator.

iOS pods conflict is risky when bridge or native module issues, list performance problems, navigation state bugs, and store build failures; the fix should address that risk directly.

For permission prompt missing, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

The strongest mitigation for permission prompt missing is the smallest change that proves or disproves the suspected cause.

Handle native module crashes by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

native module crashes needs a timeline because order often reveals whether the issue came from data, code, configuration, or process.

Treat deep link opens wrong route as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

For deep link opens wrong route, communication matters because the owner, user impact, and next action must be clear before work spreads.

Debug keyboard covers form with a device matrix, not one local run. The record must show which device, OS version, and build variant was checked.

The safest fix avoids broad rewrites, untested store changes, and fixes checked only on one emulator.

keyboard covers form does not widen into a rewrite until the narrow failure has been reproduced and measured.

For OTA update bug, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

The prevention step for OTA update bug is concrete: a test, monitor, rule, review, runbook, or owner change.

Handle Hermes runtime issue by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

For Hermes runtime issue, a rollback is useful only if it restores the failing behavior and has its own validation check.

Treat device-only layout bug as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

device-only layout bug is evaluated by blast radius, repeatability, customer impact, and confidence in the evidence.

Debug offline request loop with a device matrix, not one local run. The record must show which device, OS version, and build variant was checked.

The safest fix avoids broad rewrites, untested store changes, and fixes checked only on one emulator.

The best fix for offline request loop is one that reduces recurrence, not just the visible symptom.

For app startup delay, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

For app startup delay, the hard part is separating real movement from measurement or environment noise.

Handle accessibility issue by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

accessibility issue preserves a record of what changed, why it changed, and what proved the change worked.

Treat senior React Native architecture review as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Metro logs, native build output, device testing, Flipper or profiler traces, and crash reports is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

The final check for senior React Native architecture review is whether the same failure can be caught earlier next time.