A banking Android app has 35 screens, 12 long-lived repositories, and a 150 ms navigation target. How would you define coroutine ownership across activities, ViewModels, and repositories?

I would make each coroutine belong to the narrowest lifecycle that must keep its result alive. - UI rendering work stays in lifecycleScope with repeatOnLifecycle, while screen state production belongs to viewModelScope so rotation does not restart useful work. - Repositories expose suspend functions or cold Flows and do not create hidden application scopes; the caller owns cancellation unless a documented process truly outlives the screen. - The few process-wide jobs use one injected application CoroutineScope with a SupervisorJob, named children, and explicit shutdown in tests.

A Ktor service handles 8,000 requests per second with a 200 ms p99 SLA and also refreshes caches every minute. How would you separate request and application coroutine scopes?

I would keep request work as children of the call scope and reserve an application scope only for explicitly process-owned jobs. - Database calls, downstream HTTP calls, and response assembly inherit request cancellation and its deadline, so disconnected or timed-out calls stop consuming capacity. - Cache refreshers run under an application SupervisorJob because one failed refresh must not cancel request handling or unrelated refreshers. - Shutdown first stops admission, then cancels the application scope and waits a bounded 10 seconds for owned jobs to finish.

An Android client performs image decoding, Room queries, and three HTTP calls during startup, but may use at most four background threads on low-end devices. How would you allocate dispatcher budgets?

I would place every startup executor under one four-thread process budget, including Room and the HTTP client. - One shared four-thread Executor backs the coroutine dispatcher, Room query and transaction executors, and the HTTP client's Dispatcher; any client that requires a dedicated executor must consume part of the same four-thread budget. - Dispatcher views cap decoding at two concurrent tasks and Room or HTTP startup work at two each, while the shared Executor enforces the global limit when those workloads overlap. - Startup traces and thread-name counts on the target two-core device must show no more than four background threads; limitedParallelism alone would not cap independent Room or HTTP pools.

A Kotlin/JVM pricing service receives 2,000 calculations per second, each taking 12 ms of CPU, on an 8-core container with a 250 ms p99 target. How would you design coroutine parallelism?

I would reject the 2,000-per-second target on one 8-core container because its CPU demand is three times the physical capacity. - The capacity math is 2,000 × 12 ms = 24 CPU-seconds per wall-clock second, while eight fully occupied cores provide only 8 CPU-seconds. - The workload needs at least three 8-core containers before headroom; I would start with four, which puts nominal CPU utilization near 75% for GC, request parsing, and burst tolerance. - Each container uses core-sized limited parallelism and bounded admission, failing requests that cannot meet 250 ms instead of building an unbounded queue. - Load tests must track queue time, CPU saturation, and deadline failures at 2,000 calculations per second before the four-container rollout is accepted.

A search request fans out to six providers and must return within 300 ms even if one optional provider fails. How would you structure the coroutines?

I would use a bounded coroutineScope for required work and isolate only the optional provider with supervisorScope semantics. - Required async children inherit the 300 ms deadline, and any required failure cancels siblings because a complete required result is impossible. - The optional provider converts its own failure to an explicit unavailable result without hiding cancellation from the parent. - Each provider receives a smaller timeout budget, such as 220 ms, leaving time to rank and serialize the combined response.

A shared Kotlin SDK is used by 18 app modules, and every operation must cancel within 100 ms after its caller leaves a screen. What coroutine API contract would you publish?

I would publish suspending and cold Flow APIs that remain cooperative with caller cancellation and never launch detached work internally. - Long loops call ensureActive or use cancellable suspending primitives, and blocking vendor calls are wrapped in a cancellable adapter only when the vendor supports aborting them. - Cleanup stays in finally with NonCancellable limited to the smallest mandatory close operation, never an entire network retry. - Contract tests cancel each public operation and assert both completion within 100 ms and release of its underlying resource.

A mobile checkout has a 2 second end-to-end SLA across inventory, fraud, and payment calls. How would you propagate time budgets through coroutine layers?

I would pass one monotonic deadline through the call graph and derive each remaining timeout from it. - The orchestration layer allocates explicit sub-budgets, for example 300 ms inventory, 500 ms fraud, and 800 ms payment, while retaining time for local persistence and rendering. - Repositories accept a request context or deadline abstraction rather than each starting a fresh two-second timeout that can multiply total latency. - Timeout is mapped to a typed domain result at the boundary, while CancellationException continues upward unchanged.

Forty feature modules currently expose their own CoroutineScope factories, and architecture review requires one ownership model within two releases. What design would you approve?

I would remove feature-owned scope factories and standardize scopes by lifecycle owner rather than by module. - UI modules receive ViewModel or lifecycle scopes from Android owners, request handlers inherit server call scopes, and repositories expose structured APIs without storing arbitrary scopes. - A small platform module provides only named application and test scopes, with ownership, cancellation, and shutdown documented in its API. - A static rule flags GlobalScope and unmanaged CoroutineScope construction outside the platform module during the two-release migration.

A repository serves 15 screens, and each collector needs a fresh query filtered by its own account ID. Should its public API return Flow, StateFlow, or SharedFlow?

I would return a cold Flow because the query is parameterized per caller and has no single repository-owned current value. - Each collection creates work for that account ID, so the API documents whether Room invalidation reruns the query and how cancellation closes the subscription. - A ViewModel may convert it to StateFlow with stateIn and WhileSubscribed for screen sharing, but that lifecycle policy does not belong in the repository. - If duplicate collectors are expensive, the owner shares the flow at the layer that knows the correct scope and replay duration.

A Compose screen has 11 independent data sources and must restore its latest renderable state immediately after rotation. How would you expose StateFlow?

I would expose one immutable StateFlow of complete screen state from the ViewModel. - The ViewModel combines domain flows into a stable sealed UI state and uses stateIn(viewModelScope, WhileSubscribed(5_000), initialState) to survive short collector gaps. - MutableStateFlow remains private, and updates use atomic update so concurrent actions cannot overwrite each other. - Navigation and transient effects are excluded from durable state unless replaying them after rotation is intentionally part of the contract.

Three collectors observe a login stream, but a navigation command must be consumed once and must not replay after a 500 ms configuration change. Would you use SharedFlow?

I would not model a one-consumer navigation command as a broadly shared replaying event stream. - Durable login status belongs in StateFlow, while navigation is derived by the current UI owner from a state transition or delivered through a single-consumer Channel. - If SharedFlow is required for multiple observers, replay is zero and the contract accepts that emissions with no collector are lost. - The design test covers rotation during emission because replaying a command and dropping a command are both product-visible choices.

A telemetry Flow can receive 20,000 events per second, while its uploader sustains 5,000, and memory is capped at 32 MB. What backpressure contract would you define?

I would make loss policy explicit and use a bounded buffer sized by bytes and acceptable delay. - Low-value counters use DROP_OLDEST with aggregation, while audit-class events bypass this stream into durable storage because they cannot share a lossy contract. - The uploader batches up to 200 events or 100 ms and limits concurrent uploads so downstream pressure remains bounded. - Metrics expose dropped events, buffer occupancy, and oldest-event age, allowing the 32 MB cap to be verified under synthetic peak load.

A dashboard combines 25 StateFlows, and any update must render within 50 ms without recomputing all expensive aggregates. How would you shape the flow graph?

I would split the graph by update frequency and recompute only aggregates whose inputs changed. - Stable domain subgraphs produce typed intermediate StateFlows, so a clock tick does not recalculate account totals or permissions. - Expensive mapping runs before combine, uses distinctUntilChanged on meaningful immutable values, and avoids equality checks on mutable collections. - A benchmark drives 1,000 updates through the graph and measures computation and main-thread render time against the 50 ms budget.

A Bluetooth SDK emits callbacks from four threads and allows only one active listener per device. How would you expose it as Flow to 10 app modules?

I would wrap the callback in callbackFlow and place multi-subscriber sharing behind one device-scoped owner. - awaitClose unregisters the exact listener, trySend handles concurrent callbacks safely, and failed sends are counted rather than retried recursively. - The owner applies shareIn with a documented replay and stop timeout so ten collectors do not register ten native listeners. - Device disconnect is represented as typed state or stream completion according to the SDK contract, while collector cancellation only releases that collector.

Android and iOS apps share checkout rules, but Android uses Room, iOS uses Core Data, and the server owns final pricing. What belongs in commonMain?

I would share deterministic checkout policy and orchestration, while keeping storage engines, UI, and authoritative pricing on their owning platforms. - commonMain contains money types, validation, cart transitions, repository interfaces, and serialization models that both clients must interpret identically. - androidMain and iosMain implement persistence and secure storage using Room and Core Data without leaking either API into shared code. - Server pricing remains a remote contract; duplicating it in commonMain would create two authorities and unsafe offline totals.

A KMP library targets Android, iOS arm64, iOS simulator arm64, and a JVM server across 30 modules. How would you design the source-set hierarchy?

I would use the default hierarchy template and add intermediate source sets only for code with a real shared platform capability. - commonMain holds portable domain code, iosMain owns Apple implementations shared by both iOS targets, and an explicit jvmAndAndroidMain is justified only when Android and server dependencies truly match. - Target-specific source sets remain thin for APIs such as keychain access or Android context, avoiding a custom hierarchy for one-file coincidences. - CI compiles every target and publishes the library from one canonical build so an unused simulator source set cannot silently decay.

A shared authentication module needs secure storage on Android, iOS, and JVM, with at most five expect declarations allowed by review policy. How would you use expect and actual?

I would define one narrow common capability and use expect only for the platform factory that supplies it. - commonMain declares SecureTokenStore with readToken, writeToken, and clear operations plus domain errors, without Keychain, Keystore, or file-system types. - Each actual factory returns a small platform implementation that is tested through the same common contract suite. - Cross-platform policy such as token expiry and refresh remains ordinary common code, preserving the five-declaration limit for genuine platform gaps.

A KMP framework exposes 80 declarations to a Swift team, which requires call sites readable without Kotlin knowledge and API review within two weeks. How would you shape the boundary?

I would publish a small Swift-facing facade instead of exporting the internal Kotlin module graph. - Facade methods use stable names, simple classes, nullable values, and collection shapes that map predictably, while Kotlin-only sealed hierarchies stay behind adapters. - Suspend and Flow APIs are wrapped into the async and observation model agreed with the Swift team, including cancellation and main-thread delivery semantics. - An iOS sample target compiles representative Swift call sites in CI, making generated header changes and source-breaking names visible during the two-week review.

A shared SDK streams 100 updates per second to Swift and must stop within 200 ms when a view disappears. What interop contract would you choose?

I would expose an explicit subscription handle whose cancellation controls the underlying shared Flow collection. - Kotlin owns the collection in a child scope tied to that handle, and Swift receives values on the documented queue rather than relying on an implicit global scope. - The adapter applies a bounded conflated policy if Swift only needs the latest state; lossless records use a separate durable or batched API. - Interop tests cancel from Swift, assert collection stops within 200 ms, and verify the handle releases captured callbacks.

A KMP app ships 600 localized strings, image assets, and legal copy that iOS must update through its native release process. Who should own resources?

I would assign resources by presentation and release ownership rather than force all assets into common code. - Shared domain messages use stable error keys or typed outcomes, while Android and iOS own user-facing wording that must follow native localization and legal workflows. - Truly identical Compose Multiplatform assets can live in shared resources only when both platform teams accept the same packaging and update cadence. - CI validates key parity and missing translations without making commonMain depend on Android Resources or an iOS bundle API.

Kotlin Developer interview questions

100 real questions with model answers and explanations for Senior Kotlin Developer candidates.

See a Kotlin Developer resume example →

Practice with flashcards

Spaced repetition · Hunter Pass

Questions

ownershipcoroutinesviewmodel

I would make each coroutine belong to the narrowest lifecycle that must keep its result alive.

UI rendering work stays in lifecycleScope with repeatOnLifecycle, while screen state production belongs to viewModelScope so rotation does not restart useful work.
Repositories expose suspend functions or cold Flows and do not create hidden application scopes; the caller owns cancellation unless a documented process truly outlives the screen.
The few process-wide jobs use one injected application CoroutineScope with a SupervisorJob, named children, and explicit shutdown in tests.

Why interviewers ask this: The interviewer is testing whether the candidate can turn structured concurrency into enforceable ownership rules for a large Android codebase.

ktorcachingcoroutines

I would keep request work as children of the call scope and reserve an application scope only for explicitly process-owned jobs.

Database calls, downstream HTTP calls, and response assembly inherit request cancellation and its deadline, so disconnected or timed-out calls stop consuming capacity.
Cache refreshers run under an application SupervisorJob because one failed refresh must not cancel request handling or unrelated refreshers.
Shutdown first stops admission, then cancels the application scope and waits a bounded 10 seconds for owned jobs to finish.

Why interviewers ask this: The interviewer is evaluating lifecycle separation, cancellation propagation, and graceful shutdown under server load.

queriesroomhttp

I would place every startup executor under one four-thread process budget, including Room and the HTTP client.

One shared four-thread Executor backs the coroutine dispatcher, Room query and transaction executors, and the HTTP client's Dispatcher; any client that requires a dedicated executor must consume part of the same four-thread budget.
Dispatcher views cap decoding at two concurrent tasks and Room or HTTP startup work at two each, while the shared Executor enforces the global limit when those workloads overlap.
Startup traces and thread-name counts on the target two-core device must show no more than four background threads; limitedParallelism alone would not cap independent Room or HTTP pools.

Why interviewers ask this: The interviewer wants a concrete concurrency budget tied to workload type and device constraints.

kotlincoroutinesjvm

I would reject the 2,000-per-second target on one 8-core container because its CPU demand is three times the physical capacity.

The capacity math is 2,000 × 12 ms = 24 CPU-seconds per wall-clock second, while eight fully occupied cores provide only 8 CPU-seconds.
The workload needs at least three 8-core containers before headroom; I would start with four, which puts nominal CPU utilization near 75% for GC, request parsing, and burst tolerance.
Each container uses core-sized limited parallelism and bounded admission, failing requests that cannot meet 250 ms instead of building an unbounded queue.
Load tests must track queue time, CPU saturation, and deadline failures at 2,000 calculations per second before the four-container rollout is accepted.

Why interviewers ask this: The interviewer is checking whether the candidate treats coroutines as cheap tasks but CPU as a finite resource.

coroutines

I would use a bounded coroutineScope for required work and isolate only the optional provider with supervisorScope semantics.

Required async children inherit the 300 ms deadline, and any required failure cancels siblings because a complete required result is impossible.
The optional provider converts its own failure to an explicit unavailable result without hiding cancellation from the parent.
Each provider receives a smaller timeout budget, such as 220 ms, leaving time to rank and serialize the combined response.

Why interviewers ask this: The interviewer is evaluating precise use of failure propagation, supervision, and deadline budgeting.

kotlincoroutinesapi

I would publish suspending and cold Flow APIs that remain cooperative with caller cancellation and never launch detached work internally.

Long loops call ensureActive or use cancellable suspending primitives, and blocking vendor calls are wrapped in a cancellable adapter only when the vendor supports aborting them.
Cleanup stays in finally with NonCancellable limited to the smallest mandatory close operation, never an entire network retry.
Contract tests cancel each public operation and assert both completion within 100 ms and release of its underlying resource.

Why interviewers ask this: The interviewer is testing whether cancellation is designed as a measurable public API guarantee.

e2ecoroutines

I would pass one monotonic deadline through the call graph and derive each remaining timeout from it.

The orchestration layer allocates explicit sub-budgets, for example 300 ms inventory, 500 ms fraud, and 800 ms payment, while retaining time for local persistence and rendering.
Repositories accept a request context or deadline abstraction rather than each starting a fresh two-second timeout that can multiply total latency.
Timeout is mapped to a typed domain result at the boundary, while CancellationException continues upward unchanged.

Why interviewers ask this: The interviewer is checking deadline composition and correct distinction between timeout, cancellation, and domain failure.

designownershipcoroutines

I would remove feature-owned scope factories and standardize scopes by lifecycle owner rather than by module.

UI modules receive ViewModel or lifecycle scopes from Android owners, request handlers inherit server call scopes, and repositories expose structured APIs without storing arbitrary scopes.
A small platform module provides only named application and test scopes, with ownership, cancellation, and shutdown documented in its API.
A static rule flags GlobalScope and unmanaged CoroutineScope construction outside the platform module during the two-release migration.

Why interviewers ask this: The interviewer is evaluating whether the candidate can make coroutine ownership consistent and enforceable across many modules.

flowapiqueries

I would return a cold Flow because the query is parameterized per caller and has no single repository-owned current value.

Each collection creates work for that account ID, so the API documents whether Room invalidation reruns the query and how cancellation closes the subscription.
A ViewModel may convert it to StateFlow with stateIn and WhileSubscribed for screen sharing, but that lifecycle policy does not belong in the repository.
If duplicate collectors are expensive, the owner shares the flow at the layer that knows the correct scope and replay duration.

Why interviewers ask this: The interviewer is checking whether flow type follows ownership and semantics rather than convenience.

flow

I would expose one immutable StateFlow of complete screen state from the ViewModel.

The ViewModel combines domain flows into a stable sealed UI state and uses stateIn(viewModelScope, WhileSubscribed(5_000), initialState) to survive short collector gaps.
MutableStateFlow remains private, and updates use atomic update so concurrent actions cannot overwrite each other.
Navigation and transient effects are excluded from durable state unless replaying them after rotation is intentionally part of the contract.

Why interviewers ask this: The interviewer is evaluating state ownership, sharing policy, and separation of durable state from effects.

configflow

I would not model a one-consumer navigation command as a broadly shared replaying event stream.

Durable login status belongs in StateFlow, while navigation is derived by the current UI owner from a state transition or delivered through a single-consumer Channel.
If SharedFlow is required for multiple observers, replay is zero and the contract accepts that emissions with no collector are lost.
The design test covers rotation during emission because replaying a command and dropping a command are both product-visible choices.

Why interviewers ask this: The interviewer is checking whether the candidate understands delivery semantics instead of using SharedFlow as a generic event bus.

backpressurememoryflow

I would make loss policy explicit and use a bounded buffer sized by bytes and acceptable delay.

Low-value counters use DROP_OLDEST with aggregation, while audit-class events bypass this stream into durable storage because they cannot share a lossy contract.
The uploader batches up to 200 events or 100 ms and limits concurrent uploads so downstream pressure remains bounded.
Metrics expose dropped events, buffer occupancy, and oldest-event age, allowing the 32 MB cap to be verified under synthetic peak load.

Why interviewers ask this: The interviewer is evaluating whether backpressure includes product semantics, bounded memory, and observable loss.

flowaggregation

I would split the graph by update frequency and recompute only aggregates whose inputs changed.

Stable domain subgraphs produce typed intermediate StateFlows, so a clock tick does not recalculate account totals or permissions.
Expensive mapping runs before combine, uses distinctUntilChanged on meaningful immutable values, and avoids equality checks on mutable collections.
A benchmark drives 1,000 updates through the graph and measures computation and main-thread render time against the 50 ms budget.

Why interviewers ask this: The interviewer is checking whether the candidate can architect a scalable reactive graph rather than merely chain operators.

concurrencycallbacksflow

I would wrap the callback in callbackFlow and place multi-subscriber sharing behind one device-scoped owner.

awaitClose unregisters the exact listener, trySend handles concurrent callbacks safely, and failed sends are counted rather than retried recursively.
The owner applies shareIn with a documented replay and stop timeout so ten collectors do not register ten native listeners.
Device disconnect is represented as typed state or stream completion according to the SDK contract, while collector cancellation only releases that collector.

Why interviewers ask this: The interviewer is evaluating callback adaptation, resource ownership, and sharing semantics under concurrency.

pricingroom

I would share deterministic checkout policy and orchestration, while keeping storage engines, UI, and authoritative pricing on their owning platforms.

commonMain contains money types, validation, cart transitions, repository interfaces, and serialization models that both clients must interpret identically.
androidMain and iosMain implement persistence and secure storage using Room and Core Data without leaking either API into shared code.
Server pricing remains a remote contract; duplicating it in commonMain would create two authorities and unsafe offline totals.

Why interviewers ask this: The interviewer is testing whether KMP boundaries follow domain ownership rather than maximum code sharing.

designjvm

I would use the default hierarchy template and add intermediate source sets only for code with a real shared platform capability.

commonMain holds portable domain code, iosMain owns Apple implementations shared by both iOS targets, and an explicit jvmAndAndroidMain is justified only when Android and server dependencies truly match.
Target-specific source sets remain thin for APIs such as keychain access or Android context, avoiding a custom hierarchy for one-file coincidences.
CI compiles every target and publishes the library from one canonical build so an unused simulator source set cannot silently decay.

Why interviewers ask this: The interviewer is evaluating source-set design, hierarchy restraint, and multi-target build coverage.

authjvm

I would define one narrow common capability and use expect only for the platform factory that supplies it.

commonMain declares SecureTokenStore with readToken, writeToken, and clear operations plus domain errors, without Keychain, Keystore, or file-system types.
Each actual factory returns a small platform implementation that is tested through the same common contract suite.
Cross-platform policy such as token expiry and refresh remains ordinary common code, preserving the five-declaration limit for genuine platform gaps.

Why interviewers ask this: The interviewer is checking whether expect and actual bridge capabilities without spreading platform details through shared code.

kotlin

I would publish a small Swift-facing facade instead of exporting the internal Kotlin module graph.

Facade methods use stable names, simple classes, nullable values, and collection shapes that map predictably, while Kotlin-only sealed hierarchies stay behind adapters.
Suspend and Flow APIs are wrapped into the async and observation model agreed with the Swift team, including cancellation and main-thread delivery semantics.
An iOS sample target compiles representative Swift call sites in CI, making generated header changes and source-breaking names visible during the two-week review.

Why interviewers ask this: The interviewer is evaluating Swift ergonomics, interop stability, and boundary minimization.

I would expose an explicit subscription handle whose cancellation controls the underlying shared Flow collection.

Kotlin owns the collection in a child scope tied to that handle, and Swift receives values on the documented queue rather than relying on an implicit global scope.
The adapter applies a bounded conflated policy if Swift only needs the latest state; lossless records use a separate durable or batched API.
Interop tests cancel from Swift, assert collection stops within 200 ms, and verify the handle releases captured callbacks.

Why interviewers ask this: The interviewer is checking lifecycle, backpressure, and cancellation across the Kotlin and Swift boundary.

concurrency

I would assign resources by presentation and release ownership rather than force all assets into common code.

Shared domain messages use stable error keys or typed outcomes, while Android and iOS own user-facing wording that must follow native localization and legal workflows.
Truly identical Compose Multiplatform assets can live in shared resources only when both platform teams accept the same packaging and update cadence.
CI validates key parity and missing translations without making commonMain depend on Android Resources or an iOS bundle API.

Why interviewers ask this: The interviewer is evaluating native resource ownership and the operational cost of sharing presentation assets.

Locked questions

21
A shared analytics client accepts events from Android and iOS background threads at 5,000 events per minute. How would you design its KMP concurrency model?
concurrencydesign
22
A 25-module KMP product uses Hilt on Android and a native Swift composition root on iOS. How would you handle dependency injection in shared code?
injectiondependenciesoop
23
A Compose Multiplatform app shares 70 percent of UI across Android and desktop, but navigation and file pickers differ. Where would you draw UI and state boundaries?
kmp
24
Android and iOS must share a Compose Multiplatform checkout screen, but each platform requires its native payment sheet and accessibility audit. How would you compose it?
a11ykmp
25
An Android application has grown to 64 Gradle modules, and changing one feature currently recompiles 38 modules. How would you redesign module boundaries?
build
26
Five product teams consume a shared payments module, and its implementation changes weekly while its contract should remain stable for six months. How would you use Gradle api and implementation boundaries?
buildapi
27
A repository has 52 modules maintained by six teams, and Android configuration is copied into every build file. What convention-plugin architecture would you introduce?
config
28
A 70-module Gradle build must support configuration cache and keep configuration under 3 seconds on CI. How would you design and enforce that constraint?
configbuilddesign
29
In a 48-module build, a core-utils module is depended on by 41 modules and changes twice a week. What build-graph redesign would you propose?
30
A KSP processor generates adapters in 30 modules and adds 90 seconds to clean builds. How would you redesign it for incremental processing?
kotlin-symbol-processingconcurrency
31
A generated networking API is consumed by 12 teams and must remain source-compatible for one year. What KSP architecture would you approve?
apikotlin-symbol-processing
32
You are designing a Kotlin configuration DSL used by 20 modules, with nested receivers and a two-year binary-compatibility requirement. What shape would you choose?
designconfigkotlin
33
An order system has 14 states, but only six transitions are legal and three states carry different data. How would you model it in Kotlin?
system-designkotlin
34
Six services currently pass customer, order, and invoice IDs as String, and review found 23 possible mix-up sites. Would you introduce value classes?
classes
35
A data class representing a credit limit must always be nonnegative, but 17 modules use copy to change it. How would you protect the invariant without a flag-day rewrite?
classes
36
A Kotlinx Serialization payload is stored offline for 180 days and read by app versions up to three releases apart. How would you evolve the schema?
schemaserializationkotlin
37
A Kotlin library is called by 2 million lines of Java code, and null-related contracts must be enforced without migrating callers this year. How would you design the API?
fundamentalskotlinapi
38
A team of eight Spring engineers must build a Kotlin service at 12,000 RPS within four months, using existing Spring Security and transaction libraries. Would you choose Ktor or Spring Boot?
transactionskotlinktor
39
A Kotlin service must handle 6,000 concurrent requests, call three downstreams, and keep p99 below 400 ms with 1 GB RAM. How would you design concurrency?
concurrencykotlindesign
40
A mobile aggregation service calls four partners with 99.5 percent availability each but must offer 99.9 percent availability and a 500 ms SLA. What resilience architecture would you choose?
fan-outaggregation
41
A Spring Kotlin service performs 300 transactions per second, and each request needs two queries plus one remote call. Where would you place coroutine and transaction boundaries?
transactionsquerieskotlin
42
An order service must commit an order and publish its event exactly once from the business perspective at 1,500 writes per second. What persistence design would you use?
design
43
A KMP domain library has 20 implementations across Android, iOS, and JVM, and releases weekly. What testing architecture would you establish?
testingjvm
44
A coroutine workflow includes a 30 second debounce, three retries, and a five-minute refresh, but its test suite must finish under 10 seconds. How would you test it?
debouncetestingcoroutines
45
An Android app with 8 million users must reduce cold startup from 1.8 seconds to under 1.2 seconds on a defined mid-range device. How would you use Baseline Profiles?
46
A 90-module Android app must shrink its download by 18 MB while preserving reflection-based serialization and JNI entry points. How would you design the R8 strategy?
designserializationcode-shrinking
47
A Compose app initializes 22 SDKs before its first frame and has a 900 ms cold-start budget. What startup architecture would you propose?
architecture
48
A 500,000-line Java Android app must reach 60 percent Kotlin in 12 months while shipping every two weeks. How would you design the migration?
migrationsdatabase-migrationsdesign
49
An Android-only product wants to share 50 percent of business logic with iOS in nine months without delaying six scheduled releases. How would you stage the KMP migration?
migrationsdatabase-migrations
50
In a review of a 45-module Kotlin platform, two mid-level engineers propose a global CoroutineScope and one shared events bus to simplify APIs before a six-month rollout. How would you mentor the design?
kotlincoroutinesdesign
51
Two hours before an Android release, a soak test shows 18,000 active Jobs after opening and closing the same screen 300 times, and memory has risen by 420 MB. What do you do?
memoryperformance-testing
52
A Ktor service grows from 600 to 9,000 live coroutines over a 40-minute load test even after traffic returns to zero, and a launch is due tomorrow. How would you handle it?
coroutinesload-testingktor
53
After a Friday deploy, Android ANR rate rises from 0.2% to 2.6% on low-end devices, and traces show DefaultDispatcher workers busy with image hashing. Marketing starts in three hours. What is your response?
deployment
54
A Ktor endpoint's p99 jumps from 180 ms to 4.8 s at 1,200 requests per second after a coroutine refactor, while CPU is only 35%. You have 90 minutes before peak traffic. What do you inspect and change?
refactoringendpointscoroutines
55
Search requests continue for 12 seconds after users type a new query, producing 4.2 million wasted calls per day and a vendor quota alert due in six hours. How would you fix cancellation propagation?
procurementqueriesresilience
56
During a Ktor shutdown, 7% of requests run past the 30-second grace period because a helper catches Exception and retries. A cluster upgrade starts tonight. What do you do?
ktorerror-handling
57
A dependency returns 503 for 90 seconds and 24 Kotlin service instances amplify 8,000 requests per second into 110,000 retries per second. The dependency owner asks for relief within ten minutes. What is your plan?
dependencieskotlin
58
A vehicle-tracking Flow receives 6,000 GPS samples per second but map matching processes 600, and process memory grows by 780 MB in 12 minutes before OOM. A field trial begins in two hours. How do you respond?
concurrencyflowmemory
59
After rotating an Android device during checkout, 3.8% of users never see the payment result because a SharedFlow event is emitted while no collector is active. A release is due today. What would you change?
flow
60
A pricing screen stays stale for 11% of sessions after an update because StateFlow does not emit when a mutable data class instance is changed in place. A campaign starts tomorrow. How do you diagnose and fix it?
flowclassessessions
61
A Compose feed recomposes each of 500 rows on every 1 Hz timer tick, raising CPU from 18% to 62% and draining 9% battery per hour. You have one day before launch. What do you do?
coroutines
62
Production reports 1,700 daily crashes with a Compose snapshot exception after background sync updates a mutableStateListOf from Dispatchers.IO. A hotfix is expected in four hours. How do you proceed?
error-handlingcoroutine-dispatcherssnapshot
63
Android cold start regresses from 780 ms to 1.9 s after a package refactor, although a Baseline Profile file still exists, and release is in 48 hours. What do you check?
refactoring
64
The debug build passes, but a 10% release rollout shows 6.4% startup crashes after enabling full-mode R8 for a Kotlin serialization module. You have 30 minutes before rollout automation expands. What do you do?
serializationkotlincode-shrinking
65
A Spring Boot Kotlin service's heap climbs from 3 GB to 11 GB and GC pauses reach 1.4 seconds after traffic doubles to 6,000 requests per second. The next peak is in 45 minutes. What is your response?
data-structureskotlin
66
A batch service misses its two-hour SLA after its thread pool is increased from 32 to 256; throughput falls 40% and context switches triple. What decision do you make before tonight's run?
batchthroughputconcurrency
67
A Ktor service exhausts its 50-connection Hikari pool at 900 requests per second, p99 reaches 8 seconds, and database CPU remains 25%. An SLA review is in three hours. How do you investigate?
databasektor
68
A Spring WebFlux endpoint written in Kotlin Coroutines drops from 4,000 to 700 requests per second after adding a legacy JDBC lookup, and release is tomorrow morning. What would you do?
kotlincoroutinesendpoints
69
A code review due in 40 minutes wraps a suspend fraud API call inside a database transaction that holds 30 row locks; staging already shows 12-second lock waits. Would you approve it?
databasetransactionsapi
70
An Android sync job uses Room withTransaction around a suspend upload, and 8% of users see database locked errors during a 20-second network slowdown. A hotfix is due tonight. What do you change?
databaseroomcoroutines
71
After migrating a Java SDK call to Kotlin, a platform-type NPE affects 0.7% of 14 million daily requests because a supposedly nonnull getter sometimes returns null. A patch is needed in two hours. What do you do?
fundamentalskotlin
72
A backend adds a new sealed event subtype at noon, and older Android clients crash while deserializing 3% of messages; an app update cannot reach users for days. How do you respond?
sealed-classes
73
A Kotlin serialization upgrade changes a polymorphic discriminator from type to kind, causing 18% of stored offline records to fail after rollout. You have four hours before the next region upgrades. What is your migration plan?
migrationsdatabase-migrationsserialization
74
A KMP iOS app crashes 2,300 times per day after a shared image wrapper closes a native buffer while Swift still renders it. A hotfix is due in six hours. How do you handle ownership?
soft-skillsownership
75
A KMP callback updates SwiftUI from a background coroutine and causes 900 daily main-thread checker failures after traffic doubles. The App Store submission is tomorrow. What do you change?
concurrencycallbackscoroutines
76
Android compiles after a shared expect API gains a timeout parameter, but the iOS actual silently keeps the old 30-second behavior and misses a 5-second SLA. Release branches cut in two days. What do you do?
resilienceapi
77
A shared SDK release turns a Swift-friendly completion API into a generated name with nested KotlinResult wrappers, breaking 11 iOS call sites on the release candidate day. What is your decision?
kotlin
78
A 180-module Kotlin build rises from 12 to 28 minutes after three feature teams merge on Monday, and a release branch must be ready by Wednesday. How do you cut the time safely?
kotlin
79
Gradle configuration cache cuts configuration from 95 to 18 seconds, but 37 of 220 CI jobs publish stale endpoints because a convention plugin task reads DEPLOY_REGION in its action without declaring it as an input. You have one sprint to make builds correct. What do you do?
deploymentconfigbuild
80
To avoid a Gradle project cycle while splitting payments, a team moves payment events into shared-core, which domain, analytics, and UI all consume; one event edit now adds 70 seconds to incremental builds three days before release. How would you resolve the review?
build
81
After upgrading a KSP processor, incremental CI builds increase from 6 to 19 minutes and generated sources appear for unchanged modules. A patch train leaves tomorrow. What do you inspect?
kotlin-symbol-processingconcurrency
82
A KSP-generated mapper compiles in the producer module but consumers throw NoSuchMethodError after only a default parameter was added; 14 services deploy tonight. How do you respond?
deploymentkotlin-symbol-processing
83
A Kotlin SDK minor release removes a method's @JvmOverloads-generated overloads, breaking 26 Java consumers two hours before publication. What do you decide?
kotlin
84
A team must migrate 420,000 lines of Java to Kotlin while delivering two revenue features per month, and the first bulk conversion raises defects by 35%. How would you reset the migration?
migrationsdatabase-migrationsdefects
85
An Android team has 12 weeks to share checkout with iOS through KMP while both apps must ship weekly, and the first shared UI spike delays Android by nine days. What would you change?
86
A Room migration from version 17 to 18 renames a column, but 0.4% of upgraded users lose saved drafts because destructive fallback is enabled. A hotfix must ship today. What do you do?
migrationsschemaroom
87
During a 30-minute outage, 60,000 devices edit the same class of records offline; reconnect produces 7,500 silent overwrites from last-write-wins. Support needs a mitigation in one day. What is your plan?
88
A coroutine test fails about 1 in 80 CI runs because it uses delay(500) and real Dispatchers.IO, and release confidence is needed by noon. How do you make it deterministic?
coroutinescoroutine-dispatchers
89
A suite passes alone but fails 6% when parallelized because one test replaces Dispatchers.Main and does not restore it after cancellation. CI must stay parallel to meet a 15-minute budget. What do you change?
resiliencecoroutine-dispatchers
90
A fan-out request launches 40 coroutines, but traces show only the parent span, making a 2.5-second p99 regression impossible to attribute before an incident review tomorrow. What observability would you add?
coroutinesobservabilityincidents
91
After moving work to withContext, 22% of error logs lose request_id and cannot be joined to traces during a live incident. You need usable logs within 30 minutes. What do you do?
incidents
92
Thirty minutes before code freeze, you review a fix that uses GlobalScope.launch for order confirmation so the HTTP response can return 200 ms faster. The operation affects 80,000 orders per day. Do you approve it?
httpcoroutines
93
A pull request due today adds an unlimited Channel to absorb webhook spikes; a staging burst of 300,000 events grows heap by 2.2 GB but loses none. What review decision do you make?
data-structuresconcurrencywebhooks
94
A mid-level engineer's first coroutine feature leaks 6,000 Jobs overnight because they created a screen scope manually; the customer demo is in two days. How do you mentor while fixing the incident?
mentoringincidentscoroutines
95
A junior engineer tries to fix a Flow memory incident by changing a buffer from 1,000 to 100,000, and the release deadline is tomorrow. How would you guide the decision?
incidentsestimationmemory
96
A payment timeout cancels the parent coroutine, but a detached retry completes later and charges 41 customers twice before an alert fires. Finance needs containment in 20 minutes. What do you do?
resiliencealertingcoroutines
97
A Channel-based actor processing inventory commands reaches a backlog of 1.8 million, with oldest message age at 27 minutes, two hours before a flash sale. What is your decision?
concurrencybacklog
98
A Compose Multiplatform iOS screen falls from 60 to 24 FPS when a 10,000-row dataset arrives, while Android remains at 55 FPS, and beta starts in five days. How do you investigate?
kmp
99
Upgrading from Kotlin 1.9 to 2.x and K2 cuts compilation by 22%, but two compiler plugins generate different nullability metadata and 160 tests fail; the upgrade window closes Friday. What do you decide?
kotlin
100
A Friday review proposes sharing an Android-only cryptography implementation through KMP in one week, but the iOS actual uses a different key format and fails 4% of migration fixtures. A partner launch is next Monday. What do you do?
migrationsdatabase-migrationsfixtures

Questions

1A banking Android app has 35 screens, 12 long-lived repositories, and a 150 ms navigation target. How would you define coroutine ownership across activities, ViewModels, and repositories?

2A Ktor service handles 8,000 requests per second with a 200 ms p99 SLA and also refreshes caches every minute. How would you separate request and application coroutine scopes?

3An Android client performs image decoding, Room queries, and three HTTP calls during startup, but may use at most four background threads on low-end devices. How would you allocate dispatcher budgets?

4A Kotlin/JVM pricing service receives 2,000 calculations per second, each taking 12 ms of CPU, on an 8-core container with a 250 ms p99 target. How would you design coroutine parallelism?

5A search request fans out to six providers and must return within 300 ms even if one optional provider fails. How would you structure the coroutines?

6A shared Kotlin SDK is used by 18 app modules, and every operation must cancel within 100 ms after its caller leaves a screen. What coroutine API contract would you publish?

7A mobile checkout has a 2 second end-to-end SLA across inventory, fraud, and payment calls. How would you propagate time budgets through coroutine layers?

8Forty feature modules currently expose their own CoroutineScope factories, and architecture review requires one ownership model within two releases. What design would you approve?

9A repository serves 15 screens, and each collector needs a fresh query filtered by its own account ID. Should its public API return Flow, StateFlow, or SharedFlow?

10A Compose screen has 11 independent data sources and must restore its latest renderable state immediately after rotation. How would you expose StateFlow?

11Three collectors observe a login stream, but a navigation command must be consumed once and must not replay after a 500 ms configuration change. Would you use SharedFlow?

12A telemetry Flow can receive 20,000 events per second, while its uploader sustains 5,000, and memory is capped at 32 MB. What backpressure contract would you define?

13A dashboard combines 25 StateFlows, and any update must render within 50 ms without recomputing all expensive aggregates. How would you shape the flow graph?

14A Bluetooth SDK emits callbacks from four threads and allows only one active listener per device. How would you expose it as Flow to 10 app modules?

15Android and iOS apps share checkout rules, but Android uses Room, iOS uses Core Data, and the server owns final pricing. What belongs in commonMain?

16A KMP library targets Android, iOS arm64, iOS simulator arm64, and a JVM server across 30 modules. How would you design the source-set hierarchy?

17A shared authentication module needs secure storage on Android, iOS, and JVM, with at most five expect declarations allowed by review policy. How would you use expect and actual?

18A KMP framework exposes 80 declarations to a Swift team, which requires call sites readable without Kotlin knowledge and API review within two weeks. How would you shape the boundary?

19A shared SDK streams 100 updates per second to Swift and must stop within 200 ms when a view disappears. What interop contract would you choose?

20A KMP app ships 600 localized strings, image assets, and legal copy that iOS must update through its native release process. Who should own resources?

Locked questions