Interview round · every platform

Kotlin and Jetpack Compose interview prep

Android technical rounds go deep on the parts that break in production: a coroutine scope that outlives its screen, a Flow collected in the wrong place, a composable that recomposes on every keystroke.

For: Android engineers preparing the technical screen or the language and UI rounds of a loop.

Mike Salari · Staff mobile engineer · 500+ technical interviews from the hiring side

Read the 6 guides Build my prep plan

What the round scores

Part of the round	What the interviewer writes down
Kotlin language	Null safety, sealed types, extension functions and data classes used for a reason.
Coroutines	Structured concurrency, cancellation, dispatchers and what happens to an exception in a child job.
Flow	Cold and hot streams, where collection happens, and what restarts on rotation.
Compose	State hoisting, stability, recomposition scope and side effects, from a screen you built.

Loops differ by company. This is the common shape of the round in senior mobile loops, not a promise about any one employer.

A weak answer and a strong one

Weak

"GlobalScope is bad."

Strong

Explains which scope should own the work, and what gets cancelled when the screen goes away.

Weak

"Compose recomposes when state changes."

Strong

Shows which state read caused the recomposition and how stability changes it.

For an Android interview that is within a week, when rereading is not enough and you need to say the answers. It is for mid level to Staff engineers facing the Kotlin interview questions, coroutines, Compose and design questions most likely to decide the loop, and it trains the spoken answer, the push that follows and the recovery. With several weeks, broad coverage comes first.

The second question

Follow-ups that decide the round

“The ViewModel collects a Flow in init. What happens on rotation?”

Tests whether you know which scope owns the collection and what restarts.

“A child coroutine throws. What happens to its siblings?”

Tests structured concurrency beyond the definition.

“This composable recomposes on every keystroke. Why?”

Tests whether you can read stability and state reads, not guess.

How to prepare for it

Start with the technical questions
The Android technical guide maps the rounds and the recurring questions.
Kotlin and coroutines, then Compose
Answer each guide's questions out loud before reading the answer.
Prepare one production story per area
A cancelled job, a Flow bug, a recomposition you fixed.

Guides for this round

Android · 22 min

Android interview questions in 2026, round by round

Android interview questions for 2026, organised by round: Kotlin, coroutines, Compose, lifecycle, architecture, system design, testing, performance, security.

Android · 24 min

Android technical interview questions and answers

Android technical interview questions and answers: lifecycle, process death, coroutines, data, security and testing, with the follow-up to each.

Android · 13 min

Kotlin interview questions for Android engineers

Kotlin interview questions as Android loops ask them: null safety, coroutines, cancellation, Flow, sealed types and generics, with each follow-up.

Android · 17 min

Kotlin coroutines interview questions, and the follow-ups

Kotlin coroutines interview questions for 2026: structured concurrency, cancellation, exceptions, dispatchers, Flow and testing, with weak and senior answers.

Android · 14 min

Jetpack Compose interview questions and follow-ups

Compose interview questions on recomposition, state, side effects and performance, with the weak answer, the answer that scores and the follow-up.

Books and practice

For a full senior Android interview loop with time to prepare it properly. It is written for mid level to Staff and architect candidates and reasons about current Android practice rather than definitions, from the language and concurrency questions to the Android system design round. When the interview is days away, the 24-Hour Android book is the faster start.

For iOS and Android, Interview Runtime is the practice layer: interview answer practice where you speak first and the follow-up comes after, the way a real round runs. It is for engineers who have read enough and now need to hear where their own answer breaks. The free iOS sample shows how it works before you buy.

Other rounds

Mobile system design

Prepare for the mobile system design round: offline behaviour, sync, caching, lifecycle and release, and what the interviewer scores at Senior and Staff.

Coding and live coding

Prepare for mobile coding, live coding and pair programming rounds: the tasks that recur, how they are graded, and what to say while you type.

Architecture

Prepare for the mobile architecture round on iOS, Android and Flutter: module boundaries, dependency direction, state ownership and defending your pattern.

Senior and Staff

What changes in a Senior or Staff mobile interview loop: the follow-up depth, the scope of the design round, and the evidence each level is expected to show.

Swift, SwiftUI and UIKit

Prepare for the Swift, SwiftUI and UIKit rounds of an iOS interview: concurrency and isolation, memory, state and identity, and what each question scores.