iOS developer job postings have dropped more than 60% since 2020. Meanwhile, the median iOS engineer salary on Levels.fyi sits at $188,000. Fewer jobs. Higher pay. That's not a dying field -- it's a maturing one. The easy entry points are closing. The rewards for getting in are growing. And the path to getting there has changed more in the last two years than in the previous five.
This is the iOS developer roadmap I'd follow if I were starting in 2026. Not the theoretical "learn everything" roadmap you find on roadmap.sh. The practical one. The one that accounts for how the job market actually works, what companies actually hire for, and where Swift is actually headed.
Let me hit you with the numbers first, because they tell a story most roadmaps ignore.
The Bureau of Labor Statistics projects software developer employment to grow 15% from 2024 to 2034 -- roughly 129,200 new openings per year. That's the broad category. iOS specifically is a different picture.
| Metric | Number | Source |
|---|---|---|
| Active iOS developer job openings (US) | 237,714 | ZipRecruiter |
| Average salary (US) | $131,675 | PayScale |
| Median total compensation | $188,000 | Levels.fyi |
| Top 10% earners | $208,018+ | Salary.com |
| Apple iOS Engineer (median TC) | $248,000 | Levels.fyi |
| Meta iOS Engineer (median TC) | $440,000 | Levels.fyi |
The 60% drop in job postings isn't because companies don't need iOS developers. It's because SwiftUI enables 2-3x faster development. One senior developer now does what two mid-level developers did in 2020. Companies need fewer iOS devs, but they need better ones. And they're willing to pay significantly more for them.
Here's the salary ladder by experience:
| Experience | Salary Range |
|---|---|
| Entry-level (0-1 year) | $79,795 - $105,000 |
| Early career (1-4 years) | $96,766 - $116,000 |
| Mid-level (4-6 years) | ~$124,000 |
| Senior (7+ years) | $149,956 - $168,638 |
| FAANG senior | $250,000 - $480,000+ |
The message is clear: the entry-level iOS market is tight, but the ceiling is exceptionally high. This roadmap is about getting through the tight door -- and then climbing fast once you're in.
Skip Objective-C. I know some roadmaps still list it. In 2026, only 33% of apps rely exclusively on UIKit (which still uses some Objective-C patterns), and that number drops every month. You might encounter Objective-C in legacy codebases eventually, but it should not be where you start.
Start with Swift. Specifically Swift 6.2, which landed in September 2025 and changed how concurrency works in meaningful ways.
What to learn first:
What most beginners get wrong:
They rush through optionals. I've seen junior developers six months into a job who still force-unwrap everything with ! because they never properly understood optional binding, optional chaining, and nil coalescing. Don't be that person. Optionals are Swift's most important safety feature.
Resources:
The best free resource is Apple's own Swift Programming Language book. It's updated for Swift 6. For a more guided approach, Paul Hudson's 100 Days of SwiftUI is the single most recommended learning path in the iOS community.
This is where my roadmap diverges from traditional ones. Most older roadmaps say "learn UIKit first." In 2026, that advice is wrong.
SwiftUI adoption has surged to roughly 65-70% of new apps. SwiftUI-only projects jumped from 31% in 2024 to 43% in 2025. The trend is undeniable. But here's the catch: 75% of job postings still require UIKit knowledge, and UIKit still powers 80% of enterprise and legacy apps.
So the answer isn't "SwiftUI or UIKit." It's "SwiftUI first, UIKit second, both eventually." Here's why that order matters.
SwiftUI first because:
UIKit second because:
SwiftUI core concepts to master:
UIKit core concepts (learn after SwiftUI):
That last point is critical. The real-world skill in 2026 isn't "pure SwiftUI" or "pure UIKit." It's knowing how to bridge them. Most companies are in the middle of a multi-year migration. They need developers who can write new features in SwiftUI while maintaining and gradually replacing UIKit code.
Swift 6 introduced strict concurrency checking, and Swift 6.2 made it more approachable. This is the single biggest shift in Swift's evolution, and it's the skill that separates junior developers from mid-level ones.
Before Swift 6, data races were runtime bugs. You'd ship code, it would crash occasionally under heavy load, and you'd spend days debugging thread safety issues. Now the compiler catches data races at build time. But you need to understand the model.
What changed in Swift 6.2:
@MainActor everywhere)@concurrent attribute lets you opt into running work on background threadsThe concurrency learning path:
Why this matters for jobs:
Most existing codebases are in the middle of migrating from Grand Central Dispatch (GCD) and completion handlers to async/await. Companies desperately need developers who understand both the old patterns and the new ones, and can migrate between them safely. If you can demonstrate this skill in an interview, you're ahead of 80% of candidates.
This is where you go from "I can build an app" to "I can build an app that a team can maintain."
Architecture patterns to know:
| Pattern | When to Use | Complexity |
|---|---|---|
| MVC | Small apps, prototypes | Low |
| MVVM | Most SwiftUI apps (natural fit) | Medium |
| TCA (The Composable Architecture) | Large apps with complex state | High |
| Clean Architecture / VIPER | Enterprise apps with strict separation | High |
MVVM is the default for SwiftUI projects. Learn it well. TCA (by Point-Free) has gained significant adoption in the iOS community and shows up in job listings for companies that care about testability. You don't need to master TCA on day one, but awareness is valuable.
Data persistence -- the modern stack:
Networking:
One of the most common mistakes iOS beginners make is over-relying on third-party libraries. Installing CocoaPods for everything when Apple provides built-in solutions. URLSession, Codable, and the Combine/async-await ecosystem handle 90% of networking needs. Learn the native tools first.
Here's an uncomfortable truth: most iOS developers are bad at testing. I've reviewed codebases at companies of all sizes, and test coverage in iOS projects is consistently lower than backend projects. This is a competitive advantage if you invest in it.
Testing layers:
CI/CD for iOS:
Learn Fastlane. Seriously. Manually uploading builds to App Store Connect gets old after the third time. Automating your release pipeline with Fastlane saves hours per release and reduces human error.
The App Store is a beast. 1.9 million apps, 38 billion annual downloads, 850 million weekly users. And 38% of iOS developers had at least one app rejection in the past year.
What you need to know:
Ship something. This cannot be overstated. The difference between a developer with zero shipped apps and one with a live App Store app is enormous in hiring managers' eyes. Your app doesn't need to be revolutionary. It needs to exist, work correctly, and demonstrate that you understand the full development-to-deployment pipeline.
42% of iOS developers are solo indie developers. There's a real culture of building and shipping your own products in this community. Embrace it.
This is where you choose your path. Not every iOS developer needs all of these. Pick based on what interests you and where the jobs are.
AI/ML on device:
Apple is replacing Core ML with Core AI in iOS 27. On-device intelligence is becoming a first-class citizen. If you're interested in AI engineering or ML engineering, understanding how on-device models work is increasingly valuable. Learn Create ML for training, Core ML (soon Core AI) for inference, and the basics of model optimization for mobile.
visionOS and spatial computing:
There are currently 698 Apple Vision Pro developer jobs on ZipRecruiter paying $40-$96/hr. Vision Pro sales have been slow -- just 45,000 units in Q4 2025 -- but the developer demand exists primarily in enterprise AR/VR applications. RealityKit and ARKit skills are niche but well-compensated. This is a bet on the future, not today's market.
watchOS and HealthKit:
Health and fitness apps are a massive category on the App Store. If you're interested in health tech, learning HealthKit, workout session management, and watchOS complications opens doors to a specialized and growing market.
Performance and Instruments:
Every team needs someone who can profile apps. Learning Xcode Instruments -- memory leaks, CPU profiling, network debugging, Core Animation analysis -- makes you the person senior engineers rely on when the app is janky or crashing. This skill alone has gotten developers promoted.
Let me give you context on where Swift stands as a language.
Swift returned to the TIOBE top 20 in March 2026 after dropping to #26 in 2025. It's not in GitHub's top 6 languages (Python, JavaScript, TypeScript, Java, C++, C# dominate). TIOBE's CEO noted that Swift's ranking dipped because it's "mainly used for a particular mobile platform."
That sounds negative, but it's actually the opportunity. Swift is deeply specialized. You're not competing with every developer on Earth. You're competing with the subset that builds for Apple's ecosystem -- an ecosystem that facilitated $1.3 trillion in developer billings and sales in 2024. Apple has 34 million+ registered developers, but the number of truly skilled Swift developers who understand modern concurrency, SwiftUI, and Apple's platform direction is a fraction of that.
Swift 6.2 added WebAssembly support, which hints at Swift expanding beyond Apple platforms. Server-side Swift (Vapor framework) exists but hasn't gained mainstream adoption. For now, Swift means Apple. And that's fine -- Apple's ecosystem is large enough to build an entire career in.
I've seen both paths. Here's the honest breakdown.
Freelance iOS developer rates (US):
| Experience | Hourly Rate |
|---|---|
| Junior (1-3 years) | $40 - $60/hr |
| Mid-level (3-5 years) | $60 - $100/hr |
| Senior (5+ years) | $70 - $150/hr |
| Specialized (AR/ML/enterprise) | Up to $250/hr |
The math:
A senior freelancer billing $120/hr for 30 billable hours per week grosses $187,200/year. But you pay your own health insurance (~$8,000-$15,000/year), self-employment tax (15.3%), equipment (MacBook Pro, iPhone for testing, Apple Developer account), and have zero paid vacation.
A senior full-time iOS developer at $168,000 base salary with benefits costs the employer roughly $200,000+ total. You get health insurance, 401k match, paid time off, and stability.
My take: start full-time. Get 2-3 years of experience at a company with a mature iOS codebase. Learn how teams work, how codebases scale, how apps get shipped through review processes. Then go freelance if the independence appeals to you. Freelancing without deep experience in team-based development is a recipe for bad habits and limited growth.
Here's what a realistic year looks like. Not a bootcamp promise. Not a "learn iOS in 30 days" fantasy.
| Month | Focus | Milestone |
|---|---|---|
| 1-2 | Swift fundamentals | Can write functions, handle optionals, use protocols |
| 2-4 | SwiftUI + UIKit basics | Built 2-3 small apps (to-do list, weather app, notes app) |
| 4-5 | Swift concurrency | Understand async/await, actors, Sendable |
| 5-7 | Architecture + data + networking | Built 1 full app with API integration and local storage |
| 7-8 | Testing + CI/CD | Added tests to your app, set up automated builds |
| 8-9 | Ship to App Store | Published 1 app live on the App Store |
| 9-12 | Specialization + job prep | Portfolio of 2-3 apps, contributing to open source, interview prep |
That's 12 months of consistent work -- not casual weekend study. I'm talking 10-15 hours per week minimum. People who treat this as a hobby will take 2-3 years. People who go full-time (bootcamp, self-study, career change) can compress this to 6-8 months.
I looked at the top roadmaps on Google before writing this. Here's what they miss.
They ignore the job market. A roadmap that doesn't tell you about salary ranges, hiring trends, and what companies actually look for is just a technology checklist. You need to understand the market you're entering.
They treat SwiftUI and UIKit as equal choices. They're not. SwiftUI is the future. UIKit is the present. You need both, but the order matters. Starting with UIKit in 2026 means learning a framework that's getting fewer updates each year.
They skip the concurrency model. Swift 6's strict concurrency is the biggest change to iOS development in years. Most existing roadmaps mention async/await but don't treat it as the fundamental shift it is.
They don't discuss money. Whether it's salary expectations, freelance rates, or the cost of Apple's developer program ($99/year), financial context matters for career decisions. I've written similar roadmaps for data analysts -- the salary trajectories are very different and should influence your decision.
They oversell visionOS. Vision Pro shipped 390,000 units in 2024 and demand dropped to 45,000 in Q4 2025. Learning visionOS is fine as a bet on the future, but don't prioritize it over mastering SwiftUI and UIKit.
Total cost to start: a Mac ($599 with the new MacBook Neo, though I'd recommend at least a MacBook Air for development) plus $99/year for the developer program. That's it. Everything else is free.
iOS development in 2026 is one of the best career paths in software engineering -- if you're willing to invest the time to get good at it.
The "fewer jobs, higher pay" dynamic is real. SwiftUI's efficiency gains mean companies need fewer iOS developers per project. But the developers they do hire need to be skilled across SwiftUI, UIKit, modern concurrency, and the full Apple platform stack. The bar is higher than it was in 2020. The rewards are higher too.
I'd pick this path over web development in 2026. Here's why. The web ecosystem is fragmented across dozens of frameworks that change every 18 months. React, Next.js, Svelte, Vue, Astro -- the churn is exhausting. iOS has one language (Swift), one IDE (Xcode), one UI framework gaining momentum (SwiftUI), and one platform owner (Apple) that publishes clear documentation and guides. The learning path is narrower but deeper. And the median compensation reflects that specialization premium.
The biggest risk is Apple itself. If Apple makes a catastrophic strategic error -- unlikely given their track record, but possible -- your skills are less transferable than those of a JavaScript developer. Swift outside Apple's ecosystem is still niche. Server-side Swift hasn't taken off. Swift's absence from GitHub's top 6 languages is a reminder that you're betting on one company's platform.
But that company facilitated $1.3 trillion in developer commerce in 2024. It has $117 billion in App Store revenue flowing through its ecosystem. It has 850 million weekly active users across 175 countries. The bet on Apple's ecosystem is, by almost every measure, one of the safest bets in tech.
Start with Swift fundamentals. Learn SwiftUI. Ship an app. Get a job. Then decide if you want to go deep into enterprise, indie, freelance, or spatial computing. The roadmap isn't complicated. The execution is what separates people who talk about becoming iOS developers from people who actually become one.