What is an iOS Developer?
An iOS developer builds apps for Apple devices such as iPhone and iPad. They design screens, handle data, connect to APIs and publish apps on the App Store.
Modern iOS development uses Swift and SwiftUI with Xcode. iOS developers work at product companies, agencies and startups, or build and sell their own apps.
How to use this iOS Developer roadmap
Follow this iOS developer roadmap step by step. Swift comes first, then SwiftUI, then data and publishing.
Build one app throughout, such as a workout log, and improve it with every step.
1Step 1: Swift fundamentals
Learn Swift, Apple’s modern programming language.
What is it?
Swift is a safe, fast language. Optionals make it clear when a value might be missing, which prevents crashes.
What to learn
Optionals are central to Swift. Learn if let and guard let early.
Learn each topic here
Variables and constants
Swift uses let for constants and var for variables. Prefer let whenever a value does not change.
swift
let name = "Sara"
var count = 0
count += 1Optionals
An optional may contain a value or nil. Unwrap safely with if let, guard let or ??.
swift
var nickname: String? = nil
if let nick = nickname { print(nick) }
print(nickname ?? "No nickname")Structs and classes
Structs are value types (copied) and are preferred in Swift; classes are reference types (shared) used when identity matters.
swift
struct Product { let name: String; var price: Double }Enums
Enums define a fixed set of cases and can carry values, perfect for states like loading or error.
swift
enum LoadState { case loading, loaded([Product]), failed(String) }Closures
Closures are blocks of code you pass around, used for callbacks and sorting.
swift
let sorted = products.sorted { $0.price < $1.price }Protocols
Protocols define a set of requirements that types adopt, like interfaces. SwiftUI views conform to the View protocol.
swift
protocol Describable { var summary: String { get } }Example
swift
struct Workout {
let name: String
var minutes: Int
}
let workouts = [Workout(name: "Run", minutes: 30), Workout(name: "Yoga", minutes: 45)]
let total = workouts.reduce(0) { $0 + $1.minutes }
print("Total: \(total) min")This adds up the minutes of all workouts and prints the total.
Helpful resource: The Swift Programming Language
2Step 2: Xcode and app structure
Set up your tools and understand an iOS project.
What is it?
An iOS app starts from an App struct that defines its first screen. Xcode manages code, assets and settings.
What to learn
You need a Mac to build iOS apps with Xcode.
Learn each topic here
Xcode
Xcode is Apple’s IDE for writing, building, testing and publishing iOS apps. It runs only on macOS.
Simulator
The Simulator runs virtual iPhones and iPads on your Mac for quick testing.
App lifecycle
The app lifecycle describes states like active, inactive and background. SwiftUI uses scenePhase to react to them, for example to save data.
Info.plist
Info.plist stores app settings and permission messages, such as why you need camera or location access.
Assets and SF Symbols
The asset catalog stores images, colours and the app icon. SF Symbols is Apple’s library of thousands of icons that match the system style.
swift
Image(systemName: "heart.fill")Example
swift
import SwiftUI
@main
struct WorkoutApp: App {
var body: some Scene {
WindowGroup {
ContentView()
}
}
}This is the entry point of a SwiftUI app; ContentView is the first screen.
Helpful resource: Apple: App Dev Training
3Step 3: SwiftUI interfaces
Build screens with Apple’s declarative UI framework.
What is it?
SwiftUI describes what the screen should look like. When data changes, SwiftUI updates the view automatically.
What to learn
Use the Xcode preview canvas to see changes instantly while you code.
Learn each topic here
Views and modifiers
SwiftUI builds UI from views, styled with chained modifiers.
swift
Text("Hello").font(.title).foregroundStyle(.orange).padding()Stacks
VStack, HStack and ZStack arrange views vertically, horizontally and on top of each other.
swift
VStack(alignment: .leading) { Text("Title"); Text("Subtitle") }Lists
List shows scrollable rows of data.
swift
List(products, id: \.name) { p in Text(p.name) }Forms
Form groups inputs like text fields, toggles and pickers into a settings-style screen.
swift
Form { TextField("Name", text: $name); Toggle("Notifications", isOn: $on) }Navigation
NavigationStack and NavigationLink move between screens.
swift
NavigationStack { NavigationLink("Details") { DetailView() } }Dark mode
Use system colours and semantic styles so your app automatically looks good in light and dark mode.
Example
swift
struct WorkoutRow: View {
let workout: Workout
var body: some View {
HStack {
Text(workout.name)
Spacer()
Text("\(workout.minutes) min").foregroundStyle(.secondary)
}
}
}This row shows the workout name on the left and minutes on the right.
Helpful resource: Apple: SwiftUI tutorials
4Step 4: State and app architecture
Manage data flow cleanly as your app grows.
What is it?
State is data that can change. SwiftUI watches state and redraws the screen when it changes.
What to learn
Keep views simple. Move logic into model classes that are easy to test.
Learn each topic here
@State and @Binding
@State stores local view data; @Binding lets a child view read and change a parent’s state.
swift
@State private var count = 0
Button("Add") { count += 1 }@Observable
The @Observable macro makes a class’s properties update any view that uses them.
swift
@Observable class Cart { var items: [Product] = [] }MVVM
Model–View–ViewModel keeps UI code (View) separate from logic (ViewModel) and data (Model), making apps easier to test.
Environment
The environment passes shared values (like a data store, colour scheme or locale) down the view tree without manual passing.
Dependency management
Swift Package Manager adds third-party libraries to your project directly from Xcode.
Example
swift
@Observable
class WorkoutStore {
var workouts: [Workout] = []
func add(_ name: String, _ minutes: Int) {
workouts.append(Workout(name: name, minutes: minutes))
}
}Any view using this store updates automatically when a workout is added.
Helpful resource: Apple: Managing model data
5Step 5: Networking and async code
Load data from APIs safely and smoothly.
What is it?
Codable converts JSON into Swift types. async/await lets you wait for the network without blocking the UI.
What to learn
Always show a loading state and a clear error message. Users should never see a frozen screen.
Learn each topic here
URLSession
URLSession performs network requests.
swift
let (data, _) = try await URLSession.shared.data(from: url)Codable
Codable converts JSON into Swift types and back.
swift
struct Post: Codable { let id: Int; let title: String }
let posts = try JSONDecoder().decode([Post].self, from: data)async/await
Swift’s async/await runs work in the background without callbacks, keeping the UI responsive.
swift
.task { posts = try? await api.loadPosts() }Error handling
Use do/try/catch to handle failures and show helpful messages.
swift
do { posts = try await api.loadPosts() } catch { message = "Could not load" }Loading states
Show a ProgressView while loading and an error view with a retry button on failure.
Example
swift
struct Tip: Codable { let text: String }
func loadTips() async throws -> [Tip] {
let url = URL(string: "https://example.com/tips.json")!
let (data, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode([Tip].self, from: data)
}The function downloads JSON and decodes it into an array of Tip values.
Helpful resource: Apple: URLSession
6Step 6: Data persistence
Save user data on the device.
What is it?
SwiftData lets you store Swift model objects in a local database with very little code.
What to learn
Use SwiftData for app data and UserDefaults only for small settings.
Learn each topic here
SwiftData
SwiftData stores app data locally with simple Swift classes marked @Model.
swift
@Model class Note { var text: String; init(text: String) { self.text = text } }UserDefaults
UserDefaults stores small settings such as theme or whether onboarding was shown.
swift
@AppStorage("darkMode") var darkMode = falseCore Data basics
Core Data is Apple’s older persistence framework, still used in many existing apps. Learn the basics if you join a team with an older codebase.
Files
Save documents and images to the app’s Documents folder with FileManager.
iCloud sync basics
CloudKit and SwiftData can sync user data across their Apple devices through iCloud.
Example
swift
import SwiftData
@Model
class SavedWorkout {
var name: String
var minutes: Int
init(name: String, minutes: Int) { self.name = name; self.minutes = minutes }
}Marking a class with @Model makes it storable with SwiftData.
Helpful resource: Apple: SwiftData
7Step 7: Testing and quality
Keep your app reliable and accessible.
What is it?
Unit tests check small pieces of logic automatically so future changes do not break them.
What to learn
Turn on VoiceOver and try your app. It quickly shows accessibility problems.
Learn each topic here
XCTest and Swift Testing
Write unit tests for your logic using XCTest or the newer Swift Testing framework.
swift
@Test func total() { #expect(Cart(items: [p1, p2]).total == 15) }UI tests
UI tests launch the app and tap through screens to check full flows.
Instruments
Instruments profiles CPU, memory, energy and leaks to make your app fast and efficient.
Accessibility (VoiceOver)
Add accessibility labels, support Dynamic Type and test with VoiceOver so everyone can use your app.
swift
Image(systemName: "trash").accessibilityLabel("Delete")Debugging
Use breakpoints, the debug console and the view hierarchy debugger in Xcode to find problems quickly.
Example
swift
import XCTest
final class WorkoutStoreTests: XCTestCase {
func testAdd() {
let store = WorkoutStore()
store.add("Run", 30)
XCTAssertEqual(store.workouts.count, 1)
}
}This test checks that adding a workout increases the list by one.
Helpful resource: Apple: XCTest
8Step 8: Publishing on the App Store
Prepare, submit and maintain your app.
What is it?
Publishing means archiving your app in Xcode, uploading it to App Store Connect and submitting it for review.
What to learn
Read the App Review Guidelines before submitting. They explain most common rejection reasons.
Learn each topic here
Apple Developer Program
A paid yearly membership is needed to publish on the App Store and use TestFlight.
App Store Connect
App Store Connect is where you create app records, upload builds and manage releases and pricing.
TestFlight
TestFlight shares beta builds with testers before release.
App Review Guidelines
Apple reviews every app against its guidelines on safety, performance, design and privacy. Read them to avoid rejections.
Screenshots and metadata
Prepare screenshots for each device size, a clear description, keywords and privacy details.
Example
text
Submission checklist
[ ] Apple Developer Program membership
[ ] App icon and screenshots for each device size
[ ] Description, keywords and support URL
[ ] Privacy details completed
[ ] TestFlight testing done
[ ] Submit for reviewA complete checklist helps your app pass review faster.
Helpful resource: App Review Guidelines
iOS Developer roadmap project ideas
Projects turn what you learn into real skills. Build at least one project from each level below, and put every finished project on GitHub with a clear README.
Counter and tip app
Simple SwiftUI app with state.
Workout log
List and form screens.
Weather app
API data with loading and error states.
Journal app
SwiftData storage and search.
Habit app with widgets
Home screen widget and notifications.
App Store release
A polished app published on the App Store.
Tips to finish this ios developer roadmap
- Learn by building. Spend at least two thirds of your study time writing code and making projects, not watching videos.
- Be consistent. One focused hour every day beats a long session once a week. Small daily progress adds up quickly.
- Share your work. Post your projects on GitHub and LinkedIn. It builds your confidence and helps recruiters find you.
- Ask for feedback. Join a community, ask questions and review other people’s code. Explaining things to others is one of the fastest ways to learn.
- Do not chase every new tool. The fundamentals in this ios developer roadmap change slowly. Master them first, then explore new libraries.
Career paths and next steps
After this iOS developer roadmap, you can apply for junior iOS developer or mobile developer roles, or build and sell your own apps. Later you can become a senior iOS engineer or mobile team lead.
For Android too, see the Android developer roadmap or the cross-platform Flutter roadmap.
Related roadmaps
iOS Developer Roadmap FAQs
Do I need a Mac to become an iOS developer?
Yes. Xcode, the tool used to build iOS apps, runs on macOS.
Should I learn SwiftUI or UIKit?
Start with SwiftUI for new apps. Learn UIKit basics later, as many existing apps still use it.
How long does it take to learn iOS development?
Many learners become job-ready in six to nine months with regular practice and projects.
Is iOS development a good career?
iOS apps remain important for many businesses, so skilled iOS developers continue to be in demand.