A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Foundations Start here
F1. The Mobile Landscape
Beginner · 45 min
The first real decision is native vs cross-platform, and it shapes everything after. Learn the map — native (Swift/SwiftUI, Kotlin/Jetpack), cross-platform (React Native, Flutter), and where each wins — plus what makes mobile fundamentally different from the web: constrained devices, app-store gatekeepers, and users who are offline on a train.
Skills: Native vs cross-platform · iOS & Android ecosystems · React Native vs Flutter · Why mobile is different
Build it: A startup needs one app on iOS and Android, fast, with a small team. Argue native vs cross-platform and pick one.
F2. A Mobile Language
Beginner · 55 min
You need one language deep enough to be productive. Learn the essentials of your chosen stack — Swift, Kotlin, or TypeScript for React Native — with a focus on the mobile-specific parts: optionals and null safety, value vs reference types, and the memory model, because a leak or a retain cycle shows up fast on a phone.
Skills: Swift / Kotlin / TS · Null safety & optionals · Value vs reference · Memory model
Build it: Explain how a retain cycle (or memory leak) causes a mobile app to slow down and crash over a long session.
F3. UI Fundamentals
Beginner · 50 min
Mobile UI is declarative now. Learn to build screens with SwiftUI, Jetpack Compose or React Native — components, layout systems (flexbox, constraints), and the platform design languages (Human Interface Guidelines, Material) — plus responsive layout across a dozen screen sizes and the notch, so your app looks native, not ported.
Skills: Declarative UI · Layout systems · HIG & Material · Responsive across devices
Build it: A layout looks perfect on your phone and broken on a small one. Name the layout mistake and the fix.
F4. State Management
Intermediate · 50 min
Where state lives and how it flows is the heart of an app’s complexity. Learn local vs shared vs global state, unidirectional data flow, and the platform patterns (Observable/StateFlow, hooks, Redux-likes) — and why "just put it in a global" turns into the bug you can never quite reproduce three months later.
Skills: Local vs global state · Unidirectional flow · Observable / hooks · Avoiding state sprawl
Build it: A toggle on one screen mysteriously flips on another. Explain the shared-state bug and how a single source of truth fixes it.
F5. Navigation & Structure
Intermediate · 45 min
Apps are graphs of screens with a back button users trust. Learn navigation — stacks, tabs, modals, deep links — and how to structure an app so screens, state and data flow stay separable as it grows past the tutorial, plus deep linking so a URL or notification can drop the user exactly where you want them.
Skills: Stacks, tabs, modals · Deep linking · App structure · Navigation state
Build it: A push notification should open a specific order screen from a cold start. Sketch how deep linking makes that work.
F6. Networking & Data
Intermediate · 50 min
A phone’s network is hostile: slow, flaky, and gone in a tunnel. Learn to call REST and GraphQL APIs, serialize and cache responses, handle loading and error states as first-class UI, and design for the reality that any request can hang or fail — because on mobile, the happy path is the rare one.
Skills: REST & GraphQL clients · Serialization & caching · Loading & error states · Designing for flaky networks
Build it: A request hangs on a bad connection with a spinner forever. Describe the timeout + retry + UI behavior you’d ship instead.
Building Apps The craft
T1. Local Storage
Intermediate · 50 min
Real apps keep data on the device. Learn the storage ladder — key-value (UserDefaults/SharedPreferences) for settings, files for blobs, and an on-device database (SQLite, Core Data, Room) for structured data — and how to choose, migrate a schema across app updates, and keep secrets in the keychain, not a plaintext file.
Skills: Key-value & files · On-device SQLite · Schema migrations · Secure storage (keychain)
Build it: You add a field to a stored model in v2. Explain what happens to a user upgrading from v1 without a migration.
T2. Async & Concurrency
Advanced · 55 min
The UI thread is sacred: block it and the app freezes. Learn structured concurrency — async/await, coroutines, the main-vs-background thread rule — so heavy work (network, disk, image decode) happens off the main thread and the interface stays at 60fps while it does, which users feel as "this app is fast."
Skills: async/await & coroutines · Main vs background thread · Never block the UI · Cancellation
Build it: A list stutters while images load. Explain which work is on the wrong thread and how you’d move it.
T3. Platform APIs
Advanced · 50 min
The device is the point — camera, GPS, push, biometrics, sensors. Learn to use platform APIs and, harder, to handle the permission model gracefully: ask at the right moment, degrade when denied, and respect that every permission prompt is a small trust negotiation the user can, and will, say no to.
Skills: Camera, GPS, sensors · Push notifications · The permission model · Graceful degradation
Build it: A user denies location permission. Describe how a maps feature should behave — without nagging or breaking.
T4. Testing Mobile
Advanced · 55 min
Mobile testing has its own pyramid and its own pain. Learn unit tests for logic, snapshot tests for UI, and end-to-end tests on real devices and emulators (XCUITest, Espresso, Maestro/Detox) — plus the device matrix problem, where the same code must be verified across OS versions and screen sizes you don’t own.
Skills: Unit & snapshot tests · E2E on device · Emulators vs real devices · The device matrix
Build it: A gesture works on the emulator but fails on a real phone. Name two reasons real-device testing catches what emulators miss.
T5. Performance & Memory
Advanced · 50 min
On a phone, performance is battery, heat and whether the app gets killed in the background. Learn to profile with the platform tools, hit a smooth 60fps by avoiding jank and overdraw, trim memory and app size, and treat battery drain as a first-class bug — the kind that gets you one-starred, not filed.
Skills: Profiling tools · 60fps & jank · Memory & app size · Battery as a bug
Build it: Users report the app drains battery overnight. List the usual suspects (wakeups, location, polling) and how you’d confirm the culprit.
T6. Offline-First & Sync
Advanced · 55 min
The best mobile apps work in a tunnel. Learn offline-first architecture — a local database as the source of truth, an outbox of pending writes, optimistic UI, and background sync — plus the hard part: conflict resolution when the same record was edited on two devices while both were offline.
Skills: Local-first source of truth · Optimistic UI & outbox · Background sync · Conflict resolution
Build it: The same note is edited offline on a phone and a tablet, then both reconnect. Describe two ways to resolve the conflict.
Shipping Get it into pockets
P1. App Architecture
Advanced · 50 min
A growing app needs a structure that keeps UI, logic and data separable. Learn the mobile architecture patterns — MVVM, MVI, unidirectional/Redux-style flows, clean layering — and how to pick one that fits the team and the app’s size, so features can be added and tested without every change rippling through the whole codebase.
Skills: MVVM & MVI · Layered architecture · Testable structure · Right-sizing the pattern
Build it: A junior asks "why not just put the network call in the view?" Give the concrete cost that answers them.
P2. Mobile CI/CD
Advanced · 50 min
Mobile release engineering has extra friction: signing, provisioning, and store review. Learn to automate builds and tests in CI, manage code signing and certificates without pain, and ship to testers via TestFlight or an internal track — because manual mobile releases are slow, error-prone, and the first thing a serious team automates.
Skills: CI builds & tests · Code signing · Fastlane automation · Beta distribution
Build it: Releases take a day of manual clicking and one person knows how. List the three steps you’d automate first.
P3. Release & App Stores
Advanced · 50 min
The store is a gatekeeper you don’t control. Learn the review process and its common rejections, staged and phased rollouts, and how to ship a fix fast when a release is bad — plus the reality that once a version is out, users on it are yours to support until they upgrade, so a bad release lingers.
Skills: Store review & rejections · Phased rollouts · Hotfix strategy · Supporting old versions
Build it: A release has a crash affecting 5% of users. Explain your options — phased rollout halt, hotfix, forced update — and their trade-offs.
P4. Observability & Crashes
Advanced · 50 min
You can’t attach a debugger to a phone in a user’s pocket. Learn mobile observability — crash reporting (Crashlytics, Sentry), symbolicated stack traces, analytics and performance monitoring, and remote logging — so a crash that happens to a stranger on the other side of the world becomes a stack trace and a fix, not a mystery one-star review.
Skills: Crash reporting · Symbolication · Analytics & perf monitoring · Remote logging
Build it: A crash spikes after a release but you can’t reproduce it. Explain how symbolicated crash reports point you to the line.
P5. Security & Privacy
Advanced · 50 min
Mobile apps carry sensitive data through a hostile environment. Learn the essentials — secure storage and the keychain, certificate pinning against man-in-the-middle, not trusting the client, and the privacy rules (App Tracking Transparency, data-safety labels) that stores now enforce — because a leaked token or a privacy violation is a headline, not a ticket.
Skills: Secure storage & keychain · Certificate pinning · Never trust the client · Privacy & tracking rules
Build it: An app stores an API token in plaintext local storage. Explain the risk on a rooted device and the correct fix.
P6. The Mobile Career
Advanced · 45 min
Mobile is a deep specialty with a shifting center of gravity. Learn where the craft is going — cross-platform maturing, more on-device ML and AR, and the eternal native-vs-cross-platform debate — and how to grow from shipping screens to owning an app’s architecture, performance and release process end to end.
Skills: Where mobile is heading · On-device ML & AR · Depth vs breadth · Growth to app ownership
Build it: Write the six-month plan that takes you from building features to owning your app’s release pipeline and performance budget.