roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for React Native interviews on the New Architecture: components, lists, styling, navigation and native code. Covers Expo and EAS, storage, networking, performance, testing and release.
657 of 657 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 657 new. 0 cut, outside your plan.
React Native comes up on mobile teams shipping one codebase to both stores, on frontend teams whose company also has an app, and in full-stack JavaScript roles. It usually arrives as a practical round first, often a take-home that loads a feed into a list, followed by a conversation about what you built. Middle and senior candidates usually also get a design round set on a phone: an app that works offline, syncs when the network returns and opens the right screen from a notification. The conversation keeps returning to the line between JavaScript and the platform. Why do blank rows appear when you fling a `FlatList`? Why does an `Animated` transition survive a busy JavaScript thread only with the native driver, and why can that driver move a view but not resize it? Why does a notification tap reach the right screen from the background but the home screen after the app was killed? Why is an access token in AsyncStorage a security finding? The levels part ways on depth: whether an answer stays with what the screen shows or goes beneath it. Early-career candidates need the platform's rules straight: strings only inside `<Text>`, flexbox that stacks children in a column by default, long lists that virtualize. From a senior candidate, interviewers want to hear which thread owns a piece of work, what changed when the bridge's serialized messages gave way to direct calls through JSI, how a native module's typed spec is written, and which changes an over-the-air update may carry and which need a new binary.
Threads, JSI, Fabric and Hermes come before any component: the [runtime layers](/topics/mob-react-native-runtime) lead, with [Turbo Modules and Codegen](/topics/mob-react-native-native-modules-bridge) beside them, because most later questions, from a janky animation to a library that will not link, ask which side of that seam the work is on. Tooling follows before any screen is built: setup and upgrades, the debugging loop down to symbolicated crash traces, and [Metro](/topics/mob-metro), whose resolution rules and cache explain builds that break for no visible reason. The middle of the plan is the app a user touches. Core primitives, [virtualized lists](/topics/mob-react-native-lists) and [Yoga's flexbox](/topics/mob-react-native-styling-layout) are where web habits go wrong, and platform-specific code closes that module with the places the two operating systems will not share. [Gestures and motion](/topics/mob-react-native-motion) bring the thread model back, since worklets and UI-thread recognizers keep touch and animation responsive while JavaScript is busy; accessibility sits beside them because a custom gesture is often what a screen reader cannot reach. [Navigation](/topics/mob-react-native-navigation) precedes deep links and [push handling](/topics/mob-react-native-push), both of which end with the navigator routing to a screen, from a cold start as well as a warm one. Data follows: networking, [app state](/topics/mob-react-native-state-data) across backgrounding, then the key-value stores, where the question is what may sit on the device unencrypted. That choice feeds [hardening](/topics/mob-react-native-security), and [speed and memory](/topics/mob-react-native-perf) comes after it because profiling a dropped frame needs the threads, lists and animations met earlier. [Expo](/topics/mob-expo) sits late on purpose: prebuild, config plugins, cloud builds and over-the-air updates are easiest to reason about once you know what lives in the binary and what lives in the bundle. Its SDK modules finish the storage decision the data stretch opened: SQLite when records need queries and migrations, [SecureStore](/topics/mob-expo-secure-store) for anything secret, the file system for what is too large for either. Testing climbs from mocked native modules through Testing Library to [Detox](/topics/mob-detox) driving a real build, and the plan ends with the web port and [store release](/topics/mob-react-native-release).
Coming from React on the web, do not begin at the top. Begin with Screens, Lists & Styling under the by topics study order, and come back to the runtime once you have built a list and watched it stutter. Native iOS or Android developers have the reverse gap: the runtime and Turbo Modules feel familiar, while Metro, Yoga's defaults and the cost of a React re-render are where their answers slip. A week or two out, narrow importance to must know, and expect the take-home's follow-ups to come from lists, navigation, threads and storage; answer those against a screen you have run on a device. Seniors should save hours for what becomes design and incident talk: a Turbo Module spec, push delivery by app state, offline queues, an update that crashes at launch. The plan assumes React itself: hooks, effects and reconciliation appear only where they cost frames on a phone, so if effect cleanup and stale closures still trip you up, the [React roadmap](/roadmaps/react) comes first. Native code goes as far as a module's glue and the platform APIs it wraps; screens built in SwiftUI or Jetpack Compose belong to the [iOS Developer](/roadmaps/ios) and [Android Developer](/roadmaps/android) roadmaps.
React Native comes up on mobile teams shipping one codebase to both stores, on frontend teams whose company also has an app, and in full-stack JavaScript roles. It usually arrives as a practical round first, often a take-home that loads a feed into a list, followed by a conversation about what you built. Middle and senior candidates usually also get a design round set on a phone: an app that works offline, syncs when the network returns and opens the right screen from a notification.
The conversation keeps returning to the line between JavaScript and the platform. Why do blank rows appear when you fling a FlatList? Why does an Animated transition survive a busy JavaScript thread only with the native driver, and why can that driver move a view but not resize it? Why does a notification tap reach the right screen from the background but the home screen after the app was killed? Why is an access token in AsyncStorage a security finding?
The levels part ways on depth: whether an answer stays with what the screen shows or goes beneath it. Early-career candidates need the platform's rules straight: strings only inside <Text>, flexbox that stacks children in a column by default, long lists that virtualize. From a senior candidate, interviewers want to hear which thread owns a piece of work, what changed when the bridge's serialized messages gave way to direct calls through JSI, how a native module's typed spec is written, and which changes an over-the-air update may carry and which need a new binary.
Threads, JSI, Fabric and Hermes come before any component: the runtime layers lead, with Turbo Modules and Codegen beside them, because most later questions, from a janky animation to a library that will not link, ask which side of that seam the work is on. Tooling follows before any screen is built: setup and upgrades, the debugging loop down to symbolicated crash traces, and Metro, whose resolution rules and cache explain builds that break for no visible reason.
The middle of the plan is the app a user touches. Core primitives, virtualized lists and Yoga's flexbox are where web habits go wrong, and platform-specific code closes that module with the places the two operating systems will not share. Gestures and motion bring the thread model back, since worklets and UI-thread recognizers keep touch and animation responsive while JavaScript is busy; accessibility sits beside them because a custom gesture is often what a screen reader cannot reach. Navigation precedes deep links and push handling, both of which end with the navigator routing to a screen, from a cold start as well as a warm one.
Data follows: networking, app state across backgrounding, then the key-value stores, where the question is what may sit on the device unencrypted. That choice feeds hardening, and speed and memory comes after it because profiling a dropped frame needs the threads, lists and animations met earlier.
Expo sits late on purpose: prebuild, config plugins, cloud builds and over-the-air updates are easiest to reason about once you know what lives in the binary and what lives in the bundle. Its SDK modules finish the storage decision the data stretch opened: SQLite when records need queries and migrations, SecureStore for anything secret, the file system for what is too large for either. Testing climbs from mocked native modules through Testing Library to Detox driving a real build, and the plan ends with the web port and store release.
Coming from React on the web, do not begin at the top. Begin with Screens, Lists & Styling under the by topics study order, and come back to the runtime once you have built a list and watched it stutter. Native iOS or Android developers have the reverse gap: the runtime and Turbo Modules feel familiar, while Metro, Yoga's defaults and the cost of a React re-render are where their answers slip.
A week or two out, narrow importance to must know, and expect the take-home's follow-ups to come from lists, navigation, threads and storage; answer those against a screen you have run on a device. Seniors should save hours for what becomes design and incident talk: a Turbo Module spec, push delivery by app state, offline queues, an update that crashes at launch.
The plan assumes React itself: hooks, effects and reconciliation appear only where they cost frames on a phone, so if effect cleanup and stale closures still trip you up, the React roadmap comes first. Native code goes as far as a module's glue and the platform APIs it wraps; screens built in SwiftUI or Jetpack Compose belong to the iOS Developer and Android Developer roadmaps.