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
Null safety is one of Kotlin’s best features. Learn ? and ?: well, as they prevent many crashes.
Learn each topic here
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.
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
Learn to read Logcat. It shows errors and messages from your running app.
Learn each topic here
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.
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
Compose is now the recommended way to build Android UI. Focus on it instead of old XML layouts.
Learn each topic here
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.
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
Keep business logic in ViewModels, not in composables. It makes your app easier to test.
Learn each topic here
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.
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
Always run network calls on a background thread with coroutines, never on the main thread.
Learn each topic here
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.
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
Use Room for structured data and DataStore for small settings like theme or user preferences.
Learn each topic here
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.
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
Start by testing ViewModels. They hold most of your logic and are easy to test.
Learn each topic here
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.
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
Read Google Play policies carefully before submitting to avoid rejections.
Learn each topic here
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 productionFollowing a checklist makes your first release much smoother.
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.
Tip calculator
A simple Compose app with input and result.
Habit tracker
Lists, cards and adding habits.
News reader
Loads articles from an API with loading and error states.
Notes app
Room database, search and edit screens.
Expense tracker
Charts, categories, MVVM and tests.
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.