AND

Junior → Architect → Beyond

Engineer Roadmap

A level-graded path through everything in this guide. Each stage lists what you can already do and what to learn next — and every flashcard is tagged with its level so you can drill exactly where you are.

  1. 1

    Junior

    Build & ship features with guidance.

    You build screens and ship features with guidance. The goal is fluency in the fundamentals — Kotlin basics, composables, simple state, lists, and navigation — so you can deliver a working screen end to end.

    You can already

    • ✓Write idiomatic Kotlin: val/var, null-safety (?., ?:), data classes, and when expressions.
    • ✓Build UI with Compose: Column/Row/Box, Material 3 components, and Modifiers.
    • ✓Hold simple UI state with remember / mutableStateOf and hoist it to a stateless composable.
    • ✓Show a list with LazyColumn and navigate between screens with Navigation-Compose.
    • ✓Fetch data with a suspend function and render loading / error / empty states.

    Level up by

    • →Coroutines basics: viewModelScope, Dispatchers, and main-safety with withContext.
    • →ViewModel + StateFlow, and collectAsStateWithLifecycle for safe collection.
    • →The Activity lifecycle and why configuration changes recreate the screen.
    • →Your first unit test with JUnit + MockK, and a Compose UI test.
    Drill the flashcards filtered to Junior, plus the Kotlin and State & Flow categories. Read study topics 01, 04, 06, and 07.
  2. 2

    Mid

    Own features end-to-end: data, state, tests.

    You own features end to end — data, state, tests, and polish — with little hand-holding. The goal is depth across the everyday Android toolkit and the start of architecture and performance awareness.

    You can already

    • ✓Use coroutines & Flow well: structured concurrency, StateFlow/SharedFlow, combine, flatMapLatest.
    • ✓Apply MVVM with a single immutable UiState and a repository as the source of truth.
    • ✓Persist with Room and DataStore, and build a typed Retrofit/OkHttp network layer.
    • ✓Wire dependency injection with Hilt and keep classes constructor-injected.
    • ✓Write unit + integration tests and a few Compose UI tests; survive process death with SavedStateHandle.

    Level up by

    • →Compose performance: stability, recomposition scope, derivedStateOf, deferred reads.
    • →Clean Architecture / MVI, modularization, and the domain layer.
    • →Paging 3, WorkManager, deep links, and offline-first sync.
    Filter flashcards to Mid and the Compose, Framework, and State & Flow categories. Work study topics 02, 03, 05, and 08–13.
  3. 3

    Senior

    Architecture, performance, native & security depth.

    You bring architecture, performance, concurrency, and testing depth, and you raise the team around you. The goal is to be the person who profiles instead of guessing and who reasons about threading, leaks, and stability cold.

    You can already

    • ✓Explain the threading model, structured concurrency, and cancellation precisely.
    • ✓Profile and fix jank, memory leaks, and slow cold start with Perfetto / Macrobenchmark / LeakCanary.
    • ✓Design Compose for stability and add Baseline Profiles to guard hot paths.
    • ✓Reason about security in threat-model buckets (Keystore, EncryptedSharedPreferences, pinning, Play Integrity, MASVS).
    • ✓Own a release: CI, instrumented tests, staged rollout, crash-free rate, and a kill switch.

    Level up by

    • →System design at scale: offline-first, sync & conflict resolution, real-time, pagination.
    • →Modularization strategy, convention plugins, and build-time/observability budgets.
    • →Mentoring through reviews and multiplying a team via shared modules.
    Filter flashcards to Senior and the Performance, Coroutines, DI, and Security categories. Read study topics 14–19 and the full Architecture guide.
  4. 4

    Architect

    System design, platform decisions, team leverage.

    You design Android systems end to end and make platform decisions that move a whole team. The goal is decision-making before code — for the worst device, worst network, and worst moment (process death under memory pressure).

    You can already

    • ✓Design a feature end to end and justify architecture, state, navigation, and data strategy.
    • ✓Plan modularization, the dependency graph, and incremental migrations with bounded risk.
    • ✓Stand up CI/CD, build infrastructure, baseline-profile generation, and production observability.
    • ✓Define the security posture and the testing strategy across the org.
    • ✓Multiply a team through shared modules, convention plugins, and code review.

    Level up by

    • →Org-level platform strategy: Kotlin Multiplatform reach, dynamic delivery, and build-time at scale.
    • →Cost/perf budgets, SLOs, and evaluating emerging tech (on-device AI).
    Filter flashcards to Architect and the Architecture category. Work the Architecture guide + Deep dives and study topics 08, 12, 18.
  5. 5

    Beyond

    Frontier: on-device AI and pushing the platform.

    The frontier — where you push what an Android app can do. The goal is to bring genuinely new capability on-device and pioneer patterns the rest of the team will adopt.

    You can already

    • ✓Run generative models on-device with Gemini Nano (AICore / ML Kit GenAI) and MediaPipe LLM Inference, reasoning about the privacy/cost/latency trade-off.
    • ✓Use TensorFlow Lite / LiteRT for vision and audio with GPU delegates and quantization.
    • ✓Push the platform: Kotlin Multiplatform, Compose Multiplatform, and deep system interop.

    Level up by

    • →Contribute upstream, prototype with new Jetpack/Compose internals, and set team direction on emerging tech.
    Filter flashcards to Beyond and the On-Device AI category, and read study topic 20.