Android Interview Questions (2026)

Activity lifecycle matters in Android because it changes screen behavior, state ownership, device support, or release safety on Android phones, tablets, and Play Store releases.

A product example is verified with Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals. That makes Activity lifecycle concrete instead of a framework definition.

For Activity lifecycle, the practical check is whether a Kotlin feature screen with state, tests, Gradle config, and release checks reflects the intended behavior and whether Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals confirms it.

Fragment lifecycle is a platform decision in Android. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

Fragment lifecycle becomes useful when it changes a real choice: safer design, faster execution, clearer ownership, or better failure detection.

Jetpack Compose is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

The main risk with Jetpack Compose is lifecycle bugs, permission gaps, main-thread work, memory leaks, and release misconfiguration; detection of that risk is part of the technical substance.

ViewModel connects code to device behavior: the API or pattern and how it behaves during lifecycle, network, or release changes.

ViewModel maps back to a Kotlin feature screen with state, tests, Gradle config, and release checks, which connects the concept to implementation and release evidence.

ViewModel connects one concrete artifact, one measurable signal, and one reason the simpler option may not be enough.

LiveData and Flow matters in Android because it changes screen behavior, state ownership, device support, or release safety on Android phones, tablets, and Play Store releases.

A product example is verified with Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals. That makes LiveData and Flow concrete instead of a framework definition.

In day-to-day work, LiveData and Flow is judged by the result it protects: correctness, reliability, maintainability, cost, security, or user impact.

Coroutines is a platform decision in Android. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

Coroutines has a boundary, behavior inside that boundary, and evidence outside it.

Room database is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

Room database is worth discussing only if it changes an action: what to build, what to test, what to monitor, or what to avoid.

Retrofit connects code to device behavior: the API or pattern and how it behaves during lifecycle, network, or release changes.

Retrofit maps back to a Kotlin feature screen with state, tests, Gradle config, and release checks, which connects the concept to implementation and release evidence.

The useful distinction for Retrofit is where responsibility sits: code, data, configuration, platform, process, or owner.

WorkManager matters in Android because it changes screen behavior, state ownership, device support, or release safety on Android phones, tablets, and Play Store releases.

A product example is verified with Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals. That makes WorkManager concrete instead of a framework definition.

WorkManager often fails quietly, so the validation should be observable through Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

permissions is a platform decision in Android. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

permissions is specific: where it applies, where it does not, and what changes the decision.

intents is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

intents connects theory to delivery when the explanation includes input, output, owner, risk, and proof.

services connects code to device behavior: the API or pattern and how it behaves during lifecycle, network, or release changes.

services maps back to a Kotlin feature screen with state, tests, Gradle config, and release checks, which connects the concept to implementation and release evidence.

services goes beyond definition when it includes the operating constraint and verification step.

broadcast receivers matters in Android because it changes screen behavior, state ownership, device support, or release safety on Android phones, tablets, and Play Store releases.

A product example is verified with Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals. That makes broadcast receivers concrete instead of a framework definition.

broadcast receivers is tied to the problem it solves, not just the tool or syntax that exposes it.

Gradle build variants is a platform decision in Android. It shows how the app handles state, system APIs, performance, or user recovery.

The failure mode can be slow render, stale state, permission denial, crash, battery cost, offline break, or store rejection, depending on the feature.

The decision around Gradle build variants should be reversible or at least measurable, especially when lifecycle bugs, permission gaps, main-thread work, memory leaks, and release misconfiguration is possible.

app signing is defined through a user path: what the user does, what the app stores, what the OS controls, and what can fail on a real device.

The release check uses an emulator, simulator, real device, logs, crash traces, profiler output, or store signals.

app signing needs both the normal path and the edge case that breaks it.

For building a Compose screen, the user path, device state, network condition, and release target before choosing the implementation comes first.

building a Compose screen connects to a Kotlin feature screen with state, tests, Gradle config, and release checks, and release proof comes from Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

building a Compose screen is complete only when the result is visible in Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals and the next owner can repeat the check.

Handle handling configuration changes by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

The safe path for handling configuration changes is small scope, known baseline, controlled change, and a rollback or correction option.

Begin calling a REST API with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if calling a REST API breaks after rollout.

For calling a REST API, the important artifact is a Kotlin feature screen with state, tests, Gradle config, and release checks; without it, the task is just activity without proof.

For caching data with Room, define success in user terms first, then map it to code, logs, build output, and release checks.

Syntax is not enough. The evidence trail is Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

caching data with Room preserves the user or system outcome first, then optimizes speed, cost, or convenience.

For requesting runtime permissions, the user path, device state, network condition, and release target before choosing the implementation comes first.

requesting runtime permissions connects to a Kotlin feature screen with state, tests, Gradle config, and release checks, and release proof comes from Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

The risk in requesting runtime permissions is lifecycle bugs, permission gaps, main-thread work, memory leaks, and release misconfiguration, so the task needs an explicit prevention or detection step.

Handle scheduling background work by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

scheduling background work usually touches more than one layer, so separate input, processing, output, and ownership before changing anything.

Begin debugging an ANR with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if debugging an ANR breaks after rollout.

debugging an ANR stops at a verified result, not a completed command or a passed local run.

For profiling memory usage, define success in user terms first, then map it to code, logs, build output, and release checks.

Syntax is not enough. The evidence trail is Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

profiling memory usage needs a defined expected output, allowed side effects, and evidence source before execution.

For writing a ViewModel test, the user path, device state, network condition, and release target before choosing the implementation comes first.

writing a ViewModel test connects to a Kotlin feature screen with state, tests, Gradle config, and release checks, and release proof comes from Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

writing a ViewModel test needs a negative case as well as the happy path, especially when the failure is expensive or hard to see.

Handle writing a UI test by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

The simplest useful version of writing a UI test is the one that can be reviewed, repeated, and explained from the evidence.

Begin creating build variants with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if creating build variants breaks after rollout.

For creating build variants, document the assumption that matters most because that is where follow-up failures usually start.

For signing an app bundle, define success in user terms first, then map it to code, logs, build output, and release checks.

Syntax is not enough. The evidence trail is Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

signing an app bundle leaves a trace: test result, log line, metric, report, ticket, or review note.

For handling deep links, the user path, device state, network condition, and release target before choosing the implementation comes first.

handling deep links connects to a Kotlin feature screen with state, tests, Gradle config, and release checks, and release proof comes from Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals.

The practical choice in handling deep links is often between a quick local fix and a maintainable change that survives the next release.

Handle supporting offline mode by separating UI state, platform API behavior, local data, and remote data. Each layer needs its own check.

One constraint usually controls the decision: startup time, offline behavior, accessibility, memory, store rules, signing, or OS version support.

supporting offline mode becomes reliable when setup, execution, validation, and cleanup are separate and visible.

Begin reading Play Console crashes with the smallest testable change, then run it on the device class most likely to expose the bug.

The rollback or mitigation path matters if reading Play Console crashes breaks after rollout.

reading Play Console crashes controls blast radius by separating what changes now from what stays unchanged.

For ANR after a screen opens, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

ANR after a screen opens ends with a decision based on Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals, not a guess based on the first symptom.

Handle crash only on Android 14 by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

The first priority in crash only on Android 14 is limiting impact while keeping enough evidence to prove the actual cause.

Treat state lost on rotation as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

For state lost on rotation, the useful split is symptom, cause, fix, validation, and prevention.

Debug permission denied path with a device matrix, not one local run. The record must show which device, OS version, and build variant was checked.

The safest fix avoids broad rewrites, untested store changes, and fixes checked only on one emulator.

permission denied path is risky when lifecycle bugs, permission gaps, main-thread work, memory leaks, and release misconfiguration; the fix should address that risk directly.

For slow RecyclerView or LazyColumn, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

The strongest mitigation for slow RecyclerView or LazyColumn is the smallest change that proves or disproves the suspected cause.

Handle background job not running by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

background job not running needs a timeline because order often reveals whether the issue came from data, code, configuration, or process.

Treat API fails on mobile data as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

For API fails on mobile data, communication matters because the owner, user impact, and next action must be clear before work spreads.

Debug Room migration crash with a device matrix, not one local run. The record must show which device, OS version, and build variant was checked.

The safest fix avoids broad rewrites, untested store changes, and fixes checked only on one emulator.

Room migration crash does not widen into a rewrite until the narrow failure has been reproduced and measured.

For push notification not delivered, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

The prevention step for push notification not delivered is concrete: a test, monitor, rule, review, runbook, or owner change.

Handle deep link opens wrong screen by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

For deep link opens wrong screen, a rollback is useful only if it restores the failing behavior and has its own validation check.

Treat battery drain complaint as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

battery drain complaint is evaluated by blast radius, repeatability, customer impact, and confidence in the evidence.

Debug large APK or app bundle with a device matrix, not one local run. The record must show which device, OS version, and build variant was checked.

The safest fix avoids broad rewrites, untested store changes, and fixes checked only on one emulator.

The best fix for large APK or app bundle is one that reduces recurrence, not just the visible symptom.

For Play review rejection, reproduce the issue on the affected device class, collect logs, compare OS or framework behavior, and test the narrowest fix.

Prevention can be a regression test, crash alert, rollout guardrail, store checklist, or release note, depending on the failure.

For Play review rejection, the hard part is separating real movement from measurement or environment noise.

Handle accessibility issue by protecting the user path first, then isolating whether the cause is lifecycle, state, network, storage, permission, or release config.

The useful technical record has user impact, debug path, evidence, and ownership, not just a guessed framework fix.

accessibility issue preserves a record of what changed, why it changed, and what proved the change worked.

Treat senior Android design review as a release risk. Decide whether to hotfix, roll back, feature flag, or monitor based on impact and repeatability.

Logcat output, profiler traces, emulator runs, real-device tests, and Play Console signals is the proof source. Missing evidence means adding the log, trace, test, or release signal before calling the issue resolved.

The final check for senior Android design review is whether the same failure can be caught earlier next time.