roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepares you for iOS developer interviews, from Swift coding rounds to mobile system design. You cover language depth, the native Apple platform, app architecture, testing, and release tooling.
5016 of 5016 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 5016 new. 0 cut, outside your plan.
Swift usually gets a conversation of its own in an iOS loop, apart from the one about the platform. A recruiter screen and a coding problem solved in Swift come first, then the language conversation. The platform round is usually built around one screen, often a list fed by a JSON endpoint, which you either build at home as a small app or write live while the interviewer watches. Past junior the loop adds a mobile system design round, and behavioral questions come last. The language questions are small and exact. A struct holding a class instance is copied, yet both copies still share the one object. A method written in a protocol extension but not declared as a requirement is dispatched statically, so a conforming type's own version is skipped whenever the value is seen through the protocol. A closure property that mentions `self` keeps a view controller alive after it is dismissed, and `[unowned self]` turns that leak into a crash if the closure runs after its owner is gone. Platform questions take the same shape: a cell that shows another row's image after a fast scroll, because a download finished after the cell was reused; a view model reset whenever its parent redraws, because the child declared it `@ObservedObject` where `@StateObject` would have kept it. A junior answer names the fix. A senior one shows how the bug was found, in the memory graph debugger, an Instruments trace or a symbolicated crash report, and what keeps it from returning, from a unit test to the crash-free rate watched through a phased release.
Two languages head the plan, for different reasons. [Swift](/topics/lang-swift) is the one you write. [Objective-C](/topics/lang-objc) is there because UIKit was designed around its runtime: target-action, optional delegate methods and key-value observing all reach Swift through `@objc`, and a long-lived app keeps Objective-C of its own. The general concepts that follow give Swift's choices something to be compared with. [Memory management](/topics/found-memory-management) sets reference counting beside garbage collection, the comparison candidates from Java or Kotlin are asked to make, and [concurrency](/topics/found-concurrency) supplies the structured tasks, isolation and data races that actors and `Sendable` exist to answer. [Algorithms](/topics/found-dsa) serve the coding round; version control, [Xcode](/topics/dev-xcode) and Swift Package Manager are the tooling the platform code is built inside, with [unified logging](/topics/mob-unified-logging) for reading what a build did on a device no debugger was attached to. The platform takes the long middle of the plan. [SwiftUI](/topics/mob-swiftui) leads with UIKit beside it, since many apps run both in one target. [Combine](/topics/mob-combine) follows, because an `ObservableObject` announces its changes through it and a view model bound with `sink` keeps its subscription only as long as the `AnyCancellable` is held, which is where its retain cycles hide. Persistence runs from [Core Data](/topics/mob-core-data), where a context saved on the wrong queue or a fault fired inside a loop is the usual question, to SwiftData's `@Model` and `ModelContext`. The files an app keeps outside any store close that stretch, with the [Keychain](/topics/mob-keychain) holding the tokens and keys that must never sit in a file or a default. Networking puts [URLSession](/topics/mob-urlsession) beside [HTTP](/topics/proto-http) and REST, so the client and the protocol it speaks are learned together and the questions can be about the protocol itself: what a cache validator saves on a metered connection, which request is safe to repeat when the network drops. GraphQL is read from the app's end of the wire, from the [query a screen sends](/topics/proto-graphql-operations) to a partial response that carries an `errors` array beside its data, and to a normalized cache that keeps one edited record consistent in every list showing it. [Background tasks](/topics/mob-background-tasks) and [notifications](/topics/mob-user-notifications) cover the time the app is off screen, when the system decides whether it runs at all and a push may wake it before the user sees anything. [Universal Links](/topics/mob-universal-links) and [Core Location](/topics/mob-core-location) follow as the two ways the system hands the app a place to go: a verified link it opens instead of Safari, and a position it reports only as far as the user has authorized. The platform groups end on drawing and media, where [Core Animation](/topics/mob-core-animation) explains why the render server composites layers, not views, and why a mask, or a shadow drawn without a precomputed path, costs an offscreen pass and dropped frames. [Accessibility](/topics/found-accessibility) comes after them, written in general terms that UIKit and SwiftUI map onto a label, traits and a value for VoiceOver to read. Architecture turns the plan from the app to the system. [Application architecture](/topics/found-architectural-patterns) holds the MVC to MVVM line, where UIKit's view controller is the textbook class that absorbs everything. General system design precedes [mobile system design](/topics/mob-system-design) because a client answer about offline sync, paged feeds and push assumes you can sketch the backend behind them. That module also follows the app past release, into [staged rollout and crash health](/topics/mob-system-design-rollout-observability), where symbolication is planned before launch rather than found missing in the first crash report. The last stretch is shipping. Linting comes before testing, which starts from the frameworks, [XCTest](/topics/mob-xctest) and Swift Testing with its `@Test` and `#expect` macros, and only then reaches the discipline behind them. [Fastlane](/topics/mob-fastlane) and the pipeline follow, where certificates and provisioning profiles make code signing the step most likely to break, and [TestFlight](/topics/mob-testflight) is where a signed build first reaches people outside the team. Security follows with secure coding and then OAuth as an app meets it: a redirect back from the browser, and [PKCE](/topics/proto-oauth2-pkce), which proves that the app redeeming the code is the one that asked for it, then [AuthenticationServices](/topics/mob-authentication-services), the API that runs that redirect along with Sign in with Apple and passkeys. The plan then steps away from code, to stories for the [behavioral round](/topics/found-behavioral) and to what each stage of a loop is looking for, from the first screen to the decision after the onsite.
An Android or Kotlin developer crossing over knows the design round already; what catches that background is [ARC](/topics/lang-swift-memory-arc), since a tracing garbage collector reclaims a reference cycle and reference counting does not. A developer from the UIKit years should spend the time on SwiftUI's state ownership and on `@MainActor`, actors and `Sendable`, where much of the platform conversation has moved. Weeks out, put the hours where the platform round lives, in SwiftUI state, cell reuse and a request that has to survive a dropped connection, and leave GraphQL for a posting that names it; importance raised to must know with level narrowed to your band does the rest of the cutting. Given months, pick by topics as the study order and take the testing and code-quality modules in the same pass as the platform, not after it: a take-home is read for its tests and its structure before anyone runs it. The platform side of this plan is Apple's alone, with no module on Kotlin or a cross-platform framework. If your team shares business logic with its Android app through Kotlin Multiplatform, that Kotlin and the app it was written for are on the [Android Developer roadmap](/roadmaps/android).
Swift usually gets a conversation of its own in an iOS loop, apart from the one about the platform. A recruiter screen and a coding problem solved in Swift come first, then the language conversation. The platform round is usually built around one screen, often a list fed by a JSON endpoint, which you either build at home as a small app or write live while the interviewer watches. Past junior the loop adds a mobile system design round, and behavioral questions come last.
The language questions are small and exact. A struct holding a class instance is copied, yet both copies still share the one object. A method written in a protocol extension but not declared as a requirement is dispatched statically, so a conforming type's own version is skipped whenever the value is seen through the protocol. A closure property that mentions self keeps a view controller alive after it is dismissed, and [unowned self] turns that leak into a crash if the closure runs after its owner is gone.
Platform questions take the same shape: a cell that shows another row's image after a fast scroll, because a download finished after the cell was reused; a view model reset whenever its parent redraws, because the child declared it @ObservedObject where @StateObject would have kept it. A junior answer names the fix. A senior one shows how the bug was found, in the memory graph debugger, an Instruments trace or a symbolicated crash report, and what keeps it from returning, from a unit test to the crash-free rate watched through a phased release.
Two languages head the plan, for different reasons. Swift is the one you write. Objective-C is there because UIKit was designed around its runtime: target-action, optional delegate methods and key-value observing all reach Swift through @objc, and a long-lived app keeps Objective-C of its own.
The general concepts that follow give Swift's choices something to be compared with. Memory management sets reference counting beside garbage collection, the comparison candidates from Java or Kotlin are asked to make, and concurrency supplies the structured tasks, isolation and data races that actors and Sendable exist to answer. Algorithms serve the coding round; version control, Xcode and Swift Package Manager are the tooling the platform code is built inside, with unified logging for reading what a build did on a device no debugger was attached to.
The platform takes the long middle of the plan. SwiftUI leads with UIKit beside it, since many apps run both in one target. Combine follows, because an ObservableObject announces its changes through it and a view model bound with sink keeps its subscription only as long as the AnyCancellable is held, which is where its retain cycles hide. Persistence runs from Core Data, where a context saved on the wrong queue or a fault fired inside a loop is the usual question, to SwiftData's @Model and ModelContext. The files an app keeps outside any store close that stretch, with the Keychain holding the tokens and keys that must never sit in a file or a default.
Networking puts URLSession beside HTTP and REST, so the client and the protocol it speaks are learned together and the questions can be about the protocol itself: what a cache validator saves on a metered connection, which request is safe to repeat when the network drops. GraphQL is read from the app's end of the wire, from the query a screen sends to a partial response that carries an errors array beside its data, and to a normalized cache that keeps one edited record consistent in every list showing it. Background tasks and notifications cover the time the app is off screen, when the system decides whether it runs at all and a push may wake it before the user sees anything. Universal Links and Core Location follow as the two ways the system hands the app a place to go: a verified link it opens instead of Safari, and a position it reports only as far as the user has authorized. The platform groups end on drawing and media, where Core Animation explains why the render server composites layers, not views, and why a mask, or a shadow drawn without a precomputed path, costs an offscreen pass and dropped frames.
Accessibility comes after them, written in general terms that UIKit and SwiftUI map onto a label, traits and a value for VoiceOver to read.
Architecture turns the plan from the app to the system. Application architecture holds the MVC to MVVM line, where UIKit's view controller is the textbook class that absorbs everything. General system design precedes mobile system design because a client answer about offline sync, paged feeds and push assumes you can sketch the backend behind them. That module also follows the app past release, into staged rollout and crash health, where symbolication is planned before launch rather than found missing in the first crash report.
The last stretch is shipping. Linting comes before testing, which starts from the frameworks, XCTest and Swift Testing with its @Test and #expect macros, and only then reaches the discipline behind them. Fastlane and the pipeline follow, where certificates and provisioning profiles make code signing the step most likely to break, and TestFlight is where a signed build first reaches people outside the team. Security follows with secure coding and then OAuth as an app meets it: a redirect back from the browser, and PKCE, which proves that the app redeeming the code is the one that asked for it, then AuthenticationServices, the API that runs that redirect along with Sign in with Apple and passkeys. The plan then steps away from code, to stories for the behavioral round and to what each stage of a loop is looking for, from the first screen to the decision after the onsite.
An Android or Kotlin developer crossing over knows the design round already; what catches that background is ARC, since a tracing garbage collector reclaims a reference cycle and reference counting does not. A developer from the UIKit years should spend the time on SwiftUI's state ownership and on @MainActor, actors and Sendable, where much of the platform conversation has moved.
Weeks out, put the hours where the platform round lives, in SwiftUI state, cell reuse and a request that has to survive a dropped connection, and leave GraphQL for a posting that names it; importance raised to must know with level narrowed to your band does the rest of the cutting. Given months, pick by topics as the study order and take the testing and code-quality modules in the same pass as the platform, not after it: a take-home is read for its tests and its structure before anyone runs it.
The platform side of this plan is Apple's alone, with no module on Kotlin or a cross-platform framework. If your team shares business logic with its Android app through Kotlin Multiplatform, that Kotlin and the app it was written for are on the Android Developer roadmap.