Structured Concurrency in Kotlin Coroutines

What's really being asked

Your understanding of coroutine lifecycles, parent-child relationships, and the automatic propagation mechanisms that prevent resource leaks. It's a question about writing safe, reliable, and non-leaky concurrent code, not just about syntax. The interviewer wants to see that you grasp the "structure" part: how coroutines are contained within a defined lifecycle.

The full answer

Four key points in order. First, define Structured Concurrency as a paradigm where coroutines have their lifecycle bound to a CoroutineScope. The scope does not finish until all its children have completed. Second, explain the parent-child relationship: launching a coroutine within a scope makes it a child of the scope's Job. This creates a structured tree. Third, describe cancellation propagation: cancelling the parent Job immediately cancels all its children, preventing orphaned coroutines. Fourth, detail exception propagation: with a standard Job, an uncaught exception in any child coroutine will cancel its siblings and then propagate up to the parent, cancelling the entire scope.

The mistakes people make

The most common mistake is giving a vague answer like "it groups coroutines" or "it makes code cleaner." This misses the core lifecycle guarantees. Another red flag is mentioning GlobalScope as an example of structured concurrency; it's the exact opposite, creating top-level, unstructured coroutines. A senior candidate should also be able to distinguish the default exception behavior from the behavior with a SupervisorJob, where child failures are isolated. Failing to explain the "all-for-one" failure model of a standard Job is a sign of an incomplete understanding.

What usually comes next

"When would you use a SupervisorJob?" (When you have a scope with independent children, and one child's failure should not affect the others, like UI elements updating from different sources). "How does async's exception handling differ from launch?" (async holds the exception until .await() is called, while launch propagates it immediately). "What's the difference between the coroutineScope builder function and the CoroutineScope interface?" (coroutineScope is a suspending function that creates a sub-scope which waits for all its children, while CoroutineScope is the interface that defines the scope itself).

A concrete example

In Android, viewModelScope is a CoroutineScope tied to a ViewModel's lifecycle. When a user navigates away, the ViewModel is cleared, and its onCleared() method cancels viewModelScope. This automatically cancels any ongoing network requests launched within it. If a network request would take 5 seconds but the user leaves after 1 second, the coroutine is cancelled, saving resources and preventing crashes when the result tries to update a non-existent UI.