Android and Kotlin Interview Questions

What should you review for an Android and Kotlin interview?

Which topics should you start with?

Kotlin Multiplatform appeared in the most interviews, covering 11 of 30 interviews. Android fundamentals and architecture were the next most common topics in these interviews. Start with concrete checks: can you explain what code you would share across platforms, how an Android lifecycle works, and why you use a ViewModel?

The questions span junior, mid-level, and senior levels. Use them to check both basic terms and design choices. For example, can you define an extension function and explain what advantage it gives you?

Can you explain Kotlin Multiplatform trade-offs?

The most asked question covered Kotlin Multiplatform challenges, trade-offs, and how to address them. It appeared in 3 of 30 interviews. The topic also covers Compose Multiplatform, working with Swift, platform differences, migration, and team organization.

Check whether you can answer:

• What code would you share, and what would stay specific to each platform?
• What challenges would you address when working with Swift?
• How would you choose a framework and plan a migration?
• How would you organize work across a cross-platform team?

Can you explain Kotlin and coroutine choices?

Repeated questions include extension functions, inline, noinline, and crossinline. Can you explain what each keyword means in a higher-order function?

For coroutines and Flow, check these questions:

• How do launch and async differ, including how their execution is dispatched?
• What are coroutine scopes, and when would you use viewModelScope or another scope?
• What do dispatchers control?
• What is a Flow, and how would you create one?

Also check whether you can explain structured concurrency and coroutine exception handling. Both are covered by this topic.

Can you connect architecture to app behavior?

Architecture questions cover ViewModels, state delivery, module boundaries, use cases, dependency injection, and app design exercises. Can you explain how state reaches the UI and where dependency injection fits in your design?

For Compose, can you explain state, recomposition, and effects? For Android fundamentals, can you describe how push notifications work and how you would implement them? These checks go beyond naming the tools.

What implementation details should you check?

A coding task appeared in 1 of 30 interviews: defining a Room database class, including its database name and entities. Can you write that class and explain Room setup and migrations?

Check whether you can describe how you would investigate startup problems, memory leaks, or an app that stops responding. For releases, can you explain staged rollouts, feature flags, and rollback strategies?

Who gets asked Android and Kotlin

The 20 most asked Android and Kotlin questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. What challenges and trade-offs come with Kotlin Multiplatform, and how would you address them?

   Asked in 3 of 30 interviews · last asked May 19 · Scenario · Senior

   Show answer

   Kotlin Multiplatform shares Kotlin code across platforms, but it adds build complexity and still needs platform expertise. I would start with shared business logic, keep platform-specific features separate, and check library support early. For iOS, I would work with iOS developers on Swift-facing APIs and test both shared logic and native integration.

   • Share stable logic first; sharing UI is optional and may limit platform-specific design.
   • Some libraries lack support for every target; use platform-specific implementations behind shared interfaces.
   • Swift interoperability can need wrappers to make shared APIs easy to use.
   • Run tests on each target and budget for CI, debugging, and toolchain maintenance.

   What the interviewer checks: The interviewer checks whether you can balance code reuse against integration costs and plan a practical rollout.

   Other ways it was asked

   • “What potential downsides or trade-offs of Kotlin Multiplatform should leadership be aware of?”
   • “Can you explain any issues you’ve encountered with Kotlin Multiplatform?”
   • “Can you explain how Kotlin Multiplatform works in principle?”

2. What is an extension function in Kotlin, and what advantage does it give you?

   Asked in 2 of 30 interviews · last asked Sep 2 · Concept · Junior

   Show answer

   An extension function lets you call a new function on an existing type without changing its class or using inheritance. You define it by placing the receiver type before the function name, such as `fun String.lastWord()`. It makes helper functions easier to read and use, including for library classes.

   • Inside the function, `this` refers to the receiver object.
   • Extensions cannot access private or protected members of the receiver.
   • Extensions are resolved using the declared receiver type, not its runtime type.
   • A matching class member takes priority over an extension.

   CodeCopy

   fun String.lastWord(): String = trim().substringAfterLast(' ')
   
   fun main() {
       println("Hello Kotlin".lastWord()) // Kotlin
   }

   What the interviewer checks: The interviewer checks whether you understand extension syntax, its readability benefit, and its limits compared with real class members.

   Other ways it was asked

   • “How do you define an extension function in Kotlin?”

3. What do inline, noinline, and crossinline mean in Kotlin higher-order functions?

   Asked in 2 of 30 interviews · last asked Apr 11 · Concept · Senior

   Show answer

   `inline` asks the compiler to copy a function’s body and eligible lambda bodies into each call site. `noinline` keeps a lambda parameter as a normal function value, so it can be stored or passed elsewhere. `crossinline` allows inlining but forbids the lambda from using `return` to exit the enclosing function.

   • Inlining can reduce lambda allocations and call overhead, but may increase generated code size.
   • An inline lambda can normally use a non-local return to exit its enclosing function.
   • Use `noinline` when the lambda must be treated as a regular function value.
   • Use `crossinline` when invoking the lambda inside another execution context, such as a Runnable; labeled returns remain allowed.

   What the interviewer checks: The interviewer checks whether you understand inlining, lambda storage, and local versus non-local returns.

   Other ways it was asked

   • “What does noinline do in Kotlin?”
   • “Can you explain what inline functions are in Kotlin?”

4. How do push notifications work, and how would you implement them in a mobile app?

   Asked in 2 of 30 interviews · last asked Sep 30 · Scenario · Mid-level

   Show answer

   Push notifications let a server send messages through FCM on Android or APNs on iOS. On Android, I would add FCM, register its device token with my backend, and handle incoming messages using FirebaseMessagingService. I would configure notification channels, request notification permission where required, and make notification taps open the right screen.

   • Android 8+ requires channels for apps targeting API 26+; Android 13+ requires runtime permission for most notifications.
   • FCM automatically displays notification messages in the background; foreground messages need app handling.
   • Send refreshed tokens to the backend, and remove their user association on logout.
   • Delivery is not guaranteed or always immediate; fetch current data when the app opens.

   What the interviewer checks: The interviewer checks whether you understand the delivery flow, backend registration, Android requirements, and foreground versus background handling.

   Other ways it was asked

   • “How would you handle push notifications in a mobile app?”
   • “How do push notifications work?”

5. How do launch and async differ in Kotlin coroutines, including how their execution is dispatched?

   Asked in 2 of 30 interviews · last asked Apr 11 · Concept · Mid-level

   Show answer

   `launch` returns a `Job`, with no result value. `async` returns a `Deferred<T>`; `await()` waits for its result or throws its exception. Both use the scope's dispatcher unless overridden, or `Dispatchers.Default` if none exists. The dispatcher controls where execution runs; neither builder guarantees a new thread or parallel execution.

   • `join()` waits for completion but does not return a result or rethrow the coroutine's failure.
   • Both start by default; `CoroutineStart.LAZY` delays starting until needed.
   • A root `launch` reports uncaught failures; a root `async` exposes failures through `await()`.
   • In a regular scope, either child's failure cancels its parent; `async` does not wait for `await()`.

   What the interviewer checks: The interviewer checks result handling, failure propagation, and whether you understand that dispatching works the same for both builders.

   Other ways it was asked

   • “How do launch and async differ in Kotlin coroutines, and how is execution dispatched in each?”
   • “What is the difference between launch and async?”

6. What are coroutine scopes, including viewModelScope, and when should you use each?

   Asked in 2 of 30 interviews · last asked Sep 2 · Concept · Mid-level

   Show answer

   A coroutine scope defines the context and lifetime of coroutines launched in it. Use viewModelScope for ViewModel work; cancellation happens when the ViewModel is cleared. Use lifecycleScope for Activity or Fragment work; cancellation happens when that lifecycle is destroyed. For Fragment UI work, use viewLifecycleOwner.lifecycleScope.

   • viewModelScope survives configuration changes when the same ViewModel is retained.
   • Use repeatOnLifecycle within a lifecycle scope to stop and restart UI collection as visibility changes.
   • Use coroutineScope to group child tasks; supervisorScope lets siblings continue when one child fails.
   • Use an owned application scope for work that must outlive screens; avoid GlobalScope for ordinary app work.

   What the interviewer checks: The interviewer checks whether you can match coroutine lifetime and cancellation to the owner of the work.

   Other ways it was asked

   • “What are the main coroutine scopes in Kotlin, and when would you use each?”
   • “What is coroutine scope, and what is ViewModel scope?”

7. What are coroutine dispatchers in Kotlin, and what do they control?

   Asked in 2 of 30 interviews · last asked Sep 2 · Concept · Mid-level

   Show answer

   A coroutine dispatcher controls where a coroutine runs and resumes, usually by choosing a thread or thread pool. On Android, use Dispatchers.Main for UI work, Dispatchers.IO for blocking I/O, and Dispatchers.Default for CPU-heavy work. A coroutine usually inherits its dispatcher from its scope, but you can change it with withContext.

   • A dispatcher is part of the coroutine context.
   • Suspending a coroutine does not block its thread; blocking code still does.
   • A dispatcher does not always keep a coroutine on the same thread.
   • Dispatchers.Main requires platform support, such as kotlinx-coroutines-android.

   What the interviewer checks: The interviewer checks whether you can choose the right dispatcher and keep blocking or CPU-heavy work off the UI thread.

   Other ways it was asked

   • “What are dispatchers in coroutines?”
   • “What is a dispatcher, and what is its purpose?”

8. What are Kotlin coroutines?

   Asked in 2 of 30 interviews · last asked Sep 2 · Concept · Junior

   Show answer

   Kotlin coroutines are lightweight tasks that let you write asynchronous code in a sequential style. They can suspend while waiting without blocking a thread, then resume later. They are not threads; dispatchers control which threads they run on. On Android, they help keep the main thread responsive.

   • A suspend function can pause a coroutine, but does not automatically run on a background thread.
   • Use Dispatchers.IO for blocking I/O and Dispatchers.Default for CPU-heavy work.
   • Coroutine scopes manage task lifetimes and support structured concurrency.
   • Cancellation is cooperative: running code must reach a cancellation check to stop.

   What the interviewer checks: The interviewer checks whether you understand suspension, threads, dispatchers, and coroutine lifetimes.

   Other ways it was asked

   • “What is a coroutine?”

9. What is a Kotlin Flow, and how do you create one?

   Asked in 2 of 30 interviews · last asked Sep 2 · Concept · Junior

   Show answer

   A Kotlin Flow is a stream of values that can be produced and collected asynchronously using coroutines. Create one with the flow builder and send values with emit, or use flowOf for fixed values. A flow built with flow is cold: its code runs separately for each collector when collect is called.

   • Flow<T> represents a stream of values of type T.
   • The flow builder supports suspending calls, such as network requests.
   • Use collect in a coroutine or suspend function to receive values.
   • Not all flows are cold: StateFlow and SharedFlow are hot flows.

   CodeCopy

   import kotlinx.coroutines.flow.Flow
   import kotlinx.coroutines.flow.collect
   import kotlinx.coroutines.flow.flow
   suspend fun main() {
       val numbers: Flow<Int> = flow {
           emit(1)
           emit(2)
       }
       numbers.collect { println(it) }
   }

   What the interviewer checks: The interviewer checks whether you can create and collect a Flow and explain when it starts running.

   Other ways it was asked

   • “What is a Flow?”
   • “Can you write in the chat how to declare a Flow?”
   • “How does Flow work?”

10. What is a ViewModel, and why do you use it?

    Asked in 2 of 30 interviews · last asked Sep 2 · Concept · Junior

    Show answer

    A ViewModel is an Android Jetpack class that holds screen state and handles screen-level logic. It keeps that state during configuration changes, such as screen rotation, so a recreated screen can use it. It also keeps this logic separate from Activities, Fragments, or composables, making it easier to test.

    • A ViewModel survives configuration changes, but not process death.
    • Use SavedStateHandle to restore small pieces of state after system-initiated process death.
    • Do not hold references to Views or Activities; they can cause memory leaks.
    • A ViewModel is cleared when its owner is permanently removed.

    What the interviewer checks: The interviewer is checking whether you understand ViewModel lifetime, state handling, and separation of UI code from logic.

    Other ways it was asked

    • “What is a ViewModel, and what is it used for in Android?”

11. What software architecture do you use for Android applications, and why?

    Asked in 2 of 30 interviews · last asked Oct 2 · Concept · Senior

    Show answer

    I usually use MVVM with a repository layer for Android apps. The UI displays state from a ViewModel, while repositories handle data access. This separates responsibilities and makes testing easier. For complex apps, I add a domain layer with use cases, but I avoid extra layers for simple apps.

    • The ViewModel exposes UI state and handles UI actions without holding Activity or Fragment references.
    • Repositories hide data sources, such as network APIs and local databases.
    • ViewModels survive configuration changes, but process death needs saved state or persistent storage.
    • Choose layers based on app complexity; more layers add code and maintenance.

    What the interviewer checks: The interviewer checks whether you can explain your architecture choice, its benefits, and its trade-offs.

    Other ways it was asked

    • “Which architecture pattern would you choose for an Android application, and why?”

12. When does LaunchedEffect run in Jetpack Compose, and how do its keys control restarts?

    Asked in 2 of 30 interviews · last asked Feb 12 · Concept · Mid-level

    Show answer

    LaunchedEffect starts a coroutine when it enters the composition. If any key changes, Compose cancels the running coroutine and starts a new one. Recomposition with equal keys does not restart it, and leaving the composition cancels it. It accepts one or more keys and a suspending block, which can call regular or suspending functions.

    • Keys are compared using equality, not just object identity.
    • A constant key, such as Unit, runs once per entry into the composition.
    • Use keys for values whose changes should restart the work.
    • It does not automatically move work to a background thread; avoid blocking the UI thread.

    What the interviewer checks: The interviewer checks whether you understand effect lifetime, key-based restarts, and coroutine cancellation.

    Other ways it was asked

    • “When does LaunchedEffect run in Jetpack Compose?”
    • “How does LaunchedEffect work in Jetpack Compose, how do its keys control when it runs, and what kinds of code can it execute?”
    • “What parameters does LaunchedEffect accept in Jetpack Compose?”

13. What should be shared in Kotlin Multiplatform, and what should remain platform-specific?

    Asked in 2 of 30 interviews · last asked May 18 · Design · Mid-level

    Show answer

    Share business rules, data models, validation, and data access that use multiplatform libraries. Keep direct OS calls and native integrations in platform-specific code. Native UI stays platform-specific, but UI can also be shared with Compose Multiplatform. On iOS, app startup, lifecycle integration, and Apple framework calls usually remain platform-specific.

    • Use commonMain for code that does not depend directly on Android or iOS APIs.
    • Connect shared logic to platform features through interfaces or expect/actual declarations.
    • Share networking and storage logic when libraries support all target platforms.
    • UI sharing is optional; SwiftUI and UIKit screens remain iOS-specific.

    What the interviewer checks: The interviewer checks whether you can separate reusable logic from platform dependencies without assuming UI must stay native.

    Other ways it was asked

    • “In a Kotlin Multiplatform project, what belongs in shared code, and what should remain in the platform-specific UI?”
    • “What responsibilities or functionality typically remain in the iOS-specific code of a Kotlin Multiplatform app?”
    • “Which parts of an application generally cannot be shared in Kotlin Multiplatform?”

14. What is a typealias in Kotlin, and when would you use one?

    Asked once · last asked Feb 10 · Concept · Mid-level

    Show answer

    A typealias gives another name to an existing Kotlin type. It does not create a new type. I use it to make long generic types or function types easier to read and to show their purpose.

    • Declare an alias with the typealias keyword.
    • The alias and the original type are interchangeable.
    • It improves readability but does not add type safety.

    CodeCopy

    typealias UserNames = Map<String, String>
    
    val names: UserNames = mapOf("u1" to "Ana")

    What the interviewer checks: The interviewer is checking whether you understand that a typealias is another name, not a separate type.

    Other ways it was asked

    • “Can you give an example of a Kotlin typealias?”

15. What is the difference between object and companion object in Kotlin, and when would you use each?

    Asked once · last asked Feb 10 · Concept · Mid-level

    Show answer

    An `object` declaration creates a singleton: one shared instance of a type. A `companion object` is a singleton inside a class, whose members you can access through the class name. Use `object` for standalone shared utilities, and a companion object for factory functions or constants closely tied to a class.

    • A class can have only one companion object.
    • You do not need a class instance to access its companion members.
    • Companion functions are not Java static methods by default; use `@JvmStatic` for Java-friendly static access.
    • Both can implement interfaces.

    What the interviewer checks: The interviewer checks whether you understand shared instances and when to tie shared behavior to a class.

16. What are lateinit and lazy in Kotlin, and how do they differ?

    Asked once · last asked Feb 10 · Concept · Mid-level

    Show answer

    `lateinit` lets you declare a non-null `var` and assign it later. Reading it before assignment throws `UninitializedPropertyAccessException`. `lazy` initializes a `val` when it is first read, then reuses the result. With `lateinit`, you control assignment; with `lazy`, a supplied function creates the value.

    • `lateinit` cannot use nullable types or primitive types such as `Int` and `Boolean`.
    • A `lateinit var` can be reassigned; a `lazy val` cannot.
    • Where accessible, `::property.isInitialized` checks whether a `lateinit` property has been assigned.
    • On the JVM, `lazy` uses synchronized initialization by default; `lateinit` provides no thread safety.

    What the interviewer checks: The interviewer checks whether you understand initialization timing, mutability, and the risks of reading values too early.

17. What happens if a lateinit property is accessed before it has been initialized?

    Asked once · last asked Feb 10 · Concept · Junior

    Show answer

    Accessing a Kotlin lateinit property before it is initialized throws an UninitializedPropertyAccessException at runtime. Assign a value before reading it. Where Kotlin allows access to its backing field, you can check initialization with this::property.isInitialized.

    • The exception message names the uninitialized property.
    • Reading it does not return null or a default value.
    • The isInitialized check is only available where Kotlin allows access to the property's backing field.

    What the interviewer checks: The interviewer is checking whether you understand lateinit initialization and the runtime failure caused by reading it too early.

18. How do you overload operators such as plus in Kotlin, and what restrictions apply?

    Asked once · last asked Feb 10 · Concept · Mid-level

    Show answer

    Define an `operator` member or extension function with Kotlin's required name and signature. For example, defining `plus` lets you write `a + b`. You can overload only supported operators; you cannot create new operator symbols or change their precedence.

    • `plus` takes one argument and can return a custom type, not just a number.
    • A matching member function takes priority over an extension function.
    • `plusAssign`, used for `+=`, must return `Unit`.

    CodeCopy

    data class Point(val x: Int, val y: Int) {
        operator fun plus(other: Point): Point =
            Point(x + other.x, y + other.y)
    }
    
    val sum = Point(1, 2) + Point(3, 4) // Point(4, 6)

    What the interviewer checks: The interviewer checks whether you know operator function conventions and the limits of operator overloading.

    Other ways it was asked

    • “How do you implement a custom operator in Kotlin, and what restrictions apply?”
    • “Can you overload operators in Kotlin?”
    • “Can arithmetic operators be overloaded in Kotlin, for example for numeric types?”

19. What is the scope of a private top-level function in Kotlin?

    Asked once · last asked Feb 12 · Concept · Mid-level

    Show answer

    A private top-level function in Kotlin is visible only inside the file where it is declared. Code in another file cannot access it, even if both files are in the same package.

    • Visibility is limited to the declaring file, not the package.
    • Functions and classes in that file can access it.

    What the interviewer checks: The interviewer is checking whether you know that top-level private visibility is file-based, not class-based or package-based.

20. Which Kotlin language features help you write more concise code?

    Asked once · last asked Feb 12 · Concept · Junior

    Show answer

    Kotlin reduces repeated code with type inference, data classes, default arguments, and named arguments. Properties and string templates simplify common tasks. Lambdas and extension functions make reusable logic shorter, while safe calls and the Elvis operator simplify null handling.

    • Type inference removes many explicit type declarations without losing static type checking.
    • Data classes generate methods such as equals(), hashCode(), toString(), and copy().
    • Default arguments reduce overloads; named arguments make calls easier to read.
    • Safe calls (?.) and the Elvis operator (?:) reduce explicit null checks.

    What the interviewer checks: The interviewer wants to know whether you can connect Kotlin features to less repeated, readable code.

Related interview questions

• Software Engineer interview questions
• QA Engineer interview questions
• Machine Learning Engineer interview questions
• React interview questions
• Angular interview questions
• Node.js interview questions
• Next.js interview questions
• HTML and CSS interview questions
• Spring Boot interview questions
• iOS and Swift interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every Android and Kotlin interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

30 interviews, 20 candidates, Feb 2026 to Oct 2026. Updated every month with new interviews.