Android Developer Interview Questions and Answers (2026): Kotlin, Compose and Play

The short answer: Android interviews in 2026 focus on Kotlin, coroutines and Flow, Jetpack Compose (state, recomposition, state hoisting), lifecycles and app components, architecture (ViewModel, repositories, dependency injection, Room), performance and testing, and awareness of Google Play requirements. Expect a coding round (Kotlin data structures and algorithms or a small app task), an Android deep dive, often a mobile system design question, and behavioral questions. For questions shared with iOS, see our mobile app developer interview questions.

Kotlin questions

• “How does Kotlin handle null safety?” Types are non-nullable by default; String? is nullable. Use safe calls (?.), the Elvis operator (?:) and smart casts; avoid !!, which throws if the value is null.
• “val vs var, lateinit vs lazy?” val is read-only, var is mutable. lateinit var is for non-null properties initialized later (for example by injection); by lazy computes a val on first access.
• “What are data classes and sealed classes?” Data classes generate equals, hashCode, toString and copy, ideal for UI state. Sealed classes or interfaces restrict subclasses, so when expressions are exhaustive: ideal for states such as Loading, Success, Error.
• “Explain let, apply, also, run and with.” Scope functions that differ in how they refer to the object (it or this) and what they return (the object or the lambda result). For example, apply configures an object and returns it; let is common with null checks.
• “What are extension functions?” Functions added to an existing type without inheriting from it, resolved statically.
• “Flow vs StateFlow vs SharedFlow?” A Flow is a cold stream that runs when collected. StateFlow always holds a current value, which makes it a good fit for UI state; SharedFlow broadcasts events to multiple collectors and can replay a configurable number of values.

Coroutines questions

“What does main-safe mean?”

Android’s documentation says a function is main-safe “when it doesn’t block UI updates on the main thread.” Make suspending functions main-safe by moving blocking work to another dispatcher with withContext(Dispatchers.IO) inside the repository, so callers can safely call them from the main thread.

“What are dispatchers?”

Dispatchers.Main for UI work, Dispatchers.IO for blocking input and output such as network and disk, and Dispatchers.Default for CPU-intensive work.

“What is structured concurrency, and what is viewModelScope?”

Coroutines run in a scope that controls their lifetime. Android’s docs list “fewer memory leaks” and automatic cancellation propagated through the coroutine hierarchy among the benefits. viewModelScope is a predefined scope tied to a ViewModel, so its coroutines are cancelled when the ViewModel is cleared.

class ProfileViewModel(private val repo: ProfileRepository) : ViewModel() {
    private val _state = MutableStateFlow<ProfileState>(ProfileState.Loading)
    val state: StateFlow<ProfileState> = _state

    fun load(id: String) {
        viewModelScope.launch {
            _state.value = try {
                ProfileState.Success(repo.getProfile(id)) // main-safe suspend function
            } catch (e: IOException) {
                ProfileState.Error
            }
        }
    }
}

“How do you handle exceptions in coroutines?”

Use try/catch around suspending calls, or a CoroutineExceptionHandler for top-level coroutines. With a regular Job, a failing child cancels its parent and siblings; supervisorScope or a SupervisorJob lets siblings continue.

Jetpack Compose questions

• “What is recomposition?” Compose re-runs composable functions whose inputs (state) changed, updating only what’s needed. Composables should be fast and free of side effects.
• “remember vs rememberSaveable?” remember keeps a value across recompositions; rememberSaveable also survives configuration changes and process recreation through saved state.
• “What is state hoisting, and where should state live?” Moving state up to a caller and passing it down with events, making composables stateless and reusable. Android’s guidance: “hoist UI state to the lowest common ancestor between all the composables that read and write it,” keep state close to where it’s consumed, and expose immutable state and events to modify it. State needed by business logic goes in the ViewModel.
• “How do you run side effects in Compose?” With effect APIs such as LaunchedEffect (run a suspend function when a key changes), DisposableEffect (set up and clean up) and rememberCoroutineScope (launch from event callbacks).
• “Why do keys matter in LazyColumn?” Stable keys let Compose keep item state and animate correctly when items move, are added or are removed.

Android components and lifecycle questions

• “Walk me through the Activity lifecycle.” onCreate, onStart, onResume when the activity comes to the foreground; onPause, onStop, and onDestroy as it leaves. Configuration changes such as rotation destroy and recreate it, which is why UI state belongs in a ViewModel and saved state.
• “What are the four app components?” Activities, services, broadcast receivers and content providers, connected through intents.
• “How do you run background work that must complete?” Use WorkManager for deferrable work that must be guaranteed (such as uploading logs), with constraints like network availability; use foreground services only for user-visible ongoing work.

Architecture, performance and testing questions

• “How do you structure an Android app?” Following Android’s architecture guide: a UI layer (composables or views plus ViewModels), a data layer (repositories and data sources such as Room and Retrofit) and an optional domain layer, with dependency injection (commonly Hilt) and unidirectional data flow.
• “What causes an ANR, and how do you prevent it?” “Application not responding” errors come from blocking the main thread too long. Move I/O and heavy work off the main thread and avoid long work in broadcast receivers.
• “How do you improve startup and scrolling performance?” Measure with Android Studio profilers, defer initialization, use Baseline Profiles, avoid unnecessary recompositions, and load images efficiently.
• “How do you test an Android app?” Unit tests for ViewModels and repositories (with test dispatchers for coroutines), Compose UI tests or Espresso for flows, and tests on a range of devices and API levels.

Google Play questions

“What are Google Play’s target API level requirements?”

Google Play’s policy says that, starting 31 August 2026, new apps and app updates must target Android 16 (API level 36) or higher (with lower minimums for Wear OS, Android Automotive OS, Android TV and Android XR apps), and existing apps must target at least Android 15 (API level 35) to stay available to new users on newer devices. Interviewers ask this to see whether you keep up with platform changes, such as new permission and background-work behavior that comes with each target level.

“How do you handle permissions?”

Request runtime permissions only when needed, in context, with a clear explanation; handle denial gracefully; and request the narrowest permission that works.

Behavioral questions

• “Tell me about a crash or ANR you investigated and fixed.”
• “Tell me about a time you migrated part of an app, for example from Views to Compose.”
• “How do you keep up with Android changes?”

Related guides: iOS developer interview questions, full-stack developer interview questions and software engineer interview questions.

Frequently asked questions

Sources

• Android Developers, Kotlin coroutines on Android. Read on 1 October 2026.
• Android Developers, Where to hoist state. Read on 1 October 2026.
• Android Developers, Guide to app architecture. Read on 1 October 2026.
• Google Play Console Help, Target API level requirements for Google Play apps. Read on 1 October 2026.