Android developer interviews test Kotlin, the Android framework and modern app architecture. These Android interview questions cover activities, fragments, intents and the lifecycle for freshers, then Jetpack Compose, ViewModel, coroutines, Room, dependency injection, background work and performance for experienced Android developers.
30 questions · Updated
Fundamentals, definitions and simple scenarios. Good for freshers and warm-ups.
Activities (screens with a user interface), services (work in the background without a UI), broadcast receivers (respond to system or app events such as low battery or connectivity changes) and content providers (share data between apps). They are declared in AndroidManifest.xml along with permissions.
onCreate initialises the activity and sets up the UI, onStart makes it visible, onResume makes it interactive in the foreground, onPause runs when it loses focus, onStop when it is no longer visible, and onDestroy before it is destroyed. Configuration changes such as rotation destroy and recreate the activity by default, which is why state is kept in a ViewModel.
An intent is a message used to start components or communicate between them.
An explicit intent names the exact component, such as starting a specific activity in your app.
An implicit intent describes an action, such as ACTION_VIEW or ACTION_SEND, and lets the system find an app that can handle it, such as opening a link or sharing text.
Google declared Android Kotlin-first.
Kotlin is concise, has null safety built into the type system (which prevents many crashes), data classes, extension functions, coroutines for asynchronous code, and is required for Jetpack Compose.
It interoperates fully with Java, so existing Java code and libraries still work.
A fragment is a reusable part of an activity's UI with its own lifecycle, used for screens in single-activity apps with the Navigation component.
Its callbacks include onCreate, onCreateView (inflate the layout), onViewCreated (set up views and observers), onStart, onResume, onPause, onStop, onDestroyView (clear view references) and onDestroy.
The view lifecycle is shorter than the fragment's, which causes leaks if views are kept.
The manifest describes the app to the system: its package name, components (activities, services, receivers and providers) with intent filters, the launcher activity, permissions it needs, hardware features it uses, the theme and settings such as backup rules. Each library's manifest is merged into the final one at build time.
Dangerous permissions, such as camera, location, contacts and notifications on Android 13+, must be requested at runtime as well as declared in the manifest.
Check with ContextCompat.checkSelfPermission, request with the Activity Result API (rememberLauncherForActivityResult in Compose), explain why when shouldShowRequestPermissionRationale is true, and handle denial gracefully.
Request permissions only when the feature is used.
RecyclerView displays long lists efficiently by creating only enough item views to fill the screen and recycling them as the user scrolls.
An Adapter binds data to ViewHolders, a LayoutManager arranges them in a list or grid, and ListAdapter with DiffUtil calculates minimal updates when data changes.
In Compose, LazyColumn and LazyRow replace it.
Resources live in res folders such as values (strings, colours, dimensions, themes), drawable, mipmap (launcher icons) and font.
Qualifiers provide alternatives automatically chosen by the device, such as values-hi for Hindi translations, values-night for dark theme, and layout-sw600dp for tablets.
Strings should never be hard-coded so the app can be translated.
Gradle builds the app.
Build types such as debug and release control settings like minification, debugging and signing.
Product flavours create versions of the app, such as free and paid or staging and production, with different application IDs, API URLs or resources.
Each combination is a build variant.
Configuration is usually written in Kotlin DSL (build.gradle.kts) with a version catalog.
An APK is the installable package containing the code and resources for all devices. An Android App Bundle (AAB) is the publishing format required by Google Play; Play uses it to generate optimised APKs for each device, with only the needed languages, screen densities and CPU architecture, which makes downloads smaller.
Applied problems, trade-offs and questions about your own projects.
A ViewModel holds and manages UI-related data in a lifecycle-aware way.
It survives configuration changes such as screen rotation, so data is not reloaded, and it separates business logic from the UI.
It exposes state through StateFlow or LiveData, and its viewModelScope cancels coroutines automatically when the ViewModel is cleared.
Jetpack Compose is Android's modern declarative UI toolkit. Instead of XML layouts, you write composable functions in Kotlin that describe the UI for the current state, and Compose recomposes the parts that change when state changes. remember and mutableStateOf hold state, state hoisting keeps composables reusable, and it greatly reduces UI code.
Coroutines are lightweight threads for writing asynchronous code sequentially using suspend functions.
In Android they run network and database work off the main thread with Dispatchers.IO and return results to the UI with Dispatchers.Main.
Structured concurrency through viewModelScope and lifecycleScope cancels work automatically, and Flow handles streams of data.
Room is Jetpack's persistence library on top of SQLite.
You define entities as data classes, DAOs with SQL queries checked at compile time, and a database class.
It supports suspend functions and Flow for reactive queries, migrations for schema changes, and is the recommended way to store structured data locally for offline support.
Define an interface with annotated suspend functions such as @GET("users/{id}") suspend fun getUser(@Path("id") id: String): User, build a Retrofit instance with a base URL and a converter (kotlinx.serialization or Moshi), and call it from a repository on Dispatchers.IO. OkHttp underneath handles connection pooling, caching, timeouts and interceptors for logging and authentication headers.
Hilt is Android's recommended dependency injection library, built on Dagger.
You annotate the Application with @HiltAndroidApp, activities and fragments with @AndroidEntryPoint, ViewModels with @HiltViewModel, and provide dependencies through @Inject constructors or @Module classes with @Provides and @Binds, scoped to components such as Singleton or ViewModel.
It makes classes testable and wiring automatic.
Most apps use a single activity with the Navigation component.
In Compose, a NavHost defines destinations, and a NavController navigates between them with type-safe routes defined as serializable classes, supporting arguments, deep links, nested graphs and the back stack.
Navigation 3 is a newer Compose-first library where the app owns the back stack directly.
LiveData is lifecycle-aware observable data from the older Architecture Components.
StateFlow is a Kotlin Flow that always holds a current value, like LiveData, and is the modern choice for UI state, collected with collectAsStateWithLifecycle in Compose or repeatOnLifecycle in views.
SharedFlow has no current value and suits one-off events such as showing a message.
SharedPreferences has a synchronous API that can block the main thread, no proper error handling and no transactional safety.
DataStore uses coroutines and Flow, handles errors and updates data safely.
Preferences DataStore stores key-value pairs, and Proto DataStore stores typed objects.
Structured data still belongs in Room.
remember keeps a value across recompositions, rememberSaveable also survives configuration changes and process death, and mutableStateOf triggers recomposition when changed.
State should usually be hoisted to the caller or a ViewModel.
Side effects use effect handlers: LaunchedEffect runs suspend work tied to keys, DisposableEffect cleans up, and rememberCoroutineScope launches coroutines from events.
A ViewModel survives configuration changes such as rotation, but not process death, when Android kills the app in the background to reclaim memory.
SavedStateHandle in the ViewModel and rememberSaveable in Compose store small UI state, such as form input or a selected tab, that is restored when the user returns.
Larger data is reloaded from the database or network.
System design, deep internals, leadership and tough follow-ups.
In MVVM, the View (activity, fragment or composable) observes state from a ViewModel, which gets data from repositories.
Google's recommended architecture adds a UI layer, an optional domain layer with use cases, and a data layer with repositories combining remote (Retrofit) and local (Room) sources.
Unidirectional data flow, where events go up and state comes down, makes the app predictable and testable.
For deferrable work that must complete even if the app closes or the device restarts, such as uploads or sync, I use WorkManager with constraints such as network or charging.
For work while the user is in the app, coroutines in viewModelScope.
For ongoing user-visible tasks such as music playback or navigation, a foreground service with a notification.
Android restricts background execution to save battery.
I use Android Studio profilers for CPU, memory and network, LeakCanary for memory leaks, and Baseline Profiles and Macrobenchmark for startup time. Common fixes are moving work off the main thread to avoid ANRs, reducing overdraw and recompositions in Compose, loading and caching images efficiently with Coil or Glide, paging large lists, and reducing app size with R8.
Use HTTPS only through a network security configuration, consider certificate pinning for sensitive apps, store tokens with the Android Keystore (EncryptedSharedPreferences is deprecated, so use Keystore-backed encryption), never hard-code secrets in the app, enable R8 to shrink and obfuscate code, avoid exporting components unnecessarily, validate intents, use the Play Integrity API to detect tampered devices and keep dependencies updated.
Splitting a large app into Gradle modules speeds up builds through parallel and incremental compilation, enforces clear boundaries, and lets teams work independently.
A common structure has an app module, feature modules (such as feature:login), and core modules (core:data, core:ui, core:network).
Convention plugins share build logic, and feature modules depend on core modules, not on each other.
Local unit tests with JUnit and MockK or fakes cover ViewModels, use cases and repositories, using kotlinx-coroutines-test for coroutines and Turbine for Flows.
Robolectric runs Android framework code on the JVM.
Instrumented UI tests use Compose testing APIs or Espresso on devices or emulators, and screenshot tests catch visual regressions.
Hilt provides test doubles.
Make the local Room database the single source of truth: the UI observes it with Flow, so it works without a connection.
Repositories fetch from the network and update the database, and user changes are saved locally first and then synced to the server with WorkManager when connectivity returns, with conflict handling such as timestamps or server rules.
Paging 3 with RemoteMediator handles large lists.
Build a signed AAB with Play App Signing, test it on the internal, closed and open testing tracks, complete the store listing, content rating and data safety form, then release to production with a staged rollout starting at a small percentage while watching Android vitals, crashes and ANRs. New personal developer accounts must run a closed test with testers before production access.
See all Mobile App Developer interview questions, covering Android, Kotlin, iOS, Swift, SwiftUI and more.