Foundations
Kotlin basics, Android Studio, Compose fundamentals, first screens, state, and debugging.
Android complete reference
From beginner to principal Android engineer.
This path is for learners who need a practical route, not a topic dump. It starts with zero Android assumptions, then moves through app building, production engineering, senior design, staff-level systems, and principal-level technical direction.
Content breakup
The curriculum is split by career capability, not by API list.
Junior app builder
Navigation, lists, forms, local persistence, networking, error states, and small app delivery.
Production engineer
Architecture, coroutines, Flow, Room, Hilt, testing, release quality, and maintainable code.
Senior engineer
System design for Android apps, modularization, performance, accessibility, security, and mentoring.
Staff engineer
Cross-team architecture, migration strategy, observability, platform ownership, and technical decision records.
Principal engineer
Long-term technical direction, engineering economics, platform strategy, org influence, and risk management.
Phases
Move forward only after visible proof.
Foundations
Set up the environment, learn Kotlin basics, build first Compose screens, and understand app structure.
- Kotlin syntax and null safety
- Android Studio workflow
- Compose UI and state
Junior app builder
Build useful apps that handle real user flows, device rotation, navigation, and data.
- Navigation and forms
- Lists and detail screens
- Networking and storage
Production engineer
Learn patterns that keep an app stable after users, bugs, product changes, and releases arrive.
- MVVM and app architecture
- Coroutines, Flow, Room, Hilt
- Unit and UI testing
Senior engineer
Own larger app areas, design reliable features, improve performance, and mentor other engineers.
- Modularization and APIs
- Performance and accessibility
- Code review and rollout quality
Staff engineer
Lead migrations, platform capabilities, quality systems, and architecture across multiple teams.
- Technical strategy
- Shared platform ownership
- Reliability and observability
Principal engineer
Set long-term direction, evaluate trade-offs economically, and reduce technical risk across product lines.
- Org-level technical direction
- Architecture governance
- Business-aware engineering
Portfolio spine
Build these apps as evidence.
Habit tracker
Beginner app screenshot rendered in HTML.
Business catalogue
Junior app with search, filters, and detail entry points.
Production task app
States for loading, cache, sync, and failure handling.
| Stage | Project | Proof expected |
|---|---|---|
| Beginner | Habit tracker | Multiple Compose screens, state, navigation, local saving. |
| Junior | Local business catalogue | Lists, detail pages, search/filter, offline-first basics. |
| Production | API-backed task manager | Architecture, repository layer, Room cache, tests, loading/error states. |
| Senior | Modular marketplace app | Feature modules, performance traces, accessibility checks, release notes. |
| Staff | Migration case study | Legacy-to-Compose plan, rollout strategy, metrics, ADRs, risk register. |
| Principal | Mobile platform strategy | Three-year direction, investment trade-offs, team topology, reliability model. |
Assessment gates
The roadmap should make skill visible.
A beginner-friendly guide fails if it only explains concepts. Each phase has an exit gate so the learner knows whether they can actually use the material.
- Explain it: describe the concept without reading notes.
- Build it: ship a small working feature using the concept.
- Debug it: fix at least three realistic failure cases.
- Test it: prove the critical behavior stays correct.
- Review it: explain trade-offs and limitations in writing.