Advanced React Native Techniques and Deployment Course

Lesson 1 • Core Architecture and Component Model

Examine the JavaScript bridge, native thread model, and component hierarchy. Understanding this architecture guides performance decisions in later chapters.

Lesson 2 • State Management with Hooks

Apply useState, useEffect, and useReducer to manage local component state. These patterns underpin every stateful feature built throughout the course.

Lesson 3 • Setting Up the Development Environment

Configure Node.js, Watchman, Xcode, and Android Studio for cross-platform development. This foundation ensures all subsequent exercises run without toolchain errors.

Lesson 4 • Debugging and Developer Tools

Use Flipper, React DevTools, and the Metro bundler console to diagnose issues. Effective debugging skills accelerate development in every subsequent chapter.

Lesson 1 • Nested and Conditional Navigation

Compose nested navigators and conditionally render routes based on auth state. This pattern is essential for separating authenticated and public app sections.

Lesson 2 • React Navigation Core Concepts

Install and configure React Navigation, then build stack, tab, and drawer navigators. These primitives form the skeleton of every screen flow in the course project.

Lesson 3 • Navigation Performance Optimization

Apply lazy loading, screen unmounting, and header memoisation to reduce navigation overhead. These optimisations directly improve frame rates on low-end devices.

Lesson 1 • Server State with React Query

Manage remote data fetching, caching, and synchronisation using React Query. This section bridges local UI state and backend data covered in the API chapter.

Lesson 2 • Lightweight State with Zustand

Build minimal global stores using Zustand and compare its trade-offs with Redux. Zustand suits smaller feature modules where Redux overhead is unnecessary.

Lesson 3 • State Persistence and Rehydration

Persist state to AsyncStorage and MMKV, then rehydrate on app launch. Reliable persistence is critical for offline-capable apps built in later chapters.

Lesson 4 • Context API for Scoped State

Use React Context with memoisation to share state within feature boundaries. Context complements global stores by avoiding prop drilling in nested components.

Lesson 1 • Preventing Common Mobile Vulnerabilities

Mitigate reverse engineering, screenshot leakage, and insecure logging in production builds. Proactive hardening reduces exposure to common mobile security threats.

Lesson 2 • Data Encryption and Privacy Controls

Encrypt local databases with SQLCipher and apply data minimisation principles. Encryption at rest protects user data if a device is compromised.

Lesson 3 • Authentication Flows and Token Management

Build login, registration, and token refresh flows using OAuth2 and JWT. Secure token lifecycle management prevents session hijacking in production apps.

Lesson 4 • Secure Storage and Keychain

Store credentials and tokens in the iOS Keychain and Android Keystore using react-native-keychain. Platform-native secure storage prevents credential exposure from file system access.

Lesson 1 • Secure API Communication

Implement token refresh flows, certificate pinning, and secure header management. Security hardening here protects user data in the authentication chapter that follows.

Lesson 2 • Network State Detection

Use NetInfo to detect connectivity changes and adapt UI accordingly. Accurate network state detection is the prerequisite for the offline queue built next.

Lesson 3 • REST API Integration with Axios

Configure Axios instances, interceptors, and retry logic for robust HTTP communication. Centralised Axios setup prevents duplicated error handling across the codebase.

Lesson 4 • GraphQL with Apollo Client

Set up Apollo Client, write queries and mutations, and manage the normalised cache. GraphQL reduces over-fetching compared to REST for complex data graphs.

Lesson 1 • Memoisation and Render Optimisation

Apply React.memo, useMemo, and useCallback to prevent unnecessary component re-renders. These techniques directly reduce JS thread workload on interaction-heavy screens.

Lesson 2 • JavaScript Bundle Optimisation

Apply code splitting, inline requires, and RAM bundle format to reduce startup time. Bundle size directly affects time-to-interactive on first launch.

Lesson 3 • Profiling with Flipper and Hermes

Use the Hermes profiler and Flipper performance plugin to identify CPU and memory hotspots. Profiling before optimising prevents wasted effort on non-bottleneck code.

Lesson 4 • Image and Asset Optimisation

Use FastImage, WebP format, and progressive loading to reduce image render time. Optimised assets lower memory pressure and improve perceived load speed.

Lesson 1 • Understanding the Native Bridge

Trace how JavaScript calls cross the bridge to native code and return asynchronously. This mental model is required before writing any native module code.

Lesson 2 • Writing Android Native Modules in Kotlin

Implement a ReactContextBaseJavaModule in Kotlin and register it in a ReactPackage. Kotlin modules provide access to Android system APIs and hardware features.

Lesson 3 • Writing iOS Native Modules in Swift

Create an RCTBridgeModule in Swift, expose methods, and emit events to JavaScript. Swift modules enable access to iOS-only APIs unavailable in the JavaScript layer.

Lesson 4 • JSI and the New Architecture

Use JSI to call native C++ functions synchronously without bridge serialisation. JSI is the foundation of Fabric and TurboModules introduced in the new architecture.

Lesson 1 • Component Testing with React Native Testing Library

Render components in isolation and assert on user-visible output using RNTL queries. Component tests validate UI behaviour without requiring a running device.

Lesson 2 • Continuous Integration Pipeline Setup

Configure a CI service to run tests, lint, and build on every pull request. Automated CI gates prevent broken code from reaching the main branch.

Lesson 3 • End-to-End Testing with Detox

Write Detox tests that drive a real simulator through complete user flows. E2E tests catch integration failures invisible to unit and component tests.

Lesson 4 • Unit and Integration Testing with Jest

Write unit tests for hooks and utilities and integration tests for Redux slices using Jest. A reliable test suite catches regressions before they reach the CI pipeline.