Capstone Projects — Android Course

What you'll build

This is where it all comes together. Reading about Android teaches you Android; building apps makes you a developer. These six projects grow from a single-screen calculator to a complete, publishable app — each one exercising a phase of everything you've learned. Finish them and you have a portfolio that proves you can ship.

#	Project	Puts into practice
1	Tip Calculator	State, input, layout, Material 3 (Phases 1–2)
2	To-Do App	Room, ViewModel, Flow, lists (Phases 2–4)
3	Weather / News	Retrofit, coroutines, loading & error states (Phase 4)
4	Multi-Screen App	Navigation, MVVM, repository (Phases 3–4)
5	Themed & Animated App	Theming, dark mode, animations (Phases 2 & 5)
6	Publish-Ready App	Hilt, testing, publishing (Phase 6)

How to work

Treat each project like a real one. Before coding, write a one-line goal and sketch the screens and the UI state. Build in vertical slices — one working feature at a time — and commit to git as you go. Reach back to the relevant module whenever you're stuck; that's what it's there for.

Key idea

The single most important habit: finish and polish a smaller app rather than abandoning a huge one half-built. One complete, tested, published app impresses far more than five unfinished experiments — to users and to anyone reviewing your work.

Project 1 · Tip Calculator

Goal: a single screen that splits a bill and computes a tip. It sounds trivial, and that's the point — you'll get a complete, correct app finished in an afternoon, cementing state, input, and layout. Read the bill and tip percentage as state; the totals are derived and update live:

TipCalculator.kt

@Composable
fun TipCalculator() {
    var bill by rememberSaveable { mutableStateOf("") }
    var tipPercent by rememberSaveable { mutableStateOf(15f) }

    val amount = bill.toDoubleOrNull() ?: 0.0
    val tip = amount * tipPercent / 100
    val total = amount + tip

    Column(Modifier.padding(24.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        OutlinedTextField(
            value = bill,
            onValueChange = { bill = it },
            label = { Text("Bill amount") },
            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
        )
        Text("Tip: ${tipPercent.roundToInt()}%")
        Slider(value = tipPercent, onValueChange = { tipPercent = it }, valueRange = 0f..30f)
        Text("Total: $%.2f".format(total), style = MaterialTheme.typography.headlineMedium)
    }
}

Stretch goals: a "split between N people" stepper, rounding options, and a Material 3 theme with your own colors.

Project 2 · To-Do App with Room

Goal: add, complete, and delete tasks that persist across launches. This is the classic app that ties the data layer to the UI. Model a Task entity, expose the list as a Flow from a DAO, drive it through a ViewModel, and render it with LazyColumn. Swipe-to-delete and an empty state make it feel real.

Tip

This project is the heart of the course in miniature: Room → Flow → ViewModel → StateFlow → LazyColumn. If you can build this cleanly from memory, you understand modern Android app architecture.

Project 3 · Weather / News App with Retrofit

Goal: fetch live data from a public API and display it. Pick a free API (a weather or news service), model the JSON as DTOs, call it from a coroutine, and — crucially — handle all three states: loading, success, and error. Add pull-to-refresh and a retry button. This is where your app connects to the wider world.

Project 4 · Multi-Screen MVVM App

Goal: combine everything into a proper multi-screen app — for example a recipe or movie browser with a list screen and a detail screen. Use Navigation Compose to move between them (passing an id), a repository that combines a network source with a Room cache for offline support, and a ViewModel per screen. This is a genuinely portfolio-worthy app.

Layer	What to build
`ui/`	List screen + Detail screen, each with its ViewModel and UI state
`data/`	Retrofit API, Room database, and a Repository combining them
Navigation	A NavHost with list → detail routes and type-safe arguments

Project 5 · Themed & Animated App

Goal: take one of your earlier apps and make it shine. Build a custom MaterialTheme with a real color palette, full dark-mode support, and dynamic color. Add purposeful motion: animated list items, smooth screen transitions, an expanding card, a delightful empty state. This project is about the craft that separates a working app from a polished one.

Project 6 · Publish-Ready Application

Goal: take your best project all the way to shippable. Wire dependencies with Hilt, add tests (unit tests for ViewModels, UI tests for the key flow), handle any runtime permissions, then build a signed release bundle and prepare a Play Store listing — icon, screenshots, and description. Whether or not you hit publish, going through the whole process is the capstone of the capstone.

Note

Publishing a real app — even a simple one — is a milestone few beginners reach. It demonstrates you can take an idea through design, implementation, testing, and delivery. That end-to-end ability is exactly what makes a developer employable.

Recap & next steps

Key takeaways

Build all six projects — each reinforces a phase and grows in scope from one screen to a full app.
Plan the UI state and screens before coding; build in vertical slices and use git.
The To-Do and Multi-Screen apps rehearse the full architecture: Room/Retrofit → repository → ViewModel → Compose.
Polish and finish a smaller app rather than abandoning a large one — completion is what counts.
Taking one project through Hilt, tests, and a signed release is the real capstone of your Android journey.

Quick check

1. Which project best rehearses the core data-to-UI architecture?

2. For the Weather/News app, which three states must you handle?

3. What gives the multi-screen app offline support?

4. The most valuable habit across all projects is…

5. What makes Project 6 the true capstone?

Congratulations — you've completed The Complete Android Course! 🎉 You started with a single @Composable and finished able to architect, build, test, and publish real apps with Jetpack Compose. The ecosystem keeps evolving, so keep building, read the official Android docs, and ship things you're proud of. The best Android developers are the ones who never stop making apps — now go build yours.