roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Go into Android developer interviews ready for Kotlin, the coding round, and mobile system design. Covers app architecture, async and networking, testing, and CI/CD release tooling.
9680 of 9680 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 9680 new. 0 cut, outside your plan.
The round that decides an Android loop is rarely the algorithm problem. Most loops have one, in Kotlin, after a recruiter screen; the weight sits on the platform exercise that follows, a take-home app or a live session in which you build a screen or fix a leaking one, and on the platform conversation after it. The loop adds a mobile system design round from middle level up, usually a feed, a chat or a list that must work offline, and ends on a behavioral conversation. The platform questions are built from the lifecycle. Why does a `ViewModel` outlive a rotation but not the process death the system causes in the background, and what does `rememberSaveable` keep across that death that `remember` does not? Why does a flow collected in `lifecycleScope.launch` keep collecting after the screen is hidden, and what does `repeatOnLifecycle` change? Why does a blocked main thread become an ANR after roughly five seconds, and which work belongs to WorkManager rather than to a coroutine that dies with the process? Interviewers raise the level with follow-ups rather than new questions: *the screen rotates* becomes *the process was killed in the background* becomes *it happens on one manufacturer's devices in production*. The first is answered from the API, the right scope or annotation; the second from the lifecycle and the thread, which owner each scope dies with and which dispatcher the call ran on; the third from measurement, a cold start timed with a macrobenchmark before and after a baseline profile, a frame budget of about sixteen milliseconds at 60 Hz, a staged rollout that stopped a regression at a fraction of the users.
[Kotlin](/topics/lang-kotlin) opens the plan as the language you write, and [Java](/topics/lang-java) follows as the language you read: the SDK, the older libraries and most legacy modules are written in it, and the interop questions, platform types, SAM conversion, `@JvmStatic`, live on that seam. The foundations stretch is heavier than on most roadmaps because Android code is architecture-heavy by convention: the [architecture patterns](/topics/found-architectural-patterns) module names MVVM and the UI, domain and data layers before any Android library applies them, and [concurrency](/topics/found-concurrency) and [memory management](/topics/found-memory-management) are there because a single main thread and a garbage collector in a small heap are the two facts most platform bugs trace back to. [Algorithms](/topics/found-dsa) follow for the coding round, then Android Studio and beneath it [Gradle](/topics/dev-gradle), because an Android project is a Gradle build with variants, flavors and a dependency graph to resolve, with Git and GitHub beside both. The platform is the center of the plan, and its modules run in the order an app is built. They start beneath any screen, in [the SDK itself](/topics/mob-android-sdk), whose components, intents and manifest every library above it relies on, then the [ViewModel and Lifecycle](/topics/mob-jetpack-lifecycle) libraries that decide what outlives a rotation and which coroutine stops with the screen, [RecyclerView](/topics/mob-recyclerview) for the View-based lists most codebases still ship, and Google Play services. Then come [Compose](/topics/mob-jetpack-compose) and the observable state that feeds it, LiveData included for the screens written before flows took over; [Hilt](/topics/mob-hilt) to wire them, with [Dagger](/topics/be-dagger) beside it as the code generator Hilt is built on; [Room](/topics/mob-room) and DataStore to persist, with [SQLite](/topics/db-sqlite) right after Room because Room compiles down to it, and write-ahead logging, transactions and indexes explain what the annotations cost, then [Paging](/topics/mob-paging), which feeds a long list from that cache page by page; and [WorkManager](/topics/mob-workmanager) for work that must outlive the screen. [RxJava](/topics/be-rxjava) follows as the previous generation of async, which many codebases still carry and ask you to interoperate with or migrate away from. Networking repeats the move from library to engine: after REST as the contract, Retrofit is the typed client a screen calls and [OkHttp](/topics/be-okhttp) the connection pool, interceptors and cache beneath it. GraphQL, the other shape of contract a client speaks, then gets a module of its own, taken from the client's side: the [documents a screen sends](/topics/proto-graphql-operations), the partial responses that null propagation leaves behind, cursor pagination and the normalized cache, with enough schema design and abuse control to argue with the team that owns the server. [Firebase](/topics/cloud-firebase) follows as the backend many apps have instead of a server, and only with client and backend both in view does [mobile system design](/topics/mob-system-design) arrive, with offline-first sync, infinite feeds and device budgets as its material. The plan then measures what it built: LeakCanary finds the activity a forgotten listener kept alive, and [Jetpack Benchmark](/topics/mob-jetpack-benchmark) times the cold starts and frames the design round put budgets on. It ends on the practice around shipping: JUnit with Mockito for Java-shaped code and [MockK](/topics/dev-mockk) for Kotlin's final classes, objects and suspend functions, [Espresso](/topics/mob-espresso) for UI tests that run on a device, and Ktlint and Detekt as the gate a pull request passes before a reviewer reads it. Release follows: CI/CD concepts and Fastlane for the pipeline that builds, signs and uploads a build, Firebase App Distribution for testers and the Play Store for everyone else, where a staged rollout limits who receives a bad release. Then comes the client's security, [secure coding](/topics/found-appsec), the redirect back into the app and [PKCE](/topics/proto-oauth2-pkce), because a mobile app is a public client that cannot keep a secret. The plan closes on the [behavioral round](/topics/found-behavioral) and on [the interview process itself](/topics/found-interview-process), from the screening stages through the onsite day to what happens after.
A Java-era Android developer returning to interviews has a different gap from a newcomer. The returning developer should go straight to coroutines and Flow, to Compose and its state holders, and read the Rx module as a translation exercise, since most of what the interview now asks is phrased in those terms. A newcomer, or a backend engineer moving to the client, should get the lifecycle solid before any library: what owns a `ViewModel`, what a configuration change destroys, what process death destroys, and which coroutine scope dies with each. Senior candidates more often lose a loop in the design round than in the platform round, so the mobile system design module deserves their hours; that round expects numbers on a frame, a cold start and a payload. Time decides the controls. With a fortnight, narrow level to the posting's band and raise importance to must know; the by frequency order the page opens with already puts the Kotlin and platform questions first. Given three months, the plan's own sequence is the better guide, so switch study order to by topics; each stretch above leans on the one before it. Kotlin Multiplatform appears here as a language module, not as a second platform: the Swift side of the same app, UIKit and SwiftUI, belongs to the [iOS Developer roadmap](/roadmaps/ios). A team that ships one codebase to both stores interviews differently again; the [Flutter](/roadmaps/flutter) and [React Native](/roadmaps/react-native) roadmaps cover those frameworks.
The round that decides an Android loop is rarely the algorithm problem. Most loops have one, in Kotlin, after a recruiter screen; the weight sits on the platform exercise that follows, a take-home app or a live session in which you build a screen or fix a leaking one, and on the platform conversation after it. The loop adds a mobile system design round from middle level up, usually a feed, a chat or a list that must work offline, and ends on a behavioral conversation.
The platform questions are built from the lifecycle. Why does a ViewModel outlive a rotation but not the process death the system causes in the background, and what does rememberSaveable keep across that death that remember does not? Why does a flow collected in lifecycleScope.launch keep collecting after the screen is hidden, and what does repeatOnLifecycle change? Why does a blocked main thread become an ANR after roughly five seconds, and which work belongs to WorkManager rather than to a coroutine that dies with the process?
Interviewers raise the level with follow-ups rather than new questions: the screen rotates becomes the process was killed in the background becomes it happens on one manufacturer's devices in production. The first is answered from the API, the right scope or annotation; the second from the lifecycle and the thread, which owner each scope dies with and which dispatcher the call ran on; the third from measurement, a cold start timed with a macrobenchmark before and after a baseline profile, a frame budget of about sixteen milliseconds at 60 Hz, a staged rollout that stopped a regression at a fraction of the users.
Kotlin opens the plan as the language you write, and Java follows as the language you read: the SDK, the older libraries and most legacy modules are written in it, and the interop questions, platform types, SAM conversion, @JvmStatic, live on that seam.
The foundations stretch is heavier than on most roadmaps because Android code is architecture-heavy by convention: the architecture patterns module names MVVM and the UI, domain and data layers before any Android library applies them, and concurrency and memory management are there because a single main thread and a garbage collector in a small heap are the two facts most platform bugs trace back to. Algorithms follow for the coding round, then Android Studio and beneath it Gradle, because an Android project is a Gradle build with variants, flavors and a dependency graph to resolve, with Git and GitHub beside both.
The platform is the center of the plan, and its modules run in the order an app is built. They start beneath any screen, in the SDK itself, whose components, intents and manifest every library above it relies on, then the ViewModel and Lifecycle libraries that decide what outlives a rotation and which coroutine stops with the screen, RecyclerView for the View-based lists most codebases still ship, and Google Play services. Then come Compose and the observable state that feeds it, LiveData included for the screens written before flows took over; Hilt to wire them, with Dagger beside it as the code generator Hilt is built on; Room and DataStore to persist, with SQLite right after Room because Room compiles down to it, and write-ahead logging, transactions and indexes explain what the annotations cost, then Paging, which feeds a long list from that cache page by page; and WorkManager for work that must outlive the screen. RxJava follows as the previous generation of async, which many codebases still carry and ask you to interoperate with or migrate away from.
Networking repeats the move from library to engine: after REST as the contract, Retrofit is the typed client a screen calls and OkHttp the connection pool, interceptors and cache beneath it. GraphQL, the other shape of contract a client speaks, then gets a module of its own, taken from the client's side: the documents a screen sends, the partial responses that null propagation leaves behind, cursor pagination and the normalized cache, with enough schema design and abuse control to argue with the team that owns the server. Firebase follows as the backend many apps have instead of a server, and only with client and backend both in view does mobile system design arrive, with offline-first sync, infinite feeds and device budgets as its material.
The plan then measures what it built: LeakCanary finds the activity a forgotten listener kept alive, and Jetpack Benchmark times the cold starts and frames the design round put budgets on. It ends on the practice around shipping: JUnit with Mockito for Java-shaped code and MockK for Kotlin's final classes, objects and suspend functions, Espresso for UI tests that run on a device, and Ktlint and Detekt as the gate a pull request passes before a reviewer reads it. Release follows: CI/CD concepts and Fastlane for the pipeline that builds, signs and uploads a build, Firebase App Distribution for testers and the Play Store for everyone else, where a staged rollout limits who receives a bad release. Then comes the client's security, secure coding, the redirect back into the app and PKCE, because a mobile app is a public client that cannot keep a secret. The plan closes on the behavioral round and on the interview process itself, from the screening stages through the onsite day to what happens after.
A Java-era Android developer returning to interviews has a different gap from a newcomer. The returning developer should go straight to coroutines and Flow, to Compose and its state holders, and read the Rx module as a translation exercise, since most of what the interview now asks is phrased in those terms. A newcomer, or a backend engineer moving to the client, should get the lifecycle solid before any library: what owns a ViewModel, what a configuration change destroys, what process death destroys, and which coroutine scope dies with each. Senior candidates more often lose a loop in the design round than in the platform round, so the mobile system design module deserves their hours; that round expects numbers on a frame, a cold start and a payload.
Time decides the controls. With a fortnight, narrow level to the posting's band and raise importance to must know; the by frequency order the page opens with already puts the Kotlin and platform questions first. Given three months, the plan's own sequence is the better guide, so switch study order to by topics; each stretch above leans on the one before it.
Kotlin Multiplatform appears here as a language module, not as a second platform: the Swift side of the same app, UIKit and SwiftUI, belongs to the iOS Developer roadmap. A team that ships one codebase to both stores interviews differently again; the Flutter and React Native roadmaps cover those frameworks.