React Native Mastery Path¶
React Native lets you write a mobile app in TypeScript and React and ship it as a real native app
on iOS and Android. It does not draw HTML in a web view: when you render <Text>, a genuine
UILabel-backed view appears on iOS and a TextView-backed one on Android. That is the promise and
the catch at the same time. You get one codebase and the React model you may already know, but you
are now responsible for things the web never asked of you — safe areas and notches, the software
keyboard covering your form, permissions, app signing, store review, and a UI thread that drops
frames if you make it wait.
This course teaches React Native the way it is built today: with Expo as the toolchain, TypeScript throughout, Expo Router for navigation, and the New Architecture (JSI, Fabric, TurboModules) as the default runtime. It assumes you know React fundamentals — components, props, state and hooks. If you don't, do the first two levels of the React Mastery Path first; this course links there rather than re-teaching hooks, and spends its time on what is different on mobile.
Level 1 covers the foundations: how React Native turns components into native views, setting
up an Expo project, the core components, StyleSheet, Flexbox as React Native interprets it,
touch handling with Pressable, text input, virtualized lists, safe areas and platform
differences, and debugging — ending with a habit tracker. Level 2 is navigation, state and
data: stacks, tabs and modals, file-based routing with Expo Router, params and deep links, app
state with Context and Zustand, server state with TanStack Query, local persistence with
AsyncStorage, SecureStore and SQLite, forms with React Hook Form and Zod, assets and fonts, and the
keyboard — ending with an offline-friendly recipe book. Level 3 goes native: the threading
model and the New Architecture, camera, location and haptics, permissions, notifications,
Animated and Reanimated, gestures, accessibility, writing your own native module with the Expo
Modules API, and development builds with config plugins — ending with a field-notes app.
Level 4 is production: profiling jank, tuning big lists, component tests with Jest and React
Native Testing Library, end-to-end tests with Maestro and Detox, mobile security, EAS Build and
code signing, store submission, over-the-air updates, crash reporting — and a capstone that takes
one app all the way to a release candidate.
Every lesson has a How It Actually Works section — why a FlatList only mounts what is near
the viewport, why a Reanimated worklet keeps animating while your JavaScript is busy, how
Pressable decides a touch was a press and not a scroll, what expo prebuild writes into the
ios/ and android/ folders, and why an over-the-air update can change your JavaScript but never
your native code.
Versions and what was actually run
When this course was written, npm view reported Expo SDK 57, and a fresh
create-expo-app project pinned react-native 0.86 and React 19.2 (Expo SDKs pin a
specific React Native release, which can trail the newest one on npm). React Native ships a
minor release every few months and Expo an SDK roughly three times a year, so check
the Expo changelog before you start — the concepts here move far
more slowly than the version numbers.
Code samples were type-checked and the logic-only pieces (reducers, validators, sync queues) were executed with Jest in a real SDK 57 project. Anything that needs a phone, a simulator, an Apple Developer account or a Google Play Console — camera capture, push delivery, store submission — is described faithfully, and this course says plainly when a step is something you must run on your own device. No device output, benchmark or timing has been invented.
How the program is organized¶
| Level | Focus | Modules | What you can do after |
|---|---|---|---|
| 1 · Foundations with Expo | Core components, styling, layout, touch, lists, debugging | 10 | Build a polished single-screen app that works on both platforms |
| 2 · Navigation, State & Data | Expo Router, state, TanStack Query, storage, forms | 10 | Build a multi-screen, data-driven app that works offline |
| 3 · Native Capabilities & Polish | Architecture, device APIs, animation, gestures, a11y, native modules | 10 | Use the hardware, animate at 60 fps and extend the platform |
| 4 · Production & Shipping | Performance, testing, security, EAS, stores, OTA, monitoring | 10 | Ship, update and support an app in both stores |
Each level has 9 teaching modules plus a hands-on project (module 10), for 40 lessons total.
How to use this site¶
- Run everything on a real phone as early as possible. Expo Go or a development build on your own device shows you keyboard, notch and performance behaviour that a desktop browser never will.
- Type the code yourself. Most lessons are one screen of code; small enough to type, and typing it is where the details stick.
- Test on both platforms. Many bugs in this course's "common mistakes" sections only appear on one of iOS or Android. If you only have one, say so in your project notes and get the other checked before shipping.
- Do the projects. Modules 10, 20, 30 and the capstone build on each other in difficulty and are where the separate lessons become an app.
More from the Mastery Path series¶
Free, structured, module-wise training across 82 other languages, platforms and disciplines:
Languages
Web Frameworks
Mobile
Testing & QA
Security
Cloud Platforms
Data & Analytics
AI / ML / LLM
Embedded Systems
Leadership & Management
Professional Skills
Careers & Interviews
Process & APIs
Infrastructure & Ops