MVVM explained: what it is, when to use it and how to apply it in React Native
February 10, 2026 · 2 min read
MVVM (Model-View-ViewModel) is a pattern that separates the interface from business logic.
The organization challenge
When UI code and business rules are mixed together, the same problems show up:
- Hard to test and maintain
- Coupling between screen and logic
- Rework when the interface changes
- Code duplication across screens
The three components
Each one with a clear responsibility:
| Layer | Responsibility |
|---|---|
| View | Displays data and captures user interactions |
| ViewModel | Prepares data and commands for the screen |
| Model | Domain data and business rules |
The flow is View ↔ ViewModel ↔ Model. The Model does not know the View.
Model
The data and business rules layer.
- Data structures and domain entities
- Validations, calculations and business rules
- Does not know the View or the ViewModel
View
The user interface: what they see and touch.
- Screens and components (React Native, Flutter, Swift/Kotlin etc.)
- Displays data exposed by the ViewModel
- No business logic, only presentation and events
ViewModel
The bridge between View and Model: screen state and logic.
- Transforms Model data for the View
- Exposes properties and commands (binding)
- Presentation logic, independent of the UI
What it looks like in React Native
Each screen becomes a small folder, with one file per role:
features/cart/
index.tsx // View: only renders
viewModel.ts // ViewModel: state and handlers
models.ts // Model: types and rules
// models.ts
export type CartItem = { id: string; name: string; price: number; qty: number }
export const cartTotal = (items: CartItem[]) =>
items.reduce((sum, i) => sum + i.price * i.qty, 0)
// viewModel.ts
import { useState } from 'react'
import { cartTotal, type CartItem } from './models'
export function useCartViewModel(initial: CartItem[]) {
const [items, setItems] = useState(initial)
const remove = (id: string) => setItems((prev) => prev.filter((i) => i.id !== id))
return { items, total: cartTotal(items), remove }
}
// index.tsx
export default function CartScreen() {
const { items, total, remove } = useCartViewModel(initialItems)
return <CartList items={items} total={total} onRemove={remove} />
}
The View does not know how the total is calculated. The ViewModel can be tested without rendering anything.
Why use MVVM
- Test screen logic without depending on the interface
- Redesign the UI without breaking business rules
- Design and backend evolve in parallel
- More reusable code and simpler maintenance
Where to use it
The pattern fits mobile, web with complex state and desktop:
- Mobile: Swift, Kotlin, React Native, Flutter
- Web: Vue, React, Angular
- Desktop: WPF, .NET MAUI, SwiftUI
Does my project need it?
Consider MVVM when:
- Several screens share logic and state
- You want to test logic without depending on the UI
- Design and backend evolve at different paces
- The app is likely to grow, and so is the team
Simple, static screens can do without the pattern.
Summary
Model = data and rules. View = what the user sees. ViewModel = bridge and screen state. Clear separation, easier testing and maintenance.