An Android development roadmap for 2026 using the modern toolkit - Kotlin, Jetpack Compose, coroutines, MVVM architecture, Room, networking, testing and release to Google Play.
8 stages
9-14 months part time
Kotlin and Compose
Realistic timeline
9-14 months at 10-15 hours per week
Stages
8 in order
Starting point
Complete beginner
Android developers build the apps that run on billions of phones, tablets, watches and TVs. Modern Android development is centred on Kotlin and Jetpack Compose, Google's declarative UI toolkit, supported by a set of Jetpack libraries for architecture, data and background work.
This Android developer roadmap follows that modern toolkit rather than older patterns you would have to unlearn. It assumes no prior experience, but if you have never programmed before, the first stages of the software developer roadmap are a useful companion.
Overview
Android development roadmap overview
Eight stages from your first Kotlin file to an app on Google Play.
Select a stage to see what it covers. Filter by level to focus.
1. Kotlin fundamentals
6-8 weeks
Write idiomatic Kotlin, including null safety and collections.
Variables, types and null safety
Functions, lambdas and higher-order functions
Classes, data classes and interfaces
Collections and their operations
Sealed classes and enums
Git and GitHub basics
Done when: A console app that manages a list of items with filtering and sorting, written in idiomatic Kotlin.
Each stage ends with a working app feature. Build on the same project where you can.
1
Foundation · Beginner
Kotlin fundamentals
6-8 weeks
Write idiomatic Kotlin, including null safety and collections.
Kotlin is Google's recommended language for Android. Learn its syntax, null safety, data classes, collections and lambdas, and practise in small console programs before touching Android. Understanding classes, interfaces and higher-order functions now will make Compose and architecture code much easier to read later.
Skills
Variables, types and null safety
Functions, lambdas and higher-order functions
Classes, data classes and interfaces
Collections and their operations
Sealed classes and enums
Git and GitHub basics
Milestone
A console app that manages a list of items with filtering and sorting, written in idiomatic Kotlin.
Project ideas
A console contact book
A unit converter in Kotlin
2
Tools · Beginner
Android Studio and app basics
4-5 weeks
Create, run and debug a simple app on an emulator and a real phone.
Get comfortable in Android Studio: project structure, Gradle build files, the emulator, Logcat and the debugger. Learn the Android fundamentals every app relies on - the manifest, activities, the app lifecycle, resources and permissions - so that the behaviour of your app when it is rotated, backgrounded or killed makes sense.
Skills
Android Studio, emulator and device debugging
Project structure and Gradle basics
Manifest, activities and the lifecycle
Resources: strings, images and themes
Runtime permissions
Logcat and the debugger
Milestone
An app running on a physical device that survives rotation without losing state.
Project ideas
A tip calculator app
3
Core skills · Beginner
Building UI with Jetpack Compose
6-8 weeks
Build responsive, accessible screens with Compose and Material Design.
Compose describes the UI as functions of state. Learn composables, layouts, modifiers, lists, state and recomposition, and Material 3 components and theming. Add navigation between screens, and test your layouts on different screen sizes. Accessibility - content descriptions, touch target sizes and contrast - should be part of every screen from the start.
Skills
Composables, layouts and modifiers
State, remember and state hoisting
Lazy lists and grids
Material 3 components and theming
Navigation in Compose
Accessibility and adaptive layouts
Milestone
A multi-screen app with a list, a detail screen and a settings screen, following Material guidelines.
Project ideas
A recipe browser with local data
A habit tracker UI
4
Core skills · Intermediate
Architecture and asynchronous code
6-8 weeks
Structure apps so UI, logic and data are cleanly separated and testable.
Follow Google's recommended app architecture: a UI layer with ViewModels exposing state, an optional domain layer, and a data layer of repositories. Learn Kotlin coroutines and Flow for background work and streams of data, and dependency injection with Hilt so components are easy to replace in tests.
Skills
ViewModel and unidirectional data flow
UI state modelling
Repositories and the data layer
Coroutines, scopes and dispatchers
Flow and StateFlow
Dependency injection with Hilt
Milestone
Refactor your Compose app into ViewModels and repositories with no business logic in composables.
Project ideas
Rebuild the habit tracker with MVVM and Hilt
5
Frameworks · Intermediate
Data, networking and background work
6-8 weeks
Load data from APIs, store it locally and keep the app useful offline.
Most apps talk to a server. Learn Retrofit or Ktor for HTTP, JSON serialisation with kotlinx.serialization, and Room for local databases. Combine them into an offline-first pattern where the database is the source of truth. Use DataStore for preferences and WorkManager for reliable background tasks. The backend developer roadmap explains the server side of these APIs.
Skills
Retrofit or Ktor client
kotlinx.serialization
Room database, DAOs and migrations
Offline-first repositories
DataStore for preferences
WorkManager for background jobs
Milestone
An app that fetches from a public API, caches results in Room and works without a connection.
Project ideas
A weather app using a [free weather API](/apis/weather-apis)
A news reader with offline cache
6
Advanced topics · Advanced
Testing, performance and security
6-8 weeks
Ship apps that are tested, smooth and safe with user data.
Write unit tests for ViewModels and repositories, and UI tests for Compose screens. Learn to use the profilers to find slow startup, janky scrolling and memory leaks, and apply baseline profiles. Handle data securely: encrypted storage where needed, network security configuration, and careful handling of permissions and personal data.
Skills
Unit tests with JUnit and coroutine test tools
Compose UI testing
Android Studio profilers
Startup and rendering performance
Secure storage and network security
Privacy and permission best practices
Milestone
A test suite covering core logic, and a measured improvement in startup time or scrolling smoothness.
Project ideas
Add tests and a performance report to your news reader
7
Portfolio · Advanced
Publishing on Google Play
4-6 weeks
Release an app, manage updates and respond to real users.
Learn app signing, release builds, code shrinking, and the Google Play Console: store listings, testing tracks, policy requirements and crash reports. Publishing requires a Play developer account and following Google Play policies, so read the current requirements before you plan a launch. Add analytics and crash reporting responsibly, with clear privacy disclosures.
Skills
Release builds, signing and shrinking
Play Console, testing tracks and store listing
Play policy and data safety requirements
Crash reporting and vitals
Versioning and staged rollouts
CI builds with GitHub Actions
Milestone
An app live on Google Play, or in a public testing track, with at least one update shipped.
Project ideas
Publish your strongest app with a proper store listing
8
Job ready · Advanced
Portfolio and interview preparation
4-6 weeks
Present polished apps and explain your architecture decisions.
Android interviews usually include Kotlin coding, lifecycle and architecture questions, and a take-home or live app exercise. Prepare clean repositories with README screenshots and architecture diagrams, and be ready to discuss trade-offs such as state management and offline handling.
Skills
Kotlin coding exercises
Lifecycle, configuration change and process death
Architecture and state management discussion
Take-home app best practices
Explaining testing strategy
Milestone
Two to three polished apps with READMEs, tests and screenshots, and practised explanations.
Project ideas
A portfolio page with store links and demo videos
Progression
Android developer skills by level
What each level looks like in practice, so you know where you stand.
Beginner
Months 0-4
You can write Kotlin and build simple multi-screen apps with Compose.
Focus on
Kotlin basics
Android Studio
Activity lifecycle
Compose layouts and state
You can: Build and run a multi-screen app.
Intermediate
Months 4-9
You build well-structured apps that load, store and sync data.
Focus on
MVVM and Hilt
Coroutines and Flow
Retrofit and Room
Offline-first design
You can: Ship an app backed by a real API.
Advanced
Months 9-14
You test, optimise, secure and publish apps with confidence.
Focus on
Unit and UI testing
Profiling and performance
Security and privacy
Play Console releases
You can: Publish and maintain a production app.
Technologies
Android development tools and libraries
Dark chips are worth learning early. Light chips can wait until a project needs them.
Language and IDE
The standard modern setup.
Start with
Kotlin
Android Studio
Gradle
Add later or when needed
Java (for legacy code)
Kotlin Multiplatform
User interface
Compose first; views for older codebases.
Start with
Jetpack Compose
Material 3
Navigation Compose
Add later or when needed
XML Views
Compose animations
Wear OS and TV UI
Architecture
Recommended app architecture components.
Start with
ViewModel
Coroutines and Flow
Hilt
Add later or when needed
Paging 3
Modularisation
Koin
Data and networking
Talking to servers and storing locally.
Start with
Retrofit or Ktor
Room
DataStore
Add later or when needed
WorkManager
Firebase
GraphQL clients
Quality
Testing and performance tooling.
Start with
JUnit
Compose UI tests
Android Studio profiler
Add later or when needed
Baseline profiles
Macrobenchmark
Detekt or ktlint
Release
Getting apps to users.
Start with
Google Play Console
App signing
Add later or when needed
GitHub Actions
Crash reporting tools
In-app updates
Priorities
What to learn first, and what can wait
Focus beats coverage. These lists keep the first months pointed at what pays off.
Learn these first
1Kotlin fundamentals, especially null safety and collections
2Android Studio, the emulator and Logcat
3The activity lifecycle and configuration changes
4Compose basics: composables, state and lists
5ViewModel and a simple repository
Safe to skip at the start
XML layoutsLearn them later if a job uses older code. New apps are built with Compose.
Java for AndroidUseful for legacy projects, but Kotlin is the modern default.
Kotlin MultiplatformValuable once you know Android well, not before.
Complex multi-module setupsModularisation pays off in large codebases, not first apps.
Custom views and canvas drawingSpecialised work that few beginner apps need.
Projects
Android developer projects
Ordered by difficulty. Two or three finished ones beat ten half-built ones.
Beginner
Tip and split calculator
A single-screen Compose app with input validation and state that survives rotation.
Compose
State
Beginner
Habit tracker
Lists, detail screens and navigation with local sample data.
Navigation
Material 3
Intermediate
Offline weather app
Fetch forecasts from a public API, cache them in Room and refresh in the background.
Retrofit
Room
WorkManager
Intermediate
Expense tracker with charts
MVVM architecture, Room, DataStore settings and simple charts.
MVVM
Hilt
Room
Advanced
Chat or social app
Authentication, real-time updates, notifications and image upload with a hosted backend.
Firebase or custom API
Notifications
Advanced
Published production app
A tested, profiled app live on Google Play with crash reporting and staged rollouts.
Testing
Play Console
Avoid these
Common mistakes
Patterns that slow most learners down, and what to do instead.
Following outdated tutorials
Many older guides use Java, XML layouts and deprecated libraries. Check the publication date and prefer current official material.
Logic inside composables
Putting network calls or business rules in UI functions makes apps fragile. Keep them in ViewModels and repositories.
Ignoring the lifecycle
Lost state after rotation or process death is a classic bug. Test these scenarios deliberately.
Blocking the main thread
Network or database work on the main thread causes freezes. Use coroutines with appropriate dispatchers.
Only testing on the emulator
Real devices reveal performance, permission and screen-size issues. Test on at least one physical phone.
Hard-coding API keys
Keys in the app package can be extracted. Keep secrets on a server where possible.
Career
Android development career path
Portfolio, interviews and the checklist to review before you apply.
Android roles exist in product companies, agencies and freelance work. Employers look for modern Kotlin and Compose skills, sound architecture and published apps. Strong general engineering from the software development roadmap and API knowledge from the backend roadmap make you stand out.
Typical job titles
Android Developer
Mobile Developer
Kotlin Developer
Android Engineer
Mobile Software Engineer
Job-ready checklist
You write idiomatic Kotlin and use coroutines correctly
You build UIs with Jetpack Compose and Material 3
You structure apps with ViewModels, repositories and DI
You have written unit and UI tests
You have published or publicly tested an app
Portfolio guidance
Two or three polished apps rather than many small demos
Screenshots and a short screen recording in each README
An architecture diagram and explanation of decisions
Tests and CI visible in the repository
A Google Play link where possible
Interview preparation
Kotlin language questions and coding tasks
Activity lifecycle and process death
Compose state and recomposition
Architecture, DI and offline-first design
Walking through a take-home project
Resources
Where to learn each part
References worth keeping open, plus the pages here that go deeper.
If you want to connect, please WhatsApp: 3265503569
One-to-one mentorship for the roadmaps on Fox Is Happy is being set up. Sessions will cover code review, project feedback, interview preparation and a learning plan matched to where you actually are - not where a generic curriculum assumes you are.
Pricing will be reasonable and listed clearly before you book - pay per session, with student-friendly rates planned. No subscriptions and no bundles you do not need.
Register interest
3265503569
WhatsApp only. Message on WhatsApp to register interest and be told first when places open.
Mention Android Developer Roadmap in your message so the reply matches what you are working on.
Building a career in Android development
Android is the most widely used mobile operating system in the world, and apps remain central to how people bank, shop, travel and communicate. The platform has also become much more pleasant to develop for in recent years.
Why Kotlin and Jetpack Compose
Google recommends Kotlin for Android development and Compose for building new user interfaces. Kotlin is concise and null-safe, which removes a whole class of crashes. Compose replaces XML layouts with Kotlin functions that describe what the UI should look like for a given state, which makes screens simpler to build and test. You will still meet Java and XML in older codebases, so learn to read them eventually.
The recommended app architecture
Well-structured Android apps separate responsibilities into layers. This makes them easier to test and change.
Layers of a modern Android app
Layer
Responsibility
Typical tools
UI layer
Display state and send user events
Compose, ViewModel, StateFlow
Domain layer (optional)
Reusable business logic
Use case classes
Data layer
Fetch, store and expose data
Repositories, Room, Retrofit or Ktor, DataStore
How long does it take to become an Android developer?
With no programming experience, nine to fourteen months of part-time study is realistic to reach junior level. Developers coming from another language can often build solid apps within three to five months. Publishing a real app noticeably strengthens job applications.
Android or cross-platform?
Frameworks like Flutter, React Native and Kotlin Multiplatform let you share code across Android and iOS. They are useful, but native Android knowledge remains valuable because cross-platform apps still run on Android and hit platform-specific issues. Learning native Android first gives you a solid base for any of them.
A structured learning plan for building Android apps. This one covers Kotlin, Android Studio, Jetpack Compose, architecture, data and networking, testing, performance and publishing on Google Play.
Should I learn Kotlin or Java for Android?
Kotlin. It is Google's recommended language for Android and is used in most new projects. Learn to read Java later if you work on older codebases.
Is Jetpack Compose enough, or do I need XML layouts?
Compose is enough to build new apps and is the modern standard. Many companies still maintain XML-based screens, so basic familiarity with views helps in some jobs.
Do I need a powerful computer for Android development?
Android Studio and the emulator are resource-hungry. A machine with plenty of RAM and an SSD makes a big difference. Testing on a physical phone reduces the load.
Does it cost money to publish an Android app?
Publishing on Google Play requires a developer account with a one-time registration fee and identity verification. Check Google Play Console for the current requirements.
What Android projects should I build for my portfolio?
An offline-capable app that uses a real API, an app with clean MVVM architecture and tests, and ideally one app published on Google Play.
