Practice Prompts

Given a Flow<String> of search-box text, produce a stream that only emits after the user pauses typing for 300ms and skips duplicate consecutive queries. Then explain why flatMapLatest is the right way to run the actual search.

Write a generic suspend fun <T> retry(times, initialDelay, maxDelay, factor, block) that retries a suspend block on failure with exponential backoff, gives up after times attempts, and never swallows cancellation.

Implement a fixed-capacity LRU cache with O(1) get/put. Make it safe for concurrent coroutine access. What evicts, and how do you keep it O(1)?

Model a counter screen with MVI: an immutable UiState, a sealed Intent, and a pure reduce(state, intent): state. Show why purity and immutability help testing.

Write a ViewModel exposing a counter as StateFlow<Int> that survives both rotation and process death, with increment/decrement. Which APIs guarantee each?

Implement a repository where the UI observes Room (source of truth) and a refresh() updates it from the network. Why does this give stale-while-revalidate for free?

Parse an API response into a typed model with kotlinx.serialization, tolerating unknown/extra fields, and return a Result rather than throwing into the UI. Why validate at the boundary?

You animate an element's horizontal position from a fast-changing state. Show the version that recomposes every frame and the version that doesn't, and explain why.

Design 1:1 chat: real-time delivery, message history, offline send, and read receipts. Cover transport, the data layer, ordering, and trade-offs.

Users pick photos that must upload reliably even if the app is killed or offline. Design the queue, retries, progress, and constraints.

Design client-side feature flags and A/B experiments: how flags are fetched, cached, evaluated, and kept consistent — plus kill switches and analytics. Trade-offs?

Design a client analytics pipeline: capture events, batch them, survive offline and process death, and avoid blocking the UI or draining battery. Trade-offs?

You must cap outgoing requests to N per second across the app, coroutine-safe. Sketch a token-bucket and how it integrates with OkHttp/coroutines. Trade-offs vs server-side limiting?

Design a sealed Result<out T> type for success/error, and a safeApiCall helper that runs a suspend block on the IO dispatcher, returns Result.Success on success and Result.Error on failure — while correctly not swallowing coroutine cancellation.

In a ViewModel, expose a StateFlow<SearchUiState> driven by a query. Debounce input, cancel the in-flight search when the query changes, handle loading/empty/error, and survive rotation without re-running on every collector.

Design the architecture for a news feed that must load instantly, work offline, paginate infinitely, and stay fresh. Cover layers, the source of truth, pagination, sync, and the trade-offs.

You want a 'summarize this note' feature that runs on-device for privacy. Design it: model choice, device support, threading/streaming, fallback, and the privacy story.