Android Developer Interview Questions: The Hard Ones and How to Answer Them

Junior interviews test if you know the APIs. Senior interviews test if you understand the tradeoffs. Here are the questions that separate prepared candidates from the rest.

Architecture Questions

Q: What's the difference between

StateFlow

SharedFlow

StateFlow

SharedFlow

The key distinction: if a new subscriber should see the latest state, use

StateFlow

SharedFlow

replay = 0

Q: How does Hilt handle scope and what are the different component scopes?

Hilt components have a hierarchy:

• code Copy

  SingletonComponent

  — lives as long as the Application. Use for repositories, database, network client.
• code Copy

  ActivityRetainedComponent

  — survives configuration changes, tied to ViewModel lifecycle. Use for ViewModel-scoped dependencies.
• code Copy

  ActivityComponent

  — tied to Activity lifecycle. Use for dependencies needing Activity context.
• code Copy

  ViewModelComponent

  — tied to a specific ViewModel. Use for per-ViewModel state.
• code Copy

  FragmentComponent

  ,
  code Copy

  ViewComponent

  ,
  code Copy

  ServiceComponent

  — tied to their respective lifecycle.

A dependency in

SingletonComponent

ActivityComponent

Q: Explain the Clean Architecture layers and what shouldn't cross between them.

Domain layer contains business rules (use cases, domain models, repository interfaces). It has zero Android or framework imports — pure Kotlin.

Data layer implements repository interfaces. It knows about Room, Retrofit, and how to map between network/database types and domain models.

Presentation layer (ViewModel + UI) depends on use cases from Domain, not on Data implementations directly.

What shouldn't cross:

• Domain should not import Android SDK classes or third-party networking/DB libraries
• ViewModel should not import Room DAOs directly — access through use cases/repositories
• Network DTOs should not appear in ViewModel — map to domain models in the repository

Coroutines and Concurrency

Q: What happens when you launch a coroutine with

GlobalScope

GlobalScope

1. Memory leaks: references held by the coroutine prevent garbage collection
2. No lifecycle awareness: the coroutine continues after the Activity/ViewModel is destroyed
3. No structured concurrency: exceptions aren't propagated to a parent, they crash the app silently (or get swallowed depending on the exception handler)

Solution: use

viewModelScope

lifecycleScope

Q: What's the difference between

launch

async

await

launch

Job

async

Deferred<T>

.await()

When you need two concurrent operations and both results:

val aDeferred = async { fetchUserProfile() }
val bDeferred = async { fetchUserTasks() }
val profile = aDeferred.await()
val tasks = bDeferred.await()

If you used

launch

async

await

Performance

Q: How do you identify and fix recomposition performance problems in Compose?

First, identify: use the Layout Inspector's Recomposition Counts view or add

SideEffect { println("recomposing") }

Common causes:

1. Unstable types as parameters:
   code Copy

   List<T>

   is unstable. Use
   code Copy

   ImmutableList

   from
   code Copy

   kotlinx.collections.immutable

   .
2. Lambda instances changing on each recomposition: use
   code Copy

   remember { lambda }

   or
   code Copy

   viewModel::method

   .
3. Reading state at a high level: read state as low in the tree as possible — only composables that read a specific state recompose when it changes.
4. Missing keys in
   code Copy

   LazyColumn

   : without stable keys, reordering looks like replacing all items.

The fix is often: make parameters stable, move state reads lower, and add keys to lists.

Testing

Q: How do you test a ViewModel that depends on a Flow from a repository?

Three approaches, depending on complexity:

1. Fake repository with a FakeFlow: inject a

   code Copy

   FakeTaskRepository

   that has a
   code Copy

   MutableStateFlow

   . In the test, emit to the fake flow and assert on ViewModel state.

2. Turbine for Flow testing:

viewModel.uiState.test {
    assertEquals(Loading, awaitItem())
    fakeRepository.emitTasks(testTasks)
    assertEquals(Success(testTasks), awaitItem())
    cancelAndIgnoreRemainingEvents()
}

3. MainDispatcherRule: ViewModels use
   code Copy

   Dispatchers.Main

   . In JVM tests, replace it with
   code Copy

   UnconfinedTestDispatcher

   via
   code Copy

   MainDispatcherRule

   .

All three are needed together for deterministic ViewModel tests.

Q: What's the difference between testing with Robolectric vs on an emulator?

Robolectric runs Android SDK classes on the JVM without an emulator. Tests run fast (seconds vs minutes). Good for: ViewModel tests, DAO tests, anything that doesn't need hardware or actual rendering.

Instrumentation tests run on a real device or emulator. They test against the real Android framework, real rendering, real GPU. Required for: UI tests (Espresso/Compose testing), anything touching hardware, tests where Android behavior differs from Robolectric emulation.

Robolectric occasionally has discrepancies from real Android behavior. Critical flows should be tested on-device, not just in Robolectric.

Questions You Should Ask

At the end of every Android interview, ask:

• "What's your target and min SDK, and how do you handle API-level differences?"
• "What's your test strategy — what do you automate vs keep manual?"
• "How does the team handle the Compose/XML migration if it's ongoing?"

These questions reveal the team's technical maturity more than the interview questions do.

Takeaways

• Architecture questions test understanding of why the separation exists, not just what the layers are
• Coroutine questions test structured concurrency understanding —
  code Copy

  GlobalScope

  is a red flag
• Performance questions in Compose often reduce to stability and state reading levels
• Testing questions assess whether you understand when to use which tool (unit vs integration vs UI)
• The questions you ask at the end matter — they show you evaluate team health, not just accept any offer