This content originally appeared on Level Up Coding - Medium and was authored by Vaibhav Shakya | Mr Neo
Cut the boilerplate, keep the sanity — and ship faster in 2025.
🚀 The Setup: Architecture Choice Fatigue
If you’ve been building Android apps long enough, you’ve probably played the acronym drinking game: MVC, MVP, MVVM, MVI… and then Clean Architecture joined the party.
In 2025, Jetpack Compose has changed how we think about state, events, and UI updates. The question is:
Do we stick with MVVM, go full MVI, or mix them for sanity’s sake?
🏛 The Old Guard: MVC & MVP (Quick Recap)
Before Compose, we started here:
- MVC: The View did way too much, Controllers got bloated, and testability was… not great.
- MVP: A step up. Presenter handled logic, View was dumb, Model stayed separate. But async work and state management still got messy.
Both gave way to MVVM when Android devs realized two-way binding + ViewModel felt cleaner.
⚙️ MVVM in Compose — The Familiar Friend
MVVM (Model–View–ViewModel) in Compose is straightforward:
- The ViewModel exposes UI state (via StateFlow or MutableState)
- The View (Composable) observes it and triggers actions back to ViewModel
MVVM Example:
// ViewModel
class CounterViewModel : ViewModel() {
private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count
fun increment() {
_count.value++
}
}
// Composable
@Composable
fun CounterScreen(viewModel: CounterViewModel = viewModel()) {
val count by viewModel.count.collectAsState()
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Text("Count: $count")
Button(onClick = { viewModel.increment() }) {
Text("Increment")
}
}
}
✅ When to use:
- Simple flows, CRUD apps, small teams
- Faster onboarding for new devs
🔄 MVI in Compose — The State Jedi
MVI (Model–View–Intent) enforces Unidirectional Data Flow:
User Action → Intent → Reducer → New State → UI Renders
MVI Example:
// State
data class CounterState(val count: Int = 0)
// Intent
sealed class CounterIntent {
object Increment : CounterIntent()
}
// ViewModel (Reducer)
class CounterMviViewModel : ViewModel() {
private val _state = MutableStateFlow(CounterState())
val state: StateFlow<CounterState> = _state
fun onIntent(intent: CounterIntent) {
when (intent) {
is CounterIntent.Increment ->
_state.value = _state.value.copy(count = _state.value.count + 1)
}
}
}
// Composable
@Composable
fun CounterMviScreen(viewModel: CounterMviViewModel = viewModel()) {
val state by viewModel.state.collectAsState()
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Text("Count: ${state.count}")
Button(onClick = { viewModel.onIntent(CounterIntent.Increment) }) {
Text("Increment")
}
}
}
✅ When to use:
- Complex, multi-step workflows
- Multiple concurrent events, offline sync, websocket updates
🧹 Clean Architecture — The Layering Rulebook
Think of Clean Architecture as the city zoning plan:
[Presentation] → MVVM or MVI logic
[Domain] → Use Cases / Business Rules
[Data] → Repository, API, DB
In practice:
- MVVM or MVI lives in Presentation layer
- Use Cases in Domain handle app logic
- Data layer talks to network or DB
🥤 Hybrid MVVM + MVI — The Best of Both Worlds
In most real-world Compose apps, you don’t have to pick one pattern for the whole app.
Instead, you can choose MVVM for simple flows and MVI for complex state machines.
They can happily live together under the same Clean Architecture layers.
Hybrid Example:
// --- MVVM Example: Simple Profile Screen ---
class ProfileViewModel : ViewModel() {
private val _username = MutableStateFlow("Vaibhav")
val username: StateFlow<String> = _username
fun updateName(newName: String) {
_username.value = newName
}
}
@Composable
fun ProfileScreen(viewModel: ProfileViewModel = viewModel()) {
val username by viewModel.username.collectAsState()
Column {
Text("Username: $username")
Button(onClick = { viewModel.updateName("NewName") }) {
Text("Change Name")
}
}
}
// --- MVI Example: Complex Chat Screen ---
data class ChatState(val messages: List<String> = emptyList(), val isLoading: Boolean = false)
sealed class ChatIntent {
object LoadMessages : ChatIntent()
data class SendMessage(val text: String) : ChatIntent()
}
class ChatViewModel : ViewModel() {
private val _state = MutableStateFlow(ChatState())
val state: StateFlow<ChatState> = _state
fun onIntent(intent: ChatIntent) {
when (intent) {
ChatIntent.LoadMessages -> {
_state.value = _state.value.copy(isLoading = true)
// Simulate async load
viewModelScope.launch {
delay(500)
_state.value = _state.value.copy(
messages = listOf("Hello", "Welcome to the chat"),
isLoading = false
)
}
}
is ChatIntent.SendMessage -> {
_state.value = _state.value.copy(
messages = _state.value.messages + intent.text
)
}
}
}
}
@Composable
fun ChatScreen(viewModel: ChatViewModel = viewModel()) {
val state by viewModel.state.collectAsState()
Column {
if (state.isLoading) Text("Loading messages...")
state.messages.forEach { msg -> Text(msg) }
Button(onClick = { viewModel.onIntent(ChatIntent.SendMessage("Hi there!")) }) {
Text("Send Message")
}
}
}
Why Hybrid Works in 2025:
- MVVM keeps simple screens lean and quick to implement.
- MVI keeps complex flows predictable and easier to debug.
- Both can share the same Domain & Data layers in Clean Architecture.
📉 Real-Life Trade-offs
MVVM → Less ceremony → Faster to ship → Risk of “god” ViewModels
MVI → Predictable & testable → More boilerplate → Steeper learning curve
Clean → Scales well → More layers → Overkill for tiny apps
🏁 Key Points :
- MVVM: Great for smaller, simpler flows.
- MVI: Great for complex state-heavy screens.
- Clean: Wrap around either for scalable apps.
- Hybrid: Most real apps in 2025 mix them.
💬 What’s your go-to pattern in Compose right now? Have you found a sweet spot between MVVM and MVI?
From MVVM to MVI: What Really Works in Compose was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.
This content originally appeared on Level Up Coding - Medium and was authored by Vaibhav Shakya | Mr Neo
Vaibhav Shakya | Mr Neo | Sciencx (2025-09-03T14:27:57+00:00) From MVVM to MVI: What Really Works in Compose. Retrieved from https://www.scien.cx/2025/09/03/from-mvvm-to-mvi-what-really-works-in-compose/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.