Modern applications constantly deal with changing data.

For example:

A user types into a search box.
A network request changes from loading to success.
A database updates.
A user logs in or logs out.
A timer produces new values.
A device’s connectivity changes.
A user preference changes.
A real-time chat receives a new message.

Instead of repeatedly asking whether something has changed, Kotlin provides a powerful asynchronous data stream API called Kotlin Flow.

Kotlin Flow allows you to represent a stream of values that can be collected asynchronously.

In this complete beginner’s guide, you’ll learn what Kotlin Flow is, how it works, the difference between Flow, StateFlow, and SharedFlow, how to use operators such as map, filter, combine, and debounce, how Flow works with coroutines, and how to use it in Android and Kotlin Multiplatform applications.

What Is Kotlin Flow?

Kotlin Flow is an API for handling asynchronous streams of data.

A normal function might return one value:

fun getUser(): User

But a Flow can continuously produce values:

fun observeUser(): Flow<User>

Conceptually:

Value 1
   ↓
Value 2
   ↓
Value 3
   ↓
Value 4
   ↓
...

The important idea is that Flow represents a stream of values over time.

For example:

fun numbers(): Flow<Int> = flow {
    emit(1)
    emit(2)
    emit(3)
}

The Flow can emit multiple values.

Why Do We Need Kotlin Flow?

Traditional synchronous code works well when you need a single result.

For example:

val user = getUser()

But many applications have continuously changing data.

Consider a chat application:

Message 1
Message 2
Message 3
Message 4
...

You don’t want to repeatedly call:

getMessages()

Instead, you can observe a stream:

observeMessages(): Flow<List<Message>>

The application receives updates whenever the data changes.

Kotlin Flow and Coroutines

Flow is built on top of Kotlin’s coroutine ecosystem.

A Flow can run asynchronously without blocking the main thread.

For example:

fun getNumbers(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(1000)
        emit(i)
    }
}

The Flow emits:

1
↓
2
↓
3
↓
4
↓
5

with a delay between values.

Flow Is Cold by Default

One of the most important concepts to understand is that a normal Kotlin Flow is cold.

A cold Flow doesn’t start producing values until someone collects it.

Example:

val numbers = flow {
    println("Flow started")
    emit(1)
    emit(2)
}

Nothing happens just because the Flow was created.

It starts when you collect it:

numbers.collect { value ->
    println(value)
}

Output:

Flow started
1
2

What Does “Cold Flow” Mean?

Think of a cold Flow like a recipe.

Creating the recipe doesn’t cook the food.

You have to execute the recipe.

Similarly:

Create Flow
    ↓
Nothing happens yet
    ↓
collect()
    ↓
Flow starts

Creating a Flow

The most common way to create a Flow is using the flow {} builder.

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow

fun numbers(): Flow<Int> = flow {
    emit(1)
    emit(2)
    emit(3)
}

The emit() function sends values into the Flow.

What Is `emit()`?

emit() sends a value from the Flow producer to the collector.

Example:

flow {
    emit("Hello")
    emit("Kotlin")
    emit("Flow")
}

The Flow produces:

Hello
Kotlin
Flow

Collecting a Flow

Creating a Flow isn’t enough.

You need to collect it.

numbers().collect { value ->
    println(value)
}

Output:

1
2
3

collect() is a terminal operator.

Flow Producer and Collector

You can think about Flow as a pipeline:

Producer
   ↓
Flow
   ↓
Collector

For example:

API / Database
      ↓
    Flow
      ↓
 Repository
      ↓
 ViewModel
      ↓
     UI

Flow Example With a Timer

Here’s a simple example:

fun timer(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(1000)
        emit(i)
    }
}

Collect it:

timer().collect { seconds ->
    println(seconds)
}

Output:

Flow Operators

Flow provides many operators for transforming and controlling streams.

Some of the most commonly used operators are:

map
filter
take
onEach
transform
combine
zip
debounce
distinctUntilChanged
catch
retry
flowOn

Let’s understand them one by one.

Kotlin Flow `map`

map transforms each emitted value.

Example:

flowOf(1, 2, 3)
    .map { it * 2 }

The output becomes:

2
4
6

Conceptually:

1 → 2
2 → 4
3 → 6

Kotlin Flow `filter`

filter keeps only values that satisfy a condition.

flowOf(1, 2, 3, 4, 5)
    .filter { it % 2 == 0 }

Output:

2
4

Kotlin Flow `take`

take limits the number of values collected.

flowOf(1, 2, 3, 4, 5)
    .take(3)

Output:

1
2
3

Kotlin Flow `onEach`

onEach allows you to perform an action for each value without changing the value itself.

flowOf(1, 2, 3)
    .onEach {
        println("Received: $it")
    }

It’s useful for logging or side effects.

Kotlin Flow `transform`

transform gives you more control over what each input value produces.

Example:

flowOf(1, 2, 3)
    .transform { value ->
        emit(value)
        emit(value * 10)
    }

This can produce:

Kotlin Flow `debounce`

debounce is extremely useful for search functionality.

Imagine a user types:

K
Ko
Kot
Kotl
Kotlin

Without debounce, you could potentially trigger multiple API requests.

With:

debounce(300)

the Flow waits until the user stops emitting values for the specified period.

Conceptually:

K
 ↓
Ko
 ↓
Kot
 ↓
Kotl
 ↓
Kotlin
 ↓
300ms pause
 ↓
API Request

This can significantly reduce unnecessary work.

Search Example With Debounce

searchQuery
    .debounce(300)
    .filter { it.length >= 2 }
    .distinctUntilChanged()
    .collectLatest { query ->
        search(query)
    }

This is a common pattern for search screens.

Kotlin Flow `distinctUntilChanged`

This operator prevents consecutive duplicate values from being emitted downstream.

Example:

dark
dark
dark
light
light

After:

distinctUntilChanged()

the stream becomes:

dark
light

This is useful for avoiding unnecessary UI updates.

Kotlin Flow `combine`

combine combines the latest values from multiple Flows.

Suppose you have:

val firstName: Flow<String>
val lastName: Flow<String>

You can combine them:

firstName.combine(lastName) { first, last ->
    "$first $last"
}

Conceptually:

First Name ───┐
              ├──→ Full Name
Last Name ────┘

Practical `combine` Example

Suppose your screen has:

Search Query
Selected Category

You can combine both:

combine(
    searchQuery,
    selectedCategory
) { query, category ->
    SearchParams(
        query = query,
        category = category
    )
}

Now your search logic reacts whenever either value changes.

Kotlin Flow `zip`

zip pairs values from two Flows.

For example:

flowOf(1, 2, 3)
    .zip(flowOf("A", "B", "C")) { number, letter ->
        "$number-$letter"
    }

Result:

1-A
2-B
3-C

A simple way to remember the difference:

combine
→ Uses latest values

zip
→ Pairs emissions

`combine` vs `zip`

Feature	`combine`	`zip`
Combines multiple flows	Yes	Yes
Uses latest values	Yes	No
Pairs emissions	No	Yes
Useful for UI state	Very useful	Sometimes
Useful for synchronized streams	Sometimes	Yes

`collectLatest`

collectLatest is useful when only the newest value matters.

For example:

searchQuery.collectLatest { query ->
    search(query)
}

If a new query arrives while the previous search() operation is still running, the previous collector block can be cancelled and the latest value handled.

This is especially useful for:

Search
Autocomplete
Live filtering
Rapid user input

`collect` vs `collectLatest`

`collect`

Processes every emission.

A
↓
Process A
↓
B
↓
Process B

`collectLatest`

Prioritizes the newest emission.

A
↓
Processing A
↓
B arrives
↓
Cancel A
↓
Process B

Flow Error Handling

Flows can throw exceptions.

For example:

flow {
    emit(loadUser())
}

If loadUser() fails, the Flow can throw an exception.

You can handle it using catch.

loadUserFlow()
    .catch { error ->
        println(error.message)
    }
    .collect { user ->
        println(user)
    }

`catch` Operator

A typical pattern is:

flow
    .catch { error ->
        // Handle error
    }
    .collect {
        // Handle data
    }

For example:

flow {
    emit("Loading")
    throw Exception("Network error")
}
.catch {
    emit("Error")
}

The collector can receive:

Loading
Error

Flow `retry`

If an operation may temporarily fail, you can use retry.

Example:

apiFlow
    .retry(3)
    .collect()

This can retry the upstream Flow when an exception occurs.

However, not every error should be retried.

For example:

Network timeout
→ May be retryable

Invalid credentials
→ Usually not retryable

`retryWhen`

For more control, use:

retryWhen { cause, attempt ->
    attempt < 3
}

You can inspect:

Exception
Retry attempt

and decide whether to retry.

`flowOn`

flowOn changes the coroutine context used for upstream Flow operations.

Example:

flow {
    emit(loadLargeData())
}
.flowOn(Dispatchers.IO)

Conceptually:

Database / Network Work
        ↓
   IO Dispatcher
        ↓
      Flow
        ↓
     Collector

The exact dispatcher strategy depends on the application and platform.

Flow Context

A useful concept is that Flow collection and upstream execution are separate concerns.

For example:

flow {
    emit(loadData())
}
.flowOn(Dispatchers.IO)
.collect {
    updateUi(it)
}

The expensive upstream operation can run on an appropriate dispatcher while the collector handles the result in its own coroutine context.

StateFlow

StateFlow is one of the most important Flow types for Android and modern Kotlin applications.

Unlike a normal cold Flow, StateFlow represents a state that has a current value.

Example:

val state = MutableStateFlow(0)

It always has a value.

Current State = 0

You can update it:

state.value = 1

Now:

Current State = 1

StateFlow Example

private val _count =
    MutableStateFlow(0)

val count =
    _count.asStateFlow()

Update:

_count.value++

Collect:

count.collect { value ->
    println(value)
}

MutableStateFlow vs StateFlow

Use:

MutableStateFlow

when you need to change the value.

Expose:

StateFlow

to consumers.

Example:

private val _uiState =
    MutableStateFlow(UiState())

val uiState =
    _uiState.asStateFlow()

This protects the state from being modified externally.

Why Use StateFlow?

StateFlow is excellent for UI state.

For example:

data class UiState(
    val isLoading: Boolean = false,
    val name: String = "",
    val error: String? = null
)

ViewModel:

private val _uiState =
    MutableStateFlow(UiState())

val uiState =
    _uiState.asStateFlow()

Update:

_uiState.value =
    _uiState.value.copy(
        isLoading = true
    )

The UI observes the state and updates automatically.

StateFlow for Login Screens

A login screen could have:

Loading
Success
Error

For example:

data class LoginUiState(
    val isLoading: Boolean = false,
    val isLoggedIn: Boolean = false,
    val error: String? = null
)

The ViewModel updates the StateFlow.

ViewModel
    ↓
StateFlow
    ↓
Login UI

SharedFlow

SharedFlow is another important Flow type.

It is useful for broadcasting events to multiple collectors.

Examples:

Navigation events
Toast messages
Snackbar events
One-time UI events
Analytics events

Conceptually:

             SharedFlow
             /        \
            ↓          ↓
         Screen A   Screen B

StateFlow vs SharedFlow

Feature	StateFlow	SharedFlow
Represents state	Yes	Not specifically
Requires initial value	Yes	No
Holds current value	Yes	Configurable replay
Multiple collectors	Yes	Yes
UI state	Excellent	Sometimes
Events	Usually not ideal	Excellent

A simple rule:

StateFlow
→ What is the current state?

SharedFlow
→ What event happened?

SharedFlow Example

private val _events =
    MutableSharedFlow<UiEvent>()

val events =
    _events.asSharedFlow()

Emit an event:

_events.emit(
    UiEvent.ShowMessage(
        "Login successful"
    )
)

The UI can collect it.

StateFlow and SharedFlow in a ViewModel

A typical ViewModel may have:

private val _uiState =
    MutableStateFlow(UiState())

val uiState =
    _uiState.asStateFlow()

private val _events =
    MutableSharedFlow<UiEvent>()

val events =
    _events.asSharedFlow()

Then:

StateFlow
→ Screen state

SharedFlow
→ One-time events

This separation makes UI architecture easier to understand.

Flow and Room/Database

Flow works particularly well with databases.

For example, a database query can expose:

Flow<List<User>>

The architecture becomes:

Database
   ↓
Flow
   ↓
Repository
   ↓
ViewModel
   ↓
StateFlow
   ↓
UI

Whenever the database changes, the UI can receive updated data.

Flow With Network APIs

Flow can also represent a stream of network-related states.

For example:

sealed interface Resource<out T> {

    data object Loading : Resource<Nothing>

    data class Success<T>(
        val data: T
    ) : Resource<T>

    data class Error(
        val message: String
    ) : Resource<Nothing>
}

You can expose:

Flow<Resource<List<Product>>>

This allows the UI to observe:

Loading
   ↓
Success

or:

Loading
   ↓
Error

Flow in Repository Architecture

A modern architecture might look like:

UI
 ↓
ViewModel
 ↓
Use Case
 ↓
Repository
 ↓
 ┌───────────────┐
 │               │
 ↓               ↓
Database       Network
 │               │
 └───────┬───────┘
         ↓
       Flow

The repository can expose reactive data to the rest of the application.

Flow With Kotlin Multiplatform

Flow is particularly useful in Kotlin Multiplatform applications.

You can use Flow in shared code for:

API state
Database observations
Authentication state
User settings
Network status
Business logic
Timers
Application state

For example:

class UserRepository {

    fun observeUser(): Flow<User?> {
        // Shared KMP implementation
    }
}

Both Android and iOS application layers can consume the shared state using appropriate platform integration.

Flow in KMP Architecture

A KMP application might look like:

                 Shared KMP
                     |
              Repository Layer
                     |
                   Flow
                     |
             ViewModel / State
                /         \
               /           \
          Android           iOS
             UI              UI

This lets your business logic remain shared.

Flow and `suspend` Functions

A suspend function normally returns one result.

suspend fun getUser(): User

A Flow can emit multiple results over time:

fun observeUser(): Flow<User>

Think of it as:

suspend
→ One asynchronous result

Flow
→ Multiple asynchronous results

Flow vs Suspend Function

Feature	`suspend`	`Flow`
Returns one result	Yes	Can emit many
Asynchronous	Yes	Yes
Continuous updates	No	Yes
Database observation	Limited	Excellent
API request	Excellent	Useful for streams/state
UI state	Sometimes	Excellent

Flow and LiveData

Android developers may be familiar with LiveData.

Flow is more general-purpose and belongs to Kotlin’s coroutine ecosystem.

A simplified comparison:

Feature	Flow	LiveData
Kotlin-first	Yes	Android-specific
Coroutines	Excellent	Supported
KMP	Yes	No
Operators	Many	More limited
Android lifecycle	Requires lifecycle-aware collection	Built in
Shared business logic	Excellent	Android-specific

For shared KMP business logic, Flow is generally much more suitable.

Flow and Compose

With Jetpack Compose, StateFlow can be collected as UI state.

For example:

val uiState by viewModel
    .uiState
    .collectAsStateWithLifecycle()

This allows Compose to react to state changes.

Conceptually:

StateFlow
   ↓
Compose
   ↓
Recomposition

Using lifecycle-aware collection is generally preferred for Android UI when available.

Flow Cancellation

Flow works with coroutine cancellation.

For example:

viewModelScope.launch {
    flow.collect {
        // Handle data
    }
}

When the coroutine scope is cancelled, collection is cancelled.

This is important for preventing unnecessary work and avoiding leaks.

Flow and Lifecycle

In Android applications, you generally don’t want to collect UI-related Flows forever.

Use lifecycle-aware collection mechanisms where appropriate.

For example, with Compose:

collectAsStateWithLifecycle()

With Views:

repeatOnLifecycle(...)

This helps ensure collection occurs only when the UI is in an appropriate lifecycle state.

Flow Exception Handling

Remember that exception handling depends on where the exception occurs.

A common pattern is:

repository.getUsers()
    .catch { error ->
        // Handle upstream error
    }
    .collect { users ->
        // Handle users
    }

However, exceptions thrown inside the collector itself aren’t automatically handled by an upstream catch in the same way.

For broader coroutine-level handling, use normal try/catch around the collection when appropriate.

Flow `launchIn`

Instead of:

scope.launch {
    flow.collect {
        // Handle value
    }
}

you can use:

flow
    .onEach {
        // Handle value
    }
    .launchIn(scope)

launchIn starts collection in the supplied coroutine scope.

Flow Example: Search

Here’s a realistic search architecture:

val searchResults =
    searchQuery
        .debounce(300)
        .filter { it.length >= 2 }
        .distinctUntilChanged()
        .flatMapLatest { query ->
            repository.search(query)
        }

This pattern is extremely useful.

Why `flatMapLatest`?

Suppose the user searches:

Flutter

and then quickly types:

Flutter Course

You don’t want an old request to overwrite the new result.

flatMapLatest switches to the newest Flow and cancels the previous inner Flow when a new value arrives.

Conceptually:

Query A
 ↓
Request A
 ↓
Query B
 ↓
Cancel A
 ↓
Request B
 ↓
Result B

Flow Search Pipeline

A complete search pipeline can look like:

User Types
    ↓
searchQuery
    ↓
debounce
    ↓
filter
    ↓
distinctUntilChanged
    ↓
flatMapLatest
    ↓
API
    ↓
Search Results
    ↓
UI

This is one of the most useful real-world Flow patterns.

Flow `mapLatest`

mapLatest is useful when transforming values involves suspend work and only the newest value matters.

Example:

searchQuery
    .mapLatest { query ->
        repository.search(query)
    }

If a new query arrives, the previous transformation can be cancelled.

`mapLatest` vs `flatMapLatest`

A simple way to remember:

mapLatest
→ Transform each value using a suspend block.

flatMapLatest
→ Transform each value into another Flow.

For API methods returning Flow, flatMapLatest is often appropriate.

Flow Buffering

Flow normally processes values according to its coroutine suspension behavior.

Sometimes the producer and consumer have different speeds.

The buffer() operator can allow upstream production and downstream processing to proceed more independently.

Example:

flow
    .buffer()
    .collect {
        process(it)
    }

Buffering should be used intentionally because it can affect memory usage and ordering/throughput characteristics.

Flow `conflate`

conflate() can be useful when intermediate values aren’t important and only the latest available value matters.

For example, if a producer emits:

while the consumer is slow, conflation can avoid processing every intermediate value.

This can be useful for rapidly changing state where the latest value matters more than every historical value.

Hot vs Cold Flow

This is an important concept.

Cold Flow

Starts when collected.

Examples:

flow {}

Hot Flow

Exists independently of individual collectors.

Examples:

StateFlow
SharedFlow

Conceptually:

Cold Flow
Create
 ↓
Collect
 ↓
Starts

Hot Flow
Already active/stateful
 ↓
Collectors subscribe

StateFlow as Hot State

StateFlow always has a current value.

For example:

val state =
    MutableStateFlow("Loading")

A new collector can immediately receive the current state.

Current value:
Loading

Then:

Success

New collectors can receive the latest state according to StateFlow semantics.

SharedFlow Replay

SharedFlow can optionally replay previous emissions to new subscribers.

For example:

MutableSharedFlow<String>(
    replay = 1
)

This means the latest emitted value can be replayed to a new collector.

Be careful with replay for one-time events because incorrect configuration can cause an event to be delivered again when a new collector subscribes.

Flow Best Practices

1. Expose Read-Only Flows

Prefer:

private val _state =
    MutableStateFlow(...)

val state =
    _state.asStateFlow()

instead of exposing a mutable StateFlow.

2. Use StateFlow for State

If the UI needs to know:

Current loading state
Current user
Current selected item

StateFlow is often a good choice.

3. Use SharedFlow for Events

For events such as:

Navigate
Show Snackbar
Show Message

SharedFlow is often more appropriate.

4. Use `debounce` for Search

Avoid sending an API request for every keystroke.

5. Use `distinctUntilChanged`

Avoid processing the same consecutive value repeatedly.

6. Use `flatMapLatest` for Search Requests

Cancel obsolete requests when a newer query arrives.

7. Handle Errors

Use:

catch
retry
retryWhen

when appropriate.

8. Respect Coroutine Cancellation

Don’t write Flow code that ignores cancellation unnecessarily.

9. Don’t Overuse Flow

If an operation returns one result:

suspend fun getUser(): User

may be simpler than:

fun getUser(): Flow<User>

Use Flow when a stream or reactive state actually makes sense.

Common Kotlin Flow Mistakes

Mistake 1: Forgetting to Collect

Creating a Flow doesn’t automatically execute it.

val data = flow {
    emit("Hello")
}

You need:

data.collect {
    println(it)
}

Mistake 2: Using MutableStateFlow Everywhere

Don’t make every piece of data a StateFlow.

Use it when representing observable state.

Mistake 3: Using SharedFlow for Everything

SharedFlow is useful for events, but ordinary state is often better represented with StateFlow.

Mistake 4: No Debounce on Search

This can cause unnecessary network requests.

Mistake 5: No `distinctUntilChanged`

Repeated identical values can cause unnecessary processing.

Mistake 6: Ignoring Cancellation

Long-running operations should cooperate with coroutine cancellation.

Mistake 7: Handling Every Error With Retry

Retrying authentication failures or validation errors repeatedly is usually not useful.

Retry transient failures selectively.

Complete Flow Architecture Example

A production-style application might look like:

                     UI
                      |
                      ↓
                 ViewModel
                      |
              +-------+-------+
              |               |
          StateFlow       SharedFlow
              |               |
          UI State          Events
              |
              ↓
          Repository
          /        \
         /          \
        ↓            ↓
    Network        Database
        |            |
        +-----Flow---+
              |
              ↓
          Application

Kotlin Flow in an E-Commerce App

Imagine an e-commerce application.

The user searches for:

laptop

Flow can handle the entire process:

Search Text
    ↓
StateFlow
    ↓
debounce(300)
    ↓
distinctUntilChanged()
    ↓
flatMapLatest()
    ↓
API
    ↓
Products Flow
    ↓
ViewModel
    ↓
UI State
    ↓
Product List

If the user quickly changes the search:

laptop
   ↓
laptop bag
   ↓
laptop stand

obsolete searches can be cancelled using flatMapLatest.

Kotlin Flow in a Chat Application

For a chat application:

WebSocket / Database
       ↓
      Flow
       ↓
Message Repository
       ↓
StateFlow
       ↓
Chat UI

New messages can be emitted as they arrive.

Message A
Message B
Message C
Message D

The UI reacts automatically.

Kotlin Flow in Authentication

Flow is also useful for authentication state.

For example:

val authState: StateFlow<AuthState>

Possible states:

Loading
Unauthenticated
Authenticated

Architecture:

Secure Storage
      ↓
Auth Repository
      ↓
StateFlow<AuthState>
      ↓
ViewModel
      ↓
UI

This fits naturally with the authentication architecture used in Kotlin Multiplatform applications.

Kotlin Flow in KMP Local Storage

Flow is also useful when local preferences or databases can change.

For example:

fun observeTheme(): Flow<String>

Then:

Storage
 ↓
Flow
 ↓
ViewModel
 ↓
UI

When the user changes the theme:

Theme = Dark

the Flow emits the updated value.

Kotlin Flow and Clean Architecture

Flow works well with Clean Architecture.

A typical setup:

Presentation
     ↓
Domain
     ↓
Repository
     ↓
Data Sources
     ↓
Flow

For example:

interface UserRepository {

    fun observeUser(): Flow<User?>

    suspend fun refreshUser()
}

This keeps the repository contract clean.

Frequently Asked Questions

What is Kotlin Flow?

Kotlin Flow is an asynchronous stream API that allows applications to emit and collect multiple values over time.

Is Kotlin Flow part of Kotlin Coroutines?

Yes. Flow is part of Kotlin’s coroutine ecosystem and is designed to work with coroutine-based asynchronous programming.

What is a cold Flow?

A cold Flow starts producing values when it is collected. Each collector generally triggers its own execution of the upstream Flow.

What is StateFlow?

StateFlow is a hot Flow designed to represent observable state and always has a current value.

What is SharedFlow?

SharedFlow is a hot Flow designed for broadcasting emissions to multiple collectors and is often useful for events.

What is the difference between Flow and StateFlow?

A normal Flow is commonly cold and represents a stream of values. StateFlow is hot and represents current state with a required initial value.

What is the difference between StateFlow and SharedFlow?

StateFlow is primarily for state, while SharedFlow is more flexible and is commonly used for events or broadcasts.

Should I use Flow instead of suspend functions?

Not always. Use a suspend function when you need one asynchronous result. Use Flow when you need multiple values or ongoing observation.

What is `debounce` in Kotlin Flow?

debounce waits for a period of inactivity before emitting a value. It is commonly used to reduce unnecessary search API requests.

What is `flatMapLatest`?

flatMapLatest switches to the newest inner Flow and cancels collection of the previous inner Flow when a new upstream value arrives.

Can Kotlin Flow be used in Kotlin Multiplatform?

Yes. Flow can be used in shared KMP code for application state, repositories, database observation, networking, and other asynchronous streams.

Is Flow better than LiveData?

Flow is Kotlin-first, coroutine-friendly, and can be used in shared Kotlin Multiplatform code. LiveData is Android-specific and remains useful in some Android applications.

Conclusion

Kotlin Flow provides a powerful way to work with asynchronous and continuously changing data.

Instead of repeatedly checking whether something has changed, you can represent that data as a stream and react to new values.

The most important concepts to remember are:

Flow
→ Asynchronous stream

Cold Flow
→ Starts when collected

StateFlow
→ Current application/UI state

SharedFlow
→ Events and broadcasts

collect
→ Receive values

map
→ Transform values

filter
→ Keep matching values

debounce
→ Wait for input to settle

distinctUntilChanged
→ Ignore consecutive duplicates

combine
→ Combine latest values

zip
→ Pair emissions

flatMapLatest
→ Switch to latest Flow

catch
→ Handle upstream errors

retry
→ Retry failures

For modern Android and Kotlin Multiplatform applications, Flow can become an important part of the application architecture.

A common pattern is:

Data Source
    ↓
Repository
    ↓
Flow
    ↓
ViewModel
    ↓
StateFlow
    ↓
UI

Once you understand the difference between Flow, StateFlow, and SharedFlow, along with operators such as map, combine, debounce, and flatMapLatest, you can build much more responsive and maintainable applications.

Kotlin Flow is especially powerful when combined with Coroutines, Ktor, databases, Jetpack Compose, and Kotlin Multiplatform, making it an important concept for modern Kotlin developers.

Kotlin Flow: Complete Beginner’s Guide to Reactive Programming

What Is Kotlin Flow?

Why Do We Need Kotlin Flow?

Kotlin Flow and Coroutines

Flow Is Cold by Default

What Does “Cold Flow” Mean?

Creating a Flow

What Is emit()?

Collecting a Flow

Flow Producer and Collector

Flow Example With a Timer

Flow Operators

Kotlin Flow map

Kotlin Flow filter

Kotlin Flow take

Kotlin Flow onEach

Kotlin Flow transform

Kotlin Flow debounce

Search Example With Debounce

Kotlin Flow distinctUntilChanged

Kotlin Flow combine

Practical combine Example

Kotlin Flow zip

combine vs zip

collectLatest

collect vs collectLatest

collect

collectLatest

Flow Error Handling

catch Operator

Flow retry

retryWhen

flowOn

Flow Context

StateFlow

StateFlow Example

MutableStateFlow vs StateFlow

Why Use StateFlow?

StateFlow for Login Screens

SharedFlow

StateFlow vs SharedFlow

SharedFlow Example

StateFlow and SharedFlow in a ViewModel

Flow and Room/Database

Flow With Network APIs

Flow in Repository Architecture

Flow With Kotlin Multiplatform

Flow in KMP Architecture

Flow and suspend Functions

Flow vs Suspend Function

Flow and LiveData

Flow and Compose

Flow Cancellation

Flow and Lifecycle

Flow Exception Handling

Flow launchIn

Flow Example: Search

Why flatMapLatest?

Flow Search Pipeline

Flow mapLatest

mapLatest vs flatMapLatest

Flow Buffering

Flow conflate

Hot vs Cold Flow

Cold Flow

Hot Flow

StateFlow as Hot State

SharedFlow Replay

Flow Best Practices

1. Expose Read-Only Flows

2. Use StateFlow for State

3. Use SharedFlow for Events

4. Use debounce for Search

5. Use distinctUntilChanged

6. Use flatMapLatest for Search Requests

7. Handle Errors

8. Respect Coroutine Cancellation

9. Don’t Overuse Flow

Common Kotlin Flow Mistakes

Mistake 1: Forgetting to Collect

What Is `emit()`?

Kotlin Flow `map`

Kotlin Flow `filter`

Kotlin Flow `take`

Kotlin Flow `onEach`

Kotlin Flow `transform`

Kotlin Flow `debounce`

Kotlin Flow `distinctUntilChanged`

Kotlin Flow `combine`

Practical `combine` Example

Kotlin Flow `zip`

`combine` vs `zip`

`collectLatest`

`collect` vs `collectLatest`

`collect`

`collectLatest`

`catch` Operator

Flow `retry`

`retryWhen`

`flowOn`

Flow and `suspend` Functions

Flow `launchIn`

Why `flatMapLatest`?

Flow `mapLatest`

`mapLatest` vs `flatMapLatest`

Flow `conflate`

4. Use `debounce` for Search

5. Use `distinctUntilChanged`

6. Use `flatMapLatest` for Search Requests

Mistake 5: No `distinctUntilChanged`

What is `debounce` in Kotlin Flow?

What is `flatMapLatest`?

Kotlin Multiplatform Local Storage: Complete Guide to DataStore, Preferences & Secure Storage

Kotlin Multiplatform Authentication: Complete Guide to Login, JWT & Token Management