Difference between launch and async in Kotlin Coroutines
This tests your grasp of coroutine result handling and exception propagation. Explain that launch is fire-and-forget (returns Job), while async is for results (returns Deferred). Mention async defers exceptions until await().
What's really being asked
This question probes your understanding of the two fundamental coroutine builders. The interviewer is testing your ability to choose the correct tool based on whether a concurrent task needs to return a value. For a senior role, the key differentiator is your knowledge of their distinct exception handling mechanisms and how that impacts application stability and structured concurrency.
The full answer
First, the return type: launch returns a Job, which is a handle to the coroutine but carries no result. async returns a Deferred<T>, a type of Job that promises a result of type T in the future. Second, the primary use case: launch is for "fire-and-forget" tasks like UI updates or logging, where you don't need a return value. async is for performing computations that produce a value, especially for running multiple tasks in parallel to combine their results later. Third, and most importantly, exception handling: launch propagates exceptions immediately up the coroutine hierarchy, which can crash the app if unhandled. async encapsulates any exception within the Deferred object. The exception is only thrown when you call .await().
The mistakes people make
Stating only that "async returns a value." This is a junior-level answer that misses the critical point about exception handling. Another red flag is suggesting the use of async without calling await(). This creates a "deferred leak" where exceptions are silently swallowed because .await() is never called to surface them. You should use launch if you truly don't care about the result or its potential failure. Confusing Job.join() with Deferred.await() is also a mistake; join() only waits for completion, it does not return a value or throw the encapsulated exception.
What usually comes next
How would you run two network requests in parallel and combine their results? (The canonical use case for async). What happens if one of those async blocks fails before you await it? (The exception is stored, and await will throw it). How do you prevent a launch failure from crashing your whole scope? (By installing a CoroutineExceptionHandler). What is a SupervisorJob and how would it change this behavior? (It isolates child failures, preventing one failing child from cancelling its siblings).
A concrete example
Use launch for side effects: viewModelScope.launch { repository.saveUserData(user) }. This is a one-way operation. Use async for parallel decomposition to get a result: coroutineScope { val user = async { api.fetchUser() }; val permissions = async { api.fetchPermissions() }; showUI(user.await(), permissions.await()) }. This fetches two independent data sources concurrently, waits for both, and then uses the combined results.
Interview question
When running a background task that might fail, how do you defer exception handling until the result is actually needed?
- a.Use `async` and avoid calling `await()` to suppress the exception.
- b.Use `launch` with a `CoroutineExceptionHandler` to catch the error.
- c.Use `launch` and wrap the call to `join()` in a `try-catch` block.
- d.Use `async` and wrap the call to `await()` in a `try-catch` block.Correct
Why? this is the answer
`async` encapsulates any exception, which is re-thrown only when `await()` is called, allowing for deferred handling. In contrast, `launch` propagates exceptions immediately, so a `CoroutineExceptionHandler` would trigger right away.
Just read this? Test yourself on what you have been reading.
Read the original → kotlinlang.org
You just looked this up. Could you explain it out loud?
That is the part interviews actually test. Tezvyn takes questions like this one and gives you what the interviewer is really checking, the answer that lands, and the mistake that ends the conversation, in the four minutes before your next meeting.
The iPhone app is on the way
We are building it. Until it lands, nothing here is held back from you: every interview card, your saved cards, streaks and the job board all work in Safari, plus hundreds of free practice quizzes of thirty questions each. Sign in and it all carries over to the app the day it arrives.
Want it as an icon? Tap Share at the bottom of Safari, then Add to Home Screen. It opens full screen and the cards you have read stay available offline.
We are hiring for this. Open roles that interview on kotlin — each one lists the topics its interview covers.
See open roles