MVVM Architecture Setup for iOS: Combine vs @Observable

MVVM Architecture Setup for iOS: Combine vs @Observable

We often encounter projects built on MVC where the ViewController swells to thousands of lines: network requests, data processing, UI updates—all in one file. Such architecture complicates testing and maintenance. Switching to MVVM solves these problems: the ViewModel takes over business logic, and the View remains "dumb." However, setting up MVVM on iOS is not a universal template: the choice between Combine, @Observable, and RxSwift affects performance and compatibility. Our experience shows that a properly selected implementation reduces the time to implement new functionality by 40% and cuts regression bugs by a factor of 3 due to logic isolation. We guarantee a stable architecture that complies with the App Store Review Guidelines.

Which MVVM implementation to choose for your project?

MVVM with Combine (iOS 13+)

Classic implementation with ObservableObject and @Published:

final class ProfileViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    @Published var error: AppError?
    private let userRepository: UserRepository
    private var cancellables = Set<AnyCancellable>()

    init(userRepository: UserRepository) {
        self.userRepository = userRepository
    }

    func loadProfile() {
        isLoading = true
        userRepository.fetchCurrentUser()
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.error = error
                    }
                },
                receiveValue: { [weak self] user in
                    self?.user = user
                }
            )
            .store(in: &cancellables)
    }
}

Weak points: cancellables must be explicitly stored (otherwise the subscription is immediately cancelled), memory leaks via [weak self] in closures—a typical crash cause when navigating back. We configure deinit with logging for lifecycle verification in debug.

MVVM with @Observable (iOS 17+)

The @Observable macro from the Observation framework removes boilerplate:

@Observable final class ProfileViewModel {
    var user: User?
    var isLoading = false
    var error: AppError?
    private let userRepository: UserRepository

    init(userRepository: UserRepository) {
        self.userRepository = userRepository
    }

    func loadProfile() async {
        isLoading = true
        defer { isLoading = false }
        do {
            user = try await userRepository.fetchCurrentUser()
        } catch {
            self.error = error as? AppError
        }
    }
}

SwiftUI automatically tracks dependencies—re-renders only when used properties change. No @Published, no cancellables. Downside: iOS 17+ only, which limits use for projects with a wide audience.

Comparison of Combine and @Observable

Why is Dependency Injection important?

Without DI, a ViewModel creates dependencies inside itself—testing becomes impossible. Using a DI container allows swapping real services with mocks in a couple of lines of code. For example, in tests we pass a MockUserRepository, which returns prepared data instead of hitting the network. This cuts test execution time from 10 seconds to 0.1 seconds per test.

Here is a comparison of popular DI frameworks:

The choice depends on language version and testing requirements. We recommend SwiftDependencies for new projects on iOS 17+ due to strong typing and built-in test support.

How to implement MVVM painlessly: step-by-step guide?

1. Analyze the current project structure and identify modules.
2. Choose the appropriate implementation: Combine for iOS 13+, @Observable for iOS 17+, RxSwift if legacy code exists.
3. Create base protocols for ViewModel and Coordinator.
4. Set up a DI container (Swinject, Resolver, or SwiftDependencies).
5. Refactor one screen from MVC to MVVM to demonstrate to the team.
6. Write unit tests for the new ViewModel using mock repositories.
7. Document the architecture and conduct code review.

This process takes 2 to 5 days for a new project. Migration from legacy MVC to MVVM is evaluated individually—contact us for an assessment.

How to test ViewModel with async/await?

Thanks to async/await, tests become linear. Example:

func testLoadProfile_success() async {
    let mockRepository = MockUserRepository(result: .success(User.fixture))
    let sut = ProfileViewModel(userRepository: mockRepository)
    await sut.loadProfile()
    XCTAssertEqual(sut.user?.id, User.fixture.id)
    XCTAssertFalse(sut.isLoading)
    XCTAssertNil(sut.error)
}

No need for XCTestExpectation with async—using async/await, ViewModel tests are written linearly and read like regular code.

Coordinator pattern + MVVM

Pure MVVM does not address navigation. The ViewModel should not know about screens. A Coordinator encapsulates navigation logic:

protocol ProfileCoordinator: AnyObject {
    func showEditProfile(user: User)
    func showSettings()
}

final class ProfileViewModel {
    weak var coordinator: ProfileCoordinator?
    // ...
    func editProfileTapped() {
        guard let user else { return }
        coordinator?.showEditProfile(user: user)
    }
}