The Mobile Developer Roadmap for 2026: iOS, Android, or Cross-Platform?

Published on BirJob.com · March 2026 · by Ismat

My First App Had 3 Downloads, and 2 Were My Parents

In 2022, I spent three months building a habit-tracking app for Android. I followed a Udemy course, used Java (because the course was from 2019 and hadn't been updated), fought with XML layouts for weeks, and eventually published something on the Google Play Store that looked like it was designed by someone who had never actually used a smartphone. It crashed on half the devices that downloaded it. My mom gave it 5 stars anyway.

But here's the thing — that terrible app taught me more about mobile development than any tutorial ever could. I learned that the phone in your pocket is a fundamentally different computing environment from a laptop. Memory is limited. Battery life matters. Users expect 60fps animations. The app needs to work offline, handle interruptions (phone calls, notifications), manage state across lifecycle changes, and look good on screens ranging from 4 inches to 7 inches. Oh, and Apple and Google can reject your app for reasons that range from reasonable to absolutely baffling.

Since then, I've built BirJob, which scrapes 9,000+ job listings daily from 77+ sources. And I've watched mobile development job postings evolve in fascinating ways. The biggest shift? In 2023, most mobile postings specified "iOS" or "Android." In 2026, an increasing number just say "mobile developer" and expect you to work cross-platform. The platform wars haven't ended, but the battle lines have moved.

This roadmap is the guide I wish I had instead of that outdated Udemy course. It covers all the paths — native iOS, native Android, and cross-platform — and gives you an honest framework for choosing.

The Numbers First: Is Mobile Development Still a Good Bet?

Mobile development has been "dying" according to the internet for about 8 years now. Every year, someone writes a hot take about how progressive web apps (PWAs) or some new framework will kill native mobile. And every year, the mobile market grows.

• The U.S. Bureau of Labor Statistics projects 17% growth for software developers through 2034, which includes mobile developers. That's much faster than the average for all occupations, translating to roughly 153,900 new jobs per year.
• Global mobile app revenue reached $935 billion in 2025 and is projected to surpass $1 trillion by 2027. Companies aren't moving away from mobile — they're doubling down on it.
• According to Glassdoor, the median mobile developer salary in the U.S. is approximately $108,000 in 2026. Mid-level developers with 3–5 years of experience typically earn $85,000–$120,000, while senior mobile engineers earn $140,000–$200,000+.
• At top-tier companies (Apple, Google, Meta, Airbnb), senior iOS/Android engineers can earn $200,000–$350,000+ in total compensation. Levels.fyi mobile engineer data confirms these ranges.
• In the Azerbaijani market, mobile developers earn $6,000–$15,000/year locally. Working remotely for international companies from Azerbaijan or the broader region, expect $25,000–$60,000, with top performers earning $70,000–$100,000+.
• Stack Overflow's Developer Survey consistently shows mobile development among the top 10 most common developer specializations worldwide. It's not niche — it's a core pillar of the software industry.

The reality check: mobile developer salaries are generally slightly lower than equivalent web backend or cloud/infrastructure roles, but higher than frontend web development. The ceiling is high at top companies, especially for iOS specialists (Apple's ecosystem commands a premium). The floor is also reasonable — even junior mobile developers start well above the general tech support/IT baseline.

The Platform Decision: The Most Important Choice You'll Make

Before we get into any roadmap, you need to make a fundamental decision that will shape the next 12–18 months of your learning. There are four viable paths in 2026, and they're more different than most guides acknowledge.

My honest recommendation for 2026: If you have no constraints and want to maximize your career options, start with React Native if you already know JavaScript, or Flutter if you're starting fresh. Cross-platform skills are increasingly what companies want, and both frameworks have matured enormously. If you specifically want to work at Apple, a major bank, or a premium consumer brand, go native iOS with Swift. If you're targeting emerging markets or enterprise, go native Android with Kotlin.

Let me break down each path so you can make an informed decision.

Path A: Native iOS with Swift & SwiftUI

Why Choose iOS?

Apple's ecosystem is a walled garden, but it's an incredibly lucrative one. Apple reported that iOS users spend roughly 2x more on in-app purchases than Android users. This means companies targeting premium consumers — fintech apps, health apps, luxury brands — often build iOS first (or iOS only). The result: iOS developers command a salary premium of roughly 10–15% over Android developers for equivalent experience levels.

The downside? You need a Mac. Not optional. You need Xcode, which only runs on macOS. If you don't own a Mac, factor $1,000–$2,000 for a used MacBook Pro into your learning budget. Apple's developer program costs $99/year to publish to the App Store.

The iOS Roadmap (12 Months)

Phase 1: Swift Foundations (Months 1–3)

• Weeks 1–4: Swift language fundamentals — variables, types, optionals (critical in Swift), control flow, functions, closures. Optionals alone will take a week to truly understand if you're coming from Python or JavaScript. Resource: The Swift Programming Language (free book by Apple)
• Weeks 5–8: Object-oriented and protocol-oriented programming in Swift. Structs vs classes (Swift favors structs — understand why). Protocols, extensions, generics. Error handling with do-try-catch. Concurrency with async/await.
• Weeks 9–12: SwiftUI fundamentals — views, modifiers, state management (@State, @Binding, @ObservedObject, @EnvironmentObject), navigation, lists, forms. Build 2–3 simple apps (a to-do list, a weather app using a public API, a calculator).

Phase 2: Intermediate iOS (Months 4–7)

• Networking: URLSession, async/await for API calls, JSON parsing with Codable. Build an app that fetches and displays data from a REST API.
• Data persistence: UserDefaults (simple settings), Core Data (complex local data), SwiftData (Apple's modern replacement for Core Data, released 2023). Understand when to use each.
• Architecture patterns: MVVM is the dominant pattern for SwiftUI apps. Learn it thoroughly. Understand why MVC (Apple's old recommendation) leads to "Massive View Controller" problems in practice.
• Testing: XCTest for unit tests, XCUITest for UI tests. Most iOS developers under-invest in testing — don't be one of them.
• Apple frameworks: MapKit, CoreLocation, Push Notifications (APNs), HealthKit, or other frameworks relevant to your target domain.

Phase 3: Advanced & Portfolio (Months 8–12)

• Advanced SwiftUI: custom animations, custom view modifiers, performance optimization
• App Store submission process, App Store Optimization (ASO), TestFlight beta distribution
• CI/CD: Xcode Cloud or Fastlane for automated builds and testing
• Build and publish 2–3 polished apps to the App Store

Key resource: Apple's official SwiftUI tutorials are surprisingly excellent — better than most paid courses. 100 Days of SwiftUI by Paul Hudson is the community favorite structured learning path and it's free.

Path B: Native Android with Kotlin & Jetpack Compose

Why Choose Android?

Android holds roughly 72% of the global mobile market share. In many emerging markets — India, Southeast Asia, Africa, the Middle East (including Azerbaijan) — it's 85%+. If you're targeting users in these regions, Android is the default platform.

The barrier to entry is lower than iOS: you can develop on Windows, Mac, or Linux using Android Studio (free). The Google Play Store charges a one-time $25 fee to publish, compared to Apple's $99/year. And Android's openness means you have access to more device capabilities, side-loading, and hardware diversity.

The downside? Fragmentation. Your app needs to work on thousands of different devices with different screen sizes, Android versions, and hardware capabilities. Testing is more complex. And Android users historically spend less on apps than iOS users, which means some companies deprioritize Android development.

The Android Roadmap (12 Months)

Phase 1: Kotlin Foundations (Months 1–3)

• Weeks 1–4: Kotlin language fundamentals — null safety (Kotlin's killer feature), data classes, sealed classes, extension functions, lambdas, coroutines. If you know Java, Kotlin will feel like a breath of fresh air. If you're starting from scratch, Kotlin is arguably easier to learn than Java. Resource: Kotlin official documentation
• Weeks 5–8: Kotlin coroutines and Flow for asynchronous programming. This is essential — modern Android is built on coroutines. Understand structured concurrency, suspend functions, Dispatchers, and Flow (cold streams) vs StateFlow/SharedFlow (hot streams).
• Weeks 9–12: Jetpack Compose fundamentals. Google declared Compose as the recommended UI framework for Android and new projects should use it. Learn composable functions, state hoisting, recomposition, LazyColumn/LazyRow (the RecyclerView replacement), Scaffold, and navigation.

Phase 2: Intermediate Android (Months 4–7)

• Architecture: MVVM with Android ViewModel + StateFlow. Understand the Android lifecycle (Activities, Fragments, and why Compose simplifies this). Dependency injection with Hilt (the standard for Android DI).
• Networking: Retrofit for REST APIs + OkHttp for HTTP. Kotlin serialization for JSON parsing. Build apps that connect to real APIs.
• Data persistence: Room (SQLite abstraction layer) for structured data. DataStore for key-value preferences (replaces SharedPreferences).
• Testing: JUnit for unit tests, Espresso or Compose Testing for UI tests. MockK for mocking in Kotlin.
• Jetpack libraries: Navigation Compose, WorkManager (background tasks), CameraX, Google Maps SDK — pick based on your interests.

Phase 3: Advanced & Portfolio (Months 8–12)

• Advanced Compose: custom layouts, animations, performance profiling with the Layout Inspector
• Google Play Store submission, release management, staged rollouts, Android App Bundle format
• CI/CD with GitHub Actions or Bitrise
• Build and publish 2–3 polished apps to the Google Play Store

Key resource: Android Developers official courses are the best free resource. Google's Android Basics with Compose course is the recommended starting point. roadmap.sh's Android path provides a visual learning roadmap.

Path C: Cross-Platform with Flutter

Why Flutter?

Flutter is Google's cross-platform framework, and its growth trajectory has been remarkable. Flutter lets you write one codebase in Dart that compiles to native iOS and Android apps (plus web, desktop, and embedded). Unlike older cross-platform approaches, Flutter doesn't use web views or bridge to native components — it renders everything directly on a canvas using its own rendering engine (Impeller in 2026), which means consistent, smooth 60fps UI across platforms.

Stack Overflow's surveys have consistently shown Flutter as one of the most loved cross-platform frameworks, and its adoption has grown particularly strongly in Asia, the Middle East, and startups that need to ship on both platforms with small teams.

The main risk? Flutter's success is tied to Google's continued investment, and Google has a well-documented history of killing projects. That said, Flutter has survived the initial hype cycle and continues to receive major updates. The showcase page shows adoption by BMW, eBay, Google Pay, and other major companies.

The Flutter Roadmap (12 Months)

Phase 1: Dart & Flutter Foundations (Months 1–3)

• Weeks 1–3: Dart language fundamentals — it's easy to learn if you know Java, Kotlin, JavaScript, or C#. Focus on null safety, classes, mixins, async/await, Streams. Resource: Official Dart documentation
• Weeks 4–8: Flutter widget tree, stateless vs stateful widgets, layout system (Row, Column, Stack, Expanded, Flexible), Material Design and Cupertino widgets (iOS-style). The "everything is a widget" mental model takes a week or two to click.
• Weeks 9–12: Navigation (GoRouter), forms and validation, theming, responsive design across screen sizes. Build 2–3 simple apps.

Phase 2: Intermediate Flutter (Months 4–7)

• State management: This is the biggest decision in Flutter. Options: Provider (simple), Riverpod (modern, recommended), BLoC (enterprise-favorite), GetX (controversial but popular). Learn Riverpod — it's the community consensus recommendation for new projects in 2026.
• Networking: Dio or http package for REST APIs. JSON serialization with json_serializable or freezed. Build apps that connect to real backends.
• Local storage: shared_preferences for simple data, Hive or Isar for local databases, sqflite for SQLite.
• Platform channels: When you need native code (camera, Bluetooth, platform-specific APIs), learn how to call native Swift/Kotlin from Dart. This is where cross-platform meets reality.
• Testing: Widget testing (Flutter's equivalent of UI testing), unit testing, integration testing. Flutter's testing framework is genuinely excellent.

Phase 3: Advanced & Portfolio (Months 8–12)

• Custom animations with AnimationController and Rive
• Firebase integration (Auth, Firestore, Cloud Functions, Push Notifications)
• Publishing to both App Store and Google Play from one codebase
• CI/CD with Codemagic or GitHub Actions
• Build and publish 2–3 apps to both stores

Key resource: Flutter's official codelabs are well-structured. Maximilian Schwarzmuller's Flutter course on Udemy is the most popular paid course. roadmap.sh's Flutter path provides a visual overview.

Path D: Cross-Platform with React Native

Why React Native?

React Native is Meta's cross-platform framework, and its biggest advantage is obvious: if you know React (web), you're already 60% of the way to knowing React Native. The JavaScript/TypeScript ecosystem is massive, the npm package library is enormous, and the transition from web to mobile is smoother than with any other approach.

The Expo framework has transformed React Native development. In 2023, Expo was a nice-to-have convenience tool. In 2026, it's the default starting point for React Native projects. Expo handles the build toolchain, native module configuration, over-the-air updates, and app store submissions. It removes the biggest pain point React Native historically had: configuring native build tools.

React Native is used by Meta (Instagram, Facebook), Microsoft (Teams, Outlook mobile), Shopify, Discord, and hundreds of other major apps. It's the most battle-tested cross-platform framework in production.

The React Native Roadmap (12 Months)

Phase 1: JavaScript/TypeScript & React Foundations (Months 1–3)

If you already know React for web, skip to month 2. If not:

• Weeks 1–4: JavaScript fundamentals (ES6+), then TypeScript. Async/await, promises, destructuring, spread operators, modules. TypeScript is not optional in 2026 — almost every serious React Native project uses it. Resource: javascript.info (free, excellent)
• Weeks 5–8: React fundamentals — components, JSX, props, state, hooks (useState, useEffect, useContext, useRef, useMemo), component lifecycle. You must be comfortable with React before touching React Native.
• Weeks 9–12: React Native + Expo basics — setting up with npx create-expo-app, core components (View, Text, ScrollView, FlatList, Pressable), styling with StyleSheet, navigation with React Navigation or Expo Router.

Phase 2: Intermediate React Native (Months 4–7)

• State management: React Context for simple state. For complex apps: Zustand (lightweight, gaining massive adoption) or TanStack Query (for server state management). Redux is still used in legacy projects but Zustand is winning for new projects.
• Networking: fetch API, Axios, or TanStack Query for data fetching with caching. Real-time data with WebSockets or Socket.io.
• Local storage: AsyncStorage for simple key-value, Expo SQLite or WatermelonDB for complex local data. MMKV for high-performance key-value storage.
• Native modules: Expo modules cover 90% of needs (camera, location, notifications, file system). For the remaining 10%, learn to write native modules in Swift/Kotlin or use community packages.
• Animations: Reanimated for performant, gesture-driven animations. This is the standard animation library in 2026.
• Testing: Jest for unit tests, React Native Testing Library for component tests, Detox for E2E tests.

Phase 3: Advanced & Portfolio (Months 8–12)

• EAS Build and EAS Submit (Expo's build and submission services)
• Over-the-air updates with EAS Update
• Performance optimization: Hermes engine, lazy loading, image optimization
• Publishing to both stores, handling different signing requirements
• Build and publish 2–3 apps to both stores

Key resource: React Native official docs and Expo documentation are excellent. For structured learning, Academind's React Native course on Udemy is the community standard. See also our Frontend vs Full-Stack guide for context on how mobile fits into the broader development landscape.

React Native vs Flutter: The 2026 Verdict

This is the most common question I get about mobile development. Here's my honest comparison:

Choose React Native if: you already know JavaScript/React, you want maximum job market flexibility, or your team also builds web apps in React.

Choose Flutter if: you're starting from scratch and don't have web experience, you want pixel-perfect UI consistency across platforms, or you're targeting markets where Flutter is dominant (parts of Asia, Middle East, South America).

The honest truth: both are excellent choices in 2026. The days of one being clearly superior are over. Pick one and go deep — switching later is easier than you think because the concepts (state management, navigation, networking, testing) transfer directly.

Core Concepts Every Mobile Developer Must Master

Regardless of which path you choose, these concepts are universal. They appear in every mobile developer interview and every real-world project:

State Management

This is the hardest concept in mobile development and the source of the most bugs. How does your app track what screen the user is on, what data has been loaded, whether a network request is pending, and what form fields have been filled in — all simultaneously, across multiple screens, with changes happening asynchronously? Every framework has its own approach, but the underlying problem is the same. Study it deeply.

Navigation & Deep Linking

Users expect to move between screens smoothly, go back to where they were, and share links that open directly to specific content. Sounds simple. It's not. Nested navigation stacks, tab-based navigation, modal presentations, and deep linking from push notifications or URLs are where most junior developers struggle.

API Integration & Offline Support

Mobile apps live in a world of unreliable network connections. Your app needs to work when the user is in a subway with no signal, gracefully handle timeouts, cache data locally, sync when connectivity returns, and show appropriate loading/error states. This is fundamentally different from web development, where you can mostly assume connectivity.

App Store Submission & Distribution

Pro tip: submit your first app early in your learning journey, even if it's simple. The submission process itself has a learning curve, and you'll encounter issues (missing screenshots, privacy policy requirements, metadata rejections) that are better to discover early.

The "Should I Learn Web First?" Debate

This question comes up constantly: "Should I learn web development before mobile?" Here's my take.

Arguments for learning web first:

• Web development teaches you fundamentals (HTTP, APIs, databases, deployment) that transfer directly to mobile
• If you learn React for web, transitioning to React Native is natural
• Web has a lower barrier to entry (no Mac required, no app store approvals, instant deployment)
• Many companies want "T-shaped" developers who understand both web and mobile

Arguments for going straight to mobile:

• Mobile development has unique challenges (offline support, device APIs, app lifecycle) that web doesn't prepare you for
• If you know your career goal is mobile, web is a detour
• Native mobile development (Swift, Kotlin) doesn't benefit much from web knowledge
• Flutter developers don't need web experience at all

My recommendation: If you're choosing the React Native path, learn web React first. Spend 2–3 months on React for web, build a project, then transition to React Native. The shared foundation will make everything easier. For native iOS, native Android, or Flutter, skip web and go straight to mobile. The time spent on web won't meaningfully help.

The Portfolio: 2–3 Published Apps Beat 10 Tutorial Projects

This is the single most important piece of advice in this entire article: published apps are the currency of mobile development hiring.

A web developer can show a GitHub repo and a deployed URL. A data scientist can show a Kaggle profile and a Jupyter notebook. A mobile developer needs actual apps in the store. Not mockups. Not screenshots of something running in a simulator. Real apps that a hiring manager can download on their phone and use.

Here's why this matters so much: publishing an app forces you to solve all the problems that tutorials skip. Icon generation, splash screens, responsive layouts on real devices, handling the app review process, crash reporting, analytics, and actually marketing your app to get a handful of users. These are the skills that separate tutorial-completers from hireable developers.

Portfolio app ideas that demonstrate real skills:

1. A "utility" app that solves a real problem: a local transit tracker, a prayer time app, a currency converter with live rates, a meal planning app. Something that at least 100 people might actually use.
2. An app with complex state and networking: a social recipe app with user accounts, image uploads, and a feed. Shows you can handle auth, media, API integration, and complex UI.
3. An app with offline support: a note-taking app or task manager that works fully offline and syncs when connectivity returns. This demonstrates understanding of local databases and sync logic — a critical real-world skill.

Each portfolio app should have: a clean App Store/Play Store listing with good screenshots, a GitHub repo with clean architecture and tests, and a brief case study explaining your technical decisions. For more on building a developer portfolio that stands out, see our Developer Portfolio Guide.

The AI Elephant in the Room

Let's address the AI question: will AI kill mobile development jobs?

Short answer: no. But it's already changing the job.

In 2026, AI coding assistants (GitHub Copilot, Claude, Cursor) can generate UI components, write networking code, create test cases, and even scaffold entire screens from descriptions. I've seen demos of tools that generate Flutter or React Native code from Figma designs. It's impressive.

But here's what AI can't do in mobile development:

• Handle platform-specific edge cases — iOS and Android have hundreds of subtle behavioral differences that AI doesn't reliably account for. Memory management on older iPhones, Android fragmentation across manufacturers, platform-specific permission flows.
• Debug production crashes from real users — when your app crashes on a specific Samsung device running Android 12 with a particular language setting, you need a human who understands the device ecosystem to diagnose it.
• Make UX decisions — should this screen use a bottom sheet or a full-screen modal? Should the list pull-to-refresh or paginate? These are design judgment calls that require understanding user behavior.
• Navigate app store politics — Apple's review guidelines are notoriously subjective. Getting an app approved sometimes requires understanding the unwritten rules. AI can't call Apple Developer Support and negotiate.
• Optimize for real-world conditions — battery life, cellular data usage, accessibility, performance on low-end devices. These require testing on real hardware and understanding the constraints of mobile computing.

The mobile developers who are thriving in 2026 are using AI to generate boilerplate code 3x faster and spending the saved time on the hard problems: complex animations, performance optimization, platform-specific bugs, and UX refinement. The ones at risk are those who only knew how to follow tutorials and copy-paste from Stack Overflow — which is exactly what AI does better and faster.

As we discussed in our AI Coding Tools War article, AI tools raise the floor but don't raise the ceiling. They make average developers faster but don't replace the judgment and experience that make great mobile apps great.

What I Actually Think

After monitoring thousands of mobile development job postings through BirJob and watching the market evolve, here are my unfiltered opinions:

Cross-platform is winning, and it's not close. The percentage of mobile job postings that specify "React Native" or "Flutter" has grown every quarter for the last two years. Startups and mid-size companies don't have the budget or team size for separate iOS and Android teams. They want one team that ships to both platforms. If you're optimizing for job availability, go cross-platform.

But native iOS is still the premium path. The highest-paying mobile developer roles I've seen are native iOS positions at banks, fintech companies, and premium consumer brands. These companies need the absolute best performance, the deepest platform integration, and the polish that native development provides. If you want to maximize salary and you're willing to specialize, native iOS with Swift is the play.

Flutter is underrated in the Western job market and dominant elsewhere. In the U.S. and Western Europe, React Native still has more job postings. But in the Middle East, South Asia, and parts of Eastern Europe — the markets most relevant to our BirJob audience — Flutter often has more demand than React Native. If you're in Azerbaijan or the broader region, Flutter is an excellent choice.

Don't learn Java for Android in 2026. Just don't. Kotlin is the official recommended language for Android development. Google has said so explicitly. New Android APIs are Kotlin-first. Learning Java for Android in 2026 is like learning Objective-C for iOS — technically possible, but you're handicapping yourself for no reason. Same goes for XML layouts — learn Jetpack Compose instead.

Published apps are non-negotiable. I can't stress this enough. I've seen mobile developer candidates with beautiful GitHub repos and zero published apps get passed over for candidates with mediocre code but 3 apps in the store with real downloads. The app store is proof that you can ship. GitHub is proof that you can code. Both matter, but shipping matters more.

The "mobile vs web" distinction is blurring. React Native developers who know React can build for web and mobile. Flutter now targets web, desktop, and mobile from one codebase. The future isn't "mobile developer" or "web developer" — it's "application developer" who can ship to whatever platform the user needs. Position yourself accordingly.

The Career Progression

For more on the individual contributor vs management career track decision, see our Staff Engineer vs Engineering Manager guide. And if you're navigating the junior-to-senior transition, our Junior, Mid, Senior — What Actually Changes article breaks down what each level really means.

The Action Plan: Start This Week

Don't bookmark this article and let it rot in your browser tabs. Here's exactly what to do in the next 7 days:

1. Day 1: Decide your path. Re-read the comparison table above. If you know JavaScript, choose React Native. If you're starting fresh, choose Flutter. If you want the premium niche, choose iOS. Make the decision and stop second-guessing.
2. Day 2: Set up your development environment. Install the IDE (Android Studio for Kotlin/Flutter, Xcode for Swift, VS Code for React Native). Run the "Hello World" template app on a simulator or your phone. Getting the toolchain working is half the battle.
3. Day 3: Start the official beginner tutorial for your chosen framework: Apple SwiftUI tutorials, Android Basics with Compose, Flutter codelabs, or React Native getting started.
4. Day 4: Create a GitHub repository called "mobile-developer-portfolio." Push your Day 3 tutorial code. Write a README that describes what you're building and your learning plan.
5. Day 5: Build something tiny but original — not from a tutorial. A counter app with a twist, a random quote generator that calls a free API, a tip calculator. The act of building without following step-by-step instructions activates a completely different part of your brain.
6. Day 6: Browse mobile developer job postings on BirJob and LinkedIn. Read 5–10 postings for your chosen platform. Write down every skill and framework they mention. Compare against this roadmap.
7. Day 7: Sign up for a developer account ($25 for Google Play, $99/year for Apple). Set a goal: publish your first app within 60 days. It doesn't need to be good. It needs to be published. Block 1.5 hours daily in your calendar for mobile development study.

Sources

• U.S. Bureau of Labor Statistics — Software Developers Occupational Outlook
• Mobile Developer Salaries — Glassdoor
• Mobile Engineer Compensation Data — Levels.fyi
• Worldwide Mobile App Revenue Forecast — Statista
• Mobile OS Market Share Worldwide — StatCounter
• Stack Overflow Developer Survey
• The Swift Programming Language — Apple
• SwiftUI Tutorials — Apple Developer
• 100 Days of SwiftUI — Hacking with Swift
• Kotlin Documentation — JetBrains
• Jetpack Compose — Android Developers
• Android Basics with Compose — Google
• Android Developer Roadmap — roadmap.sh
• Flutter — Google
• Flutter Developer Roadmap — roadmap.sh
• React Native — Meta
• Expo — Cross-Platform Development Framework
• React Navigation
• React Native Reanimated
• The Modern JavaScript Tutorial — javascript.info

I'm Ismat, and I build BirJob — a platform that scrapes 9,000+ job listings daily from 77+ sources across Azerbaijan. If this roadmap helped, check out our other career guides: Frontend vs Full-Stack, The Developer Portfolio Guide, Best Free Certifications 2026, and TypeScript in 2026.