Last updated: 13 November 2026. Rewritten for Kotlin and Jetpack Compose, the way new Android apps are built today.
This is the order I'd learn Android development in if I were starting today. I built my first apps in Java with XML layouts. Since then I've published apps on Google Play with more than 20,000 downloads combined, led the Android track at Google Developer Groups PESCE, and now work as an Android developer. Some of what I learned early is no longer how Android apps are built, so this roadmap is based on the current, official way: Kotlin and Jetpack Compose.
Each stage lists what to learn, the best free resource I know for it, and a small project to prove you've got it. Don't move on until you've built the project.
Contents
- Set up Android Studio
- Learn Kotlin basics
- Build screens with Jetpack Compose
- State, ViewModel and app architecture
- Navigation between screens
- Save data locally with Room and DataStore
- Talk to the internet with Retrofit
- Firebase for login and cloud data
- Git, testing and debugging
- Publish on Google Play
- Practice projects
- Should you still learn Java and XML?
1. Set up Android Studio
Android Studio is the only IDE you need. It ships with its own Java runtime, the Android SDK and an emulator, so you don't have to install a JDK separately.
- Learn: creating a project from the Empty Activity template, running it on the emulator and on your own phone with USB debugging, and reading Logcat.
- Guide: my step-by-step post How to Install Android Studio on Windows and Ubuntu.
- Tip: the emulator needs a lot of RAM. On a machine with 8 GB, a real phone over USB is often faster.
2. Learn Kotlin basics
Kotlin is Google's recommended language for Android. You don't need to master it first. Learn enough to read and write simple code, then keep learning as you build.
- Learn:
valvsvar, functions,ifandwhen, lists and maps, classes and data classes, null safety (?,?.,?:) and lambdas. - Resource: the free Android Basics with Compose course starts with Kotlin, and Kotlin Playground lets you practise in the browser.
- Prove it: write a small console program that stores a list of tasks and prints the unfinished ones.
data class Task(val title: String, val done: Boolean = false)
fun main() {
val tasks = listOf(Task("Install Android Studio", done = true), Task("Learn Compose"))
tasks.filter { !it.done }.forEach { println(it.title) }
}
3. Build screens with Jetpack Compose
Compose is the modern way to build Android UI. You describe the screen in Kotlin functions instead of XML files, and the screen updates automatically when your data changes.
- Learn:
@Composablefunctions,Column,Row,Box,Text,Button,Image,Modifier(padding, size, click),LazyColumnfor lists, and Material 3 theming. - Resource: units 1–3 of Android Basics with Compose, and the Compose layout basics docs.
- Prove it: a profile card screen with your photo, name and three buttons, then a scrolling list of 20 items.
@Composable
fun Greeting(name: String) {
var count by remember { mutableStateOf(0) }
Column(Modifier.padding(16.dp)) {
Text("Hello, $name! You tapped $count times.")
Button(onClick = { count++ }) { Text("Tap me") }
}
}
4. State, ViewModel and app architecture
This is where most beginners get stuck. Your screen should only show data. A ViewModel should own it, so it survives screen rotation and stays testable.
- Learn:
rememberandmutableStateOf, state hoisting,ViewModel,StateFlowandcollectAsStateWithLifecycle(), and the basic layers: UI → ViewModel → Repository → data source. - Resource: the official Guide to app architecture.
- Prove it: a counter or tip calculator where the value survives rotating the phone.
5. Navigation between screens
- Learn: Navigation Compose: a
NavHost, routes, passing an ID to a detail screen, and the back stack. - Resource: Navigation with Compose.
- Prove it: a list screen where tapping an item opens its detail screen, and Back returns to the list.
6. Save data locally with Room and DataStore
- Learn: Room for structured data (entities, DAOs, queries returning
Flow) and DataStore for small settings such as dark mode. Kotlin coroutines (suspend,viewModelScope.launch) come in here. - Resource: Save data using Room.
- Prove it: a notes app where notes are still there after you close and reopen it.
7. Talk to the internet with Retrofit
- Learn: REST basics (GET, POST, JSON), Retrofit with kotlinx.serialization, showing loading and error states, and loading images with Coil. Add the
INTERNETpermission to the manifest. - Tip: while learning, you can fake an API on your own machine with Mockoon. See my post How to Install Mockoon and Create REST APIs.
- Prove it: a weather or news app that loads data from a public API, shows a spinner while loading, and a retry button when offline.
8. Firebase for login and cloud data
Firebase lets you add sign-in and a cloud database without writing a backend, which makes it the quickest way to give a beginner app real users and real data.
- Learn: Firebase Authentication (email and Google sign-in), Cloud Firestore, Cloud Storage for images, and security rules so users can only read and write their own data.
- Guide: my Firebase Series: Auth, Firestore, Storage & Hosting.
- Prove it: add login to your notes app and sync notes to Firestore.
9. Git, testing and debugging
- Git: commit every working step and push your projects to GitHub. Recruiters look at it. Guide: Pushing Files to GitHub from the Terminal.
- Debugging: breakpoints, Logcat filters, and the Layout Inspector for Compose.
- Testing: unit tests for your ViewModel with JUnit, then a simple Compose UI test. Read Fundamentals of testing Android apps.
10. Publish on Google Play
Publishing is a skill of its own. These are the steps beginners most often miss:
- Developer account: a one-time US$25 fee and identity verification.
- Closed testing for new personal accounts: before you can publish to everyone, you must run a closed test with at least 12 testers who stay opted in for 14 continuous days. Line up friends or classmates before you start.
- Release build: build a signed Android App Bundle (
.aab), not an APK, and let Play App Signing manage your key. - Store listing: icon, screenshots, short and full description, and a privacy policy URL. A Data safety form and content rating questionnaire are required.
- Target API level: Google Play requires apps to target a recent Android version, and the minimum rises every year. Check the current requirement before you upload.
- Earning: AdMob ads or in-app purchases through Google Play Billing. Start with a useful app first; monetise once people use it.
Practice projects, from easy to harder
Build these in order. Each one reuses what the last one taught you, and together they make a solid GitHub portfolio.
For more ideas with feature lists and the libraries to use, see 10 Android App Ideas for Beginners.
| Project | What it practises |
|---|---|
| Tip calculator | Compose layout, text input, state |
| Quiz app | Lists, ViewModel, navigation, scoring logic |
| Habit or mood tracker | Room database, dates, simple charts |
| Expense tracker | Room, categories, totals per month, DataStore settings |
| Weather app | Retrofit, JSON, loading and error states, location permission |
| Recipe or movie browser | Paging through an API, image loading with Coil, search |
| Chat or notes app with login | Firebase Auth, Firestore real-time updates, security rules |
Should you still learn Java and XML?
Not first. New Android projects use Kotlin and Compose, and that's what the official courses teach. But many existing apps and company codebases still use Java and XML layouts, so being able to read them helps when you join a team. My Android UI Kit app (my own app) is a collection of Java and XML UI snippets, if you want examples of the older style.
Where to go from here
Start with stage 1 today: install Android Studio, then build your first screen with Create Your First Android App. If you get stuck on any stage, leave a comment with the error you're seeing and I'll help.

Thank you sir
ReplyDelete💙😍
Delete