Junior → Architect → Beyond
iOS Engineer Roadmap
A level-graded path through everything in this guide. Each stage lists what you can already do and what to learn next — and every flashcard is tagged with its level so you can drill exactly where you are.
- 1
Junior
Build & ship screens with guidance.
You build screens and ship features with guidance. The goal here is fluency in the fundamentals — Swift syntax, SwiftUI views, state, lists, navigation, and fetching data — so you can deliver a working screen end to end in Xcode.
You can already
- ✓Write Swift comfortably: optionals, structs vs classes, enums, closures, and value semantics.
- ✓Build SwiftUI screens from views, modifiers, stacks, and List, and drive them with @State and @Binding.
- ✓Navigate with NavigationStack and present sheets; pass data between screens.
- ✓Call a REST API with URLSession and async/await, decode JSON with Codable, and handle loading / error / empty states.
- ✓Run and debug an app on the simulator and a device from Xcode.
Level up by
- →Observable models: @Observable / ObservableObject and where state should live (view vs model).
- →Swift Concurrency basics — async/await, Task, and not blocking the main actor.
- →MVVM: pull logic out of views into testable view models.
- →Write your first unit tests with XCTest (or Swift Testing) and a UI test.
Drill the flashcards filtered to Junior, plus the Swift and SwiftUI categories. Read study topics 01, 02, 03, and 06. - 2
Mid
Own features end-to-end: state, data, tests.
You own features end to end — state, data, persistence, and tests — with little hand-holding. The goal is depth across the everyday iOS toolkit and the start of performance and concurrency awareness.
You can already
- ✓Model state cleanly with the Observation framework (@Observable), @Environment, and clear data flow.
- ✓Separate UI from logic with MVVM; inject dependencies instead of hard-coding singletons.
- ✓Persist data with SwiftData or Core Data, and cache network responses.
- ✓Use structured concurrency: async let, task groups, and @MainActor for UI updates.
- ✓Write meaningful unit tests and a few UI tests; read a crash report and a basic Instruments trace.
Level up by
- →Swift 6 strict concurrency: actors, Sendable, isolation, and fixing data races at compile time.
- →Performance: diffing in SwiftUI, identity, lazy stacks, image/memory budgets, and Instruments deep-dives.
- →UIKit interop — UIViewRepresentable, hosting controllers — and when to drop down to UIKit.
- →Architecture patterns beyond MVVM (unidirectional / TCA-style) and modularizing with SPM.
Drill Mid + Senior flashcards across Concurrency, Data & Networking, and Testing. Read study topics 05, 07, 08, and 10, then try a coding prompt. - 3
Senior
Concurrency, performance, architecture & security depth.
You're the person who makes the hard calls: concurrency correctness, performance under load, native depth, and security. You can justify trade-offs and mentor others, and you own quality from the simulator to the App Store.
You can already
- ✓Reason about Swift 6 data-race safety: actor isolation, Sendable, @MainActor, and async boundaries.
- ✓Diagnose and fix performance issues with Instruments (Time Profiler, Allocations, SwiftUI, Hangs).
- ✓Bridge SwiftUI and UIKit both ways, and integrate native frameworks confidently.
- ✓Set up CI/CD (Xcode Cloud or Fastlane), signing, TestFlight, and a repeatable release process.
- ✓Handle security and privacy: Keychain, biometrics, App Transport Security, and privacy manifests.
Level up by
- →System design for mobile: modular architecture, offline-first sync, and feature-flagged rollouts.
- →Platform leverage: build tooling, SwiftLint/format, shared design systems, and reusable Swift packages.
- →Deep release engineering: phased releases, staged rollouts, and crash/observability pipelines.
- →Lead technical decisions and write the ADRs the team will follow.
Drill Senior flashcards across Performance, Security, and CI/CD & Tooling. Read study topics 09, 12, 13, and 14, plus the Architecture deep dives, then try a system-design prompt. - 4
Architect
System design, modularization, platform & team leverage.
You design systems, not just features. You set the architecture, the module boundaries, and the platform decisions that give a whole team leverage — and you keep an app shippable as it scales to many engineers and millions of users.
You can already
- ✓Design a modular, multi-package app: clear boundaries, dependency direction, and feature isolation.
- ✓Choose architecture (MVVM, unidirectional/TCA, Clean) per the team and product, and defend the trade-offs.
- ✓Own build and release at scale: caching, parallel CI, code signing strategy, and phased rollouts.
- ✓Set cross-cutting standards: observability, accessibility, localization, and security posture.
- ✓Make platform bets — adopt new APIs deliberately while keeping a sane minimum-deployment target.
Level up by
- →Push into on-device intelligence: Core ML pipelines and Apple Intelligence integration.
- →Influence beyond the codebase: hiring bar, technical strategy, and developer experience.
- →Contribute to the ecosystem — open source, Swift Evolution discussions, and conference talks.
Live in the Architecture deep dives and the Architect flashcards. Read study topics 11 and 12, and rehearse the system-design prompts and pitches out loud. - 5
Beyond
Frontier: on-device AI and pushing the platform.
The frontier: pushing the platform itself. On-device AI, new modalities, and being early — and credible — on what Apple ships next, from Apple Intelligence to spatial computing.
You can already
- ✓Integrate Core ML, Vision, Natural Language, and Speech for on-device, private inference.
- ✓Adopt Apple Intelligence and on-device foundation models thoughtfully, with graceful fallbacks.
- ✓Profile and shrink models, and reason about latency, memory, and battery for ML on device.
- ✓Prototype with new platforms and APIs early, and ship behind flags.
Level up by
- →Stay current with each WWDC and turn new APIs into shipped, differentiated features.
- →Share what you learn — write, speak, and open-source the hard parts.