Mobile

Android Developer Roadmap: Step-by-Step Guide for 2026

This Android developer roadmap shows you how to build native Android apps with Kotlin and Jetpack Compose, from language basics to architecture, data, testing and publishing on Google Play.

Steps8Time6 to 9 monthsLevelBeginner to job-ready

What is an Android Developer?

An Android developer builds apps for phones, tablets and other devices that run Android. They design screens, connect to APIs, store data, handle permissions and publish apps on Google Play.

Modern Android development uses Kotlin and Jetpack Compose, with Android Studio as the main tool. Android developers work at product companies, agencies, startups and as freelancers.

How to use this Android Developer roadmap

Follow this Android developer roadmap from top to bottom. Kotlin comes first because everything else is written in it.

Build one app that grows through the roadmap, such as a habit tracker, and add a new feature with each step.

1Step 1: Kotlin fundamentals

Learn the official language for Android development.

What is it?

Kotlin is a modern, concise language. It is fully supported by Google for Android and avoids many common errors through null safety.

What to learn

Variables and typesFunctionsNull safetyClasses and data classesCollections and lambdas

Null safety is one of Kotlin’s best features. Learn ? and ?: well, as they prevent many crashes.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
Variables and types

Kotlin uses val for read-only values and var for values that change. Types are usually inferred.

kotlin

val name = "Sara"
var count = 0
count++
Functions

Functions are declared with fun and can have default and named parameters.

kotlin

fun greet(name: String, title: String = "Mr") = "Hello $title $name"
Null safety

Kotlin types cannot be null unless marked with ?. Use ?. and ?: to handle missing values safely and avoid crashes.

kotlin

val city: String? = null
println(city?.length ?: 0)
Classes and data classes

Data classes hold data with automatic equals, copy and toString.

kotlin

data class User(val id: Int, val name: String)
val u2 = User(1, "Sara").copy(name = "Ali")
Collections and lambdas

Lists, sets and maps with lambdas like filter and map make data handling short and clear.

kotlin

val cheap = products.filter { it.price < 10 }.map { it.name }

Example

kotlin

data class Habit(val name: String, val daysDone: Int = 0)

fun main() {
    val habits = listOf(Habit("Read", 5), Habit("Walk", 3))
    val best = habits.maxByOrNull { it.daysDone }
    println(best?.name ?: "No habits")
}

This finds the habit done on the most days and prints its name safely.

Practice project: Write small Kotlin programs: a tip calculator, a to-do list and a grade calculator.

Helpful resource: Kotlin documentation

2Step 2: Android Studio and app basics

Set up your tools and understand how an Android app is structured.

What is it?

An Android app is made of components such as activities, declared in the manifest, with resources like strings and images in separate folders.

What to learn

Android StudioEmulatorGradleActivitiesApp manifestResources

Learn to read Logcat. It shows errors and messages from your running app.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
Android Studio

Android Studio is the official IDE for Android, with code editing, layout previews, emulators, debugging and profiling.

Emulator

The emulator runs virtual Android devices of different sizes and versions so you can test without many phones.

Gradle

Gradle builds your app and manages dependencies (libraries) in build.gradle.kts.

kotlin

dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.11.0")
}
Activities

An Activity is an entry screen of an Android app. Modern Compose apps usually have one Activity and switch screens with navigation.

App manifest

AndroidManifest.xml declares the app’s name, icon, screens and permissions such as internet or camera.

Resources

Resources are files outside code: strings, colours, images and fonts in the res folder. Keeping text in strings.xml makes translation easy.

Example

xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-permission android:name="android.permission.INTERNET" />
    <application android:label="Habit Tracker">
        <activity android:name=".MainActivity" android:exported="true" />
    </application>
</manifest>

The manifest tells Android the app’s name, screens and permissions such as internet access.

Practice project: Create a new project, run it on the emulator and on a real phone.

Helpful resource: Android Developers courses

3Step 3: Jetpack Compose UI

Build modern user interfaces with Compose.

What is it?

Jetpack Compose builds UI from small functions called composables. When data changes, Compose updates the screen automatically.

What to learn

ComposablesLayouts (Row, Column, Box)ModifiersLists with LazyColumnMaterial 3Theming

Compose is now the recommended way to build Android UI. Focus on it instead of old XML layouts.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
Composables

Composables are Kotlin functions annotated with @Composable that describe UI. When data changes, Compose redraws them.

kotlin

@Composable
fun Greeting(name: String) { Text("Hello $name") }
Layouts (Row, Column, Box)

Row arranges items horizontally, Column vertically and Box stacks them on top of each other.

kotlin

Column { Text("Title"); Row { Icon(Icons.Default.Star, null); Text("4.8") } }
Modifiers

Modifiers change size, padding, background and click behaviour of composables. Order matters.

kotlin

Text("Buy", Modifier.padding(16.dp).background(Color.Black).clickable { buy() })
Lists with LazyColumn

LazyColumn shows long scrollable lists efficiently, only composing visible items.

kotlin

LazyColumn { items(products) { p -> Text(p.name) } }
Material 3

Material 3 is Google’s latest design system with ready components like buttons, cards and top bars.

Theming

Define colours, typography and shapes once in a theme, including dynamic colour and dark mode.

Example

kotlin

@Composable
fun HabitRow(habit: Habit) {
    Row(Modifier.fillMaxWidth().padding(16.dp)) {
        Text(habit.name, Modifier.weight(1f))
        Text("${habit.daysDone} days")
    }
}

This composable shows one habit with its name on the left and days on the right.

Practice project: Build the habit list screen with cards, a header and a floating add button.

Helpful resource: Jetpack Compose

4Step 4: State, navigation and architecture

Structure apps so they are easy to grow and test.

What is it?

A ViewModel holds screen data and survives screen rotations. The UI observes its state and redraws when it changes.

What to learn

State and rememberViewModelMVVMNavigation ComposeDependency injection (Hilt)

Keep business logic in ViewModels, not in composables. It makes your app easier to test.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
State and remember

State holds changing data; remember keeps it across recompositions.

kotlin

var count by remember { mutableStateOf(0) }
Button(onClick = { count++ }) { Text("$count") }
ViewModel

A ViewModel stores screen data and logic and survives rotation. The UI observes its state.

MVVM

Model–View–ViewModel separates data (Model), UI (View) and presentation logic (ViewModel), making apps easier to test and grow.

Navigation Compose

Navigation Compose defines routes and moves between screens.

kotlin

NavHost(nav, startDestination = "home") {
    composable("home") { Home(nav) }
    composable("details/{id}") { Details(it.arguments?.getString("id")) }
}
Dependency injection (Hilt)

Hilt automatically provides objects like repositories and API clients to ViewModels, reducing boilerplate and making testing easier.

Example

kotlin

class HabitViewModel : ViewModel() {
    private val _habits = MutableStateFlow(listOf<Habit>())
    val habits = _habits.asStateFlow()

    fun add(name: String) {
        _habits.value = _habits.value + Habit(name)
    }
}

The UI collects habits and updates when add() changes the list.

Practice project: Add a ViewModel and a second screen to add new habits.

Helpful resource: Guide to app architecture

5Step 5: Networking and APIs

Load data from the internet.

What is it?

Retrofit turns an API into Kotlin functions. Coroutines let you call them without freezing the screen.

What to learn

REST APIsRetrofitJSON parsingCoroutinesError handling

Always run network calls on a background thread with coroutines, never on the main thread.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
REST APIs

Most apps load data from REST APIs using HTTP requests that return JSON.

Retrofit

Retrofit turns an API into a Kotlin interface.

kotlin

interface Api {
    @GET("products") suspend fun products(): List<Product>
}
JSON parsing

Libraries such as kotlinx.serialization or Moshi convert JSON into Kotlin data classes automatically.

Coroutines

Coroutines run long tasks like network calls in the background without blocking the UI.

kotlin

viewModelScope.launch { _items.value = api.products() }
Error handling

Catch exceptions from network calls and expose loading, success and error states to the UI.

Example

kotlin

interface QuoteApi {
    @GET("quotes/random")
    suspend fun random(): Quote
}

viewModelScope.launch {
    val quote = api.random()
}

The suspend function waits for the network in the background while the UI stays smooth.

Practice project: Show daily motivational quotes in your app from a public API.

Helpful resource: Kotlin coroutines on Android

6Step 6: Local data storage

Save data on the device so the app works offline.

What is it?

Room is a library that makes it easy to save data in a local SQLite database using Kotlin classes.

What to learn

Room databaseDataStoreRepository patternFlowsOffline-first basics

Use Room for structured data and DataStore for small settings like theme or user preferences.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
Room database

Room is a SQLite library with compile-time checked queries.

kotlin

@Dao interface NoteDao {
    @Query("SELECT * FROM notes") fun all(): Flow<List<Note>>
}
DataStore

DataStore saves small settings like theme or login state, replacing SharedPreferences.

Repository pattern

A repository is one place that decides whether data comes from the network or local database, so the rest of the app does not care.

Flows

Flows are streams of values over time; the UI collects them and updates automatically when data changes.

Offline-first basics

Show saved data from the local database first, then refresh from the network, so the app works with poor connections.

Example

kotlin

@Entity
data class HabitEntity(@PrimaryKey(autoGenerate = true) val id: Int = 0, val name: String)

@Dao
interface HabitDao {
    @Query("SELECT * FROM HabitEntity")
    fun all(): Flow<List<HabitEntity>>
}

The DAO returns a Flow, so the UI updates whenever data changes.

Practice project: Store habits in a Room database so they stay after the app closes.

Helpful resource: Room database guide

7Step 7: Testing and app quality

Make your app reliable and fast.

What is it?

Tests check your code automatically so changes do not break existing features.

What to learn

Unit testsCompose UI testsDebuggingPerformanceAccessibility

Start by testing ViewModels. They hold most of your logic and are easy to test.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
Unit tests

Test ViewModels and logic with JUnit, which run fast on your computer.

Compose UI tests

Compose testing finds UI elements, performs clicks and checks results.

kotlin

composeRule.onNodeWithText("Add").performClick()
composeRule.onNodeWithText("1").assertExists()
Debugging

Use breakpoints, Logcat and the Layout Inspector in Android Studio to find bugs.

Performance

Profile CPU, memory and frame rendering, avoid heavy work on the main thread and keep lists lazy.

Accessibility

Add content descriptions to icons and images, support large text and test with TalkBack, Android’s screen reader.

Example

kotlin

@Test
fun addHabit_increasesList() {
    val vm = HabitViewModel()
    vm.add("Read")
    assertEquals(1, vm.habits.value.size)
}

This test confirms that adding a habit adds one item to the list.

Practice project: Write unit tests for your ViewModel and one UI test for the add-habit screen.

Helpful resource: Testing on Android

8Step 8: Publishing on Google Play

Prepare, release and update your app.

What is it?

Publishing means building a signed release version and uploading it to the Google Play Console with a store listing.

What to learn

App signingRelease buildsPlay ConsoleStore listingPrivacy policyUpdates and crash reports

Read Google Play policies carefully before submitting to avoid rejections.

Learn each topic here

Tap a topic to open a full explanation with examples, no need to go anywhere else.
App signing

Apps must be signed with a private key to prove they come from you. Google Play App Signing keeps the key safe.

Release builds

Release builds are optimised and shrunk with R8, producing an Android App Bundle (.aab) for Google Play.

Play Console

Google Play Console is where you upload builds, run test tracks and roll out releases.

Store listing

Write a clear title and description and add an icon, feature graphic and screenshots.

Privacy policy

Provide a privacy policy URL and complete the Data safety form describing what data you collect.

Updates and crash reports

Use staged rollouts for updates and monitor crashes with Play Console vitals or Firebase Crashlytics.

Example

text

Release checklist
[ ] App icon and screenshots
[ ] Short and full description
[ ] Privacy policy URL
[ ] Signed release bundle (.aab)
[ ] Content rating and data safety form
[ ] Internal test before production

Following a checklist makes your first release much smoother.

Practice project: Publish your app to an internal testing track and share it with friends.

Helpful resource: Publish your app

Android 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.

Beginner

Tip calculator

A simple Compose app with input and result.

Beginner

Habit tracker

Lists, cards and adding habits.

Intermediate

News reader

Loads articles from an API with loading and error states.

Intermediate

Notes app

Room database, search and edit screens.

Advanced

Expense tracker

Charts, categories, MVVM and tests.

Advanced

Published app

A polished app released on Google Play.

Tips to finish this android 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 android developer roadmap change slowly. Master them first, then explore new libraries.

Career paths and next steps

After this Android developer roadmap, you can apply for junior Android developer or mobile developer roles. Later you can become a senior Android engineer, mobile lead or move into cross-platform development.

For cross-platform skills, see the Flutter roadmap or the mobile app developer roadmap.

Related roadmaps

Android Developer Roadmap FAQs

Should I learn Kotlin or Java for Android?

Kotlin is the recommended language for new Android development. Java knowledge still helps with older projects.

Is Jetpack Compose required?

Compose is the modern standard for Android UI, and most new projects use it.

How long does it take to become an Android developer?

With steady practice, many learners become job-ready in six to nine months.

Do I need a Mac for Android development?

No. Android Studio runs on Windows, macOS and Linux.