Sefism Mobile Development Roadmap

What it is

Sefism's mobile development roadmap takes you from your platform's language to an app that real testers install from Google Play or the App Store. It is seven stages and about 325 hours, and it deliberately goes past the point where most courses stop: offline data, permission flows, tests, profiling, a screen reader pass, store review and shipping an update.

Each stage lists its topics in learning order, each with a short explanation, a check question and a study prompt for an AI assistant that quizzes you instead of writing your app. Every stage closes with a milestone, Tauseef's practical advice, a checklist and resources sorted by job.

By the end you can:

• Build a multi-screen app with clear state management and navigation on your chosen platform.
• Fetch, cache and sync API data so the app keeps working without a connection, with tokens in secure storage.
• Use the camera, location and notifications with permission flows that handle a user saying no.
• Test core logic and one full user flow, profile a release build and complete that flow with a screen reader.
• Publish an app through Google Play closed testing or TestFlight with crash reporting live.

Four platforms

You choose a platform when you open the roadmap. Stage titles, topics, resources and projects all change with it:

• Flutter (the default at /roadmaps/mobile/): one Dart codebase for both stores, with widgets, go_router, Provider or Riverpod, and sqflite or drift.
• React Native: one codebase if you know React, with Expo, Expo Router, TanStack Query, expo-sqlite and SecureStore.
• Android: Kotlin and Jetpack Compose, with ViewModel and StateFlow, Retrofit, Room, DataStore and WorkManager.
• iOS: Swift and SwiftUI (you need a Mac), with @Observable, NavigationStack, URLSession, SwiftData and the Keychain.

Who it suits, and who should start elsewhere

It suits programmers who want to build and ship real apps for phones: students looking for a portfolio project that stands out, web developers moving to mobile, and anyone with an app idea who wants to get it into a store properly.

You should already be able to program a little. If you cannot yet, start with Programming foundations. If you already know React well, the React Native option builds on it; the Frontend development roadmap is the place to learn React first. If your app needs its own server and database, pair this with Backend development.

Time and a weekly plan

The seven stages add up to about 325 hours. The first, your platform language (50 hours), is a foundation stage you can skim if you already know Dart, TypeScript, Kotlin or Swift. The page turns hours into weeks from your pace: about 65 weeks at 5 hours a week, 43 at 8 hours, or 30 at 12 hours.

A student with 12 hours a week: around seven months. Use two evenings for topics and a long weekend session for the stage's milestone, building one app that grows through the stages so that by publishing you have something worth shipping.

Someone working full time with 8 hours a week: about ten months. Keep the app small; the roadmap's point is a finished, published, tested app rather than a large unfinished one.

Stage by stage

1. Your platform language (50 hours, foundation)

Titled Dart fundamentals, JavaScript and TypeScript, Kotlin fundamentals or Swift fundamentals. Variables and type inference, null safety (or optionals in Swift), functions and closures, classes and data modelling, collections, errors, async code, and packages. Flutter adds sealed classes, records, patterns and streams; Kotlin adds coroutine basics and Gradle; Swift adds enums with associated values, protocols and Swift Package Manager. Milestone: 15 Exercism exercises in your language, then a small console program using classes, collections, error handling and one async call.

2. UI fundamentals and layout (60 hours)

Titled Widgets and layout, React and React Native components, Jetpack Compose UI or SwiftUI views and layout. Declarative UI, hot reload and previews, layout containers, safe areas and screen sizes, local UI state, long lists and images, forms and the keyboard, theming and dark mode, and your platform's design guidelines. Milestone: three screens rebuilt from a real app you use (a login, a list with images and a detail page) that adapt to a small and a large phone and support dark mode.

3. State management and navigation (45 hours)

Local state, unidirectional data flow and lifting state up, view models and UI state, shared app state, stack navigation, tabs, sheets and dialogs, passing data between screens, and deep links. Each platform names its own tools: go_router and Riverpod, Expo Router and Zustand or Redux Toolkit, Navigation Compose and StateFlow, or NavigationStack and @Observable. Milestone: a three-screen app where a change on one screen shows on the others without passing callbacks through every layer, and a deep link opens the detail screen.

4. Networking, APIs and local storage (60 hours)

HTTP and JSON parsing, loading, error and empty states, timeouts and retries, key-value storage, a local SQLite database, the repository pattern, offline-first caching with a queue and sync, secure storage for secrets, and authentication tokens. Milestone: an app on a public API that caches results locally, still shows data in airplane mode, queues one user action offline and syncs it when the connection returns, with the login token in secure storage.

5. Device features, permissions and notifications (40 hours)

The app lifecycle, runtime permissions and good prompts, camera and photo picker, location, local and push notifications, background work and OS limits, and platform-specific code. Milestone: a feature using the camera or location, plus a reminder notification that still fires after the phone restarts, with each permission asked only when needed and a "no" handled properly.

6. Testing, performance and accessibility (40 hours)

Unit tests for logic, fakes and dependency injection, UI tests, end-to-end tests for key flows, profiling frames and memory, startup time and app size, screen readers and labels, text scaling and a security review before release. The roadmap notes that most student portfolios skip this stage, which is why it stands out. Milestone: tests over your core logic and one full user flow, the slowest screen fixed in the profiler, and that flow completed with the screen reader on at the largest text size.

7. Publishing to Google Play and the App Store (30 hours)

App IDs and version numbers, release builds, signing, crash reporting and analytics, privacy policy and data declarations, beta testing with Play closed testing and TestFlight, store listings, review guidelines and common rejections, staged rollouts and shipping updates. Milestone: your app published at least through a closed test or TestFlight with crash reporting live, and one update shipped that fixes something a tester reported. The Android version sets a Play closed test with at least 12 testers; the iOS version a TestFlight beta with at least 10 external testers.

Projects that fit

Two projects fit any platform: a medication adherence tracker with a caregiver view and an offline-first field data collection app with conflict-safe sync. Flutter adds a local market price transparency app, an offline-first campus timetable and an on-device wellbeing journal. React Native adds a receipt scanning expense splitter and a crowdsourced transport arrival tracker. iOS adds load-shedding schedule and outage alerts with widgets, and Android indoor navigation with Bluetooth beacons.

How it works on Sefism

Everything here is free to learn from. The public page shows all seven stages, with the first two stages open to read. Adding the roadmap to your dashboard uses credits: new members get starting credits and the first roadmap you add is free. Once added, every stage opens, you can track progress topic by topic, the weeks follow your own pace, and the companion cheat sheet opens with it. If you are stuck on a store rejection or a platform choice, ask Tauseef a question.

The companion cheat sheet

The Mobile development cheat sheet follows these stages in Flutter, React Native, Android and iOS editions, from your language's essentials to publishing. Revise a chapter after each stage, and keep the publishing chapter open on release day.

Related on Sefism

• How to choose between frontend, backend, mobile, cloud, security, data and AI
• Which final year project helps you get a job?
• How to build a developer portfolio as a beginner
• Library picks used in the stages: Flutter Documentation, Expo Documentation, Android Basics with Compose, 100 Days of SwiftUI and the Guide to App Architecture
• Related roadmaps: Frontend development, Backend development and UI/UX design

What you can do afterwards

Apply for mobile developer roles with an app real testers have installed, tests and an accessibility pass to talk about, take on freelance app work, or publish your own app as a product.

FAQ

How long does it take to learn mobile development? This roadmap is about 325 hours: around seven months at 12 hours a week or ten at 8, ending with a published app.

Flutter or React Native? The roadmap describes Flutter as one Dart codebase for both stores and React Native as one codebase if you already know React. Both cover Android and iOS; pick the one whose language you would rather spend a year in.

Do I need a Mac? The iOS option (Swift and SwiftUI) needs one, as the roadmap notes. With Flutter or React Native you can learn and test on Android without one.

Do I have to publish to a store? The final milestone asks for at least a Play closed test or a TestFlight beta, with one update shipped from tester feedback.