Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path →
18 stations. 3 tracks. From native vs cross-platform and UI, state and navigation through storage, concurrency, platform APIs and offline-first sync, to architecture, CI/CD, app-store release and crash reporting — build apps that live in a pocket, offline, on a battery.
18 stations on 3 ladders, in order — each rung is written assuming the one above it. Mark them off as you go; your progress is saved in this browser.
6 rungs · ~6h · ends at Networking & Data.
F1 · 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.
Build itA startup needs one app on iOS and Android, fast, with a small team. Argue native vs cross-platform and pick one.
✓ CheckpointArgue for native over cross-platform on one concrete app, then argue the opposite for a different one. If the same answer fits both, you have a preference rather than a reason.
F2 · 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.
Build itExplain how a retain cycle (or memory leak) causes a mobile app to slow down and crash over a long session.
✓ CheckpointExplain what an optional actually protects you from, and describe a crash that null safety makes impossible to write in the first place.
F3 · 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.
Build itA layout looks perfect on your phone and broken on a small one. Name the layout mistake and the fix.
✓ CheckpointExplain why a layout that looks right on your simulator is not evidence it is right, and name the device classes that break it.
F4 · 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.
Build itA toggle on one screen mysteriously flips on another. Explain the shared-state bug and how a single source of truth fixes it.
✓ CheckpointPoint at one piece of state in an app you know and justify why it is local rather than global — “it was easier” does not count.
F5 · 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.
Build itA push notification should open a specific order screen from a cold start. Sketch how deep linking makes that work.
✓ CheckpointTrace what has to happen for a deep link to land a user on the right screen with a sensible back stack behind them.
F6 · 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.
Build itA request hangs on a bad connection with a spinner forever. Describe the timeout + retry + UI behavior you’d ship instead.
✓ CheckpointDescribe how your UI should behave on a connection that is slow rather than absent — the case that is far more common and far more often unhandled.
6 rungs · ~6h · ends at Offline-First & Sync.
T1 · 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.
Build itYou add a field to a stored model in v2. Explain what happens to a user upgrading from v1 without a migration.
✓ CheckpointSay which of your app's data belongs in key-value storage, which in SQLite, and which in the keychain — and what goes wrong for each if you pick the wrong one.
T2 · 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."
Build itA list stutters while images load. Explain which work is on the wrong thread and how you’d move it.
✓ CheckpointExplain how work that is not on the main thread can still cause a dropped frame, and where cancellation belongs when a user navigates away mid-request.
T3 · 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.
Build itA user denies location permission. Describe how a maps feature should behave — without nagging or breaking.
✓ CheckpointExplain what your feature does when the user denies the permission it needs, and why “ask again immediately” is the wrong answer.
T4 · 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.
Build itA gesture works on the emulator but fails on a real phone. Name two reasons real-device testing catches what emulators miss.
✓ CheckpointJustify the split between what you test on an emulator and what genuinely requires a real device, and name a bug only hardware would reveal.
T5 · 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.
Build itUsers report the app drains battery overnight. List the usual suspects (wakeups, location, polling) and how you’d confirm the culprit.
✓ CheckpointExplain how a feature that profiles clean can still be a battery bug, and why that never shows up in a frame-rate graph.
T6 · 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.
Build itThe same note is edited offline on a phone and a tablet, then both reconnect. Describe two ways to resolve the conflict.
✓ CheckpointDescribe what happens when the same record is edited on two devices while both are offline — and defend the resolution rule you would pick.
6 rungs · ~5h · ends at The Mobile Career.
P1 · 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.
Build itA junior asks "why not just put the network call in the view?" Give the concrete cost that answers them.
✓ CheckpointExplain what MVVM buys you that plain view code does not, and name the app size below which the pattern costs more than it returns.
P2 · 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.
Build itReleases take a day of manual clicking and one person knows how. List the three steps you’d automate first.
✓ CheckpointExplain why code signing is the step that breaks mobile CI most often, and what a build machine needs that your laptop already quietly has.
P3 · 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.
Build itA release has a crash affecting 5% of users. Explain your options — phased rollout halt, hotfix, forced update — and their trade-offs.
✓ CheckpointExplain why a phased rollout is worth the delay, and what signal you watch before widening it.
P4 · 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.
Build itA crash spikes after a release but you can’t reproduce it. Explain how symbolicated crash reports point you to the line.
✓ CheckpointExplain why an unsymbolicated crash report is close to useless, and what your release pipeline must upload for it to be readable.
P5 · 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.
Build itAn app stores an API token in plaintext local storage. Explain the risk on a rooted device and the correct fix.
✓ CheckpointExplain why any check you enforce only in the app is not a security control, and name what certificate pinning does and does not defend against.
P6 · 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.
Build itWrite the six-month plan that takes you from building features to owning your app’s release pipeline and performance budget.
✓ CheckpointDescribe the difference between shipping features in an app and owning one — and name the responsibility that transfers when you cross that line.
The common questions before you start — how long it takes, whether to follow it in order, and how it stays current.
It runs 18 stations across 3 tracks — roughly ~17h of focused learning, plus the time you spend actually building. It is self-paced, so most people work through it over a few weeks, an evening or a single station at a time.
The tracks are ordered so each station builds on the one before, and following them start to finish is the intended path. But every station also stands alone — if you already have the foundations, jump straight to the part you need.
Yes. The whole roadmap, and every handbook, lab, and challenge it links to, is free and open — no sign-up and no paywall.
It teaches the durable fundamentals of the role first, then the tooling and the AI-era shifts on top — so most of it stays relevant as individual tools churn, and it is revised as the role itself changes.
Anyone stepping into or leveling up in the Mobile Engineer role — whether you are switching in, early-career, or a senior filling gaps. Start where you are; the ladder shows what is left.
See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.