Setting Up MVP Architecture for iOS: Template and Practice

Setting Up MVP Architecture for iOS: Template and Practice

Imagine: your UIKit codebase has grown to 20+ screens, each ViewController carries 500+ lines, and tests are either absent or require launching the simulator. You tried MVVM, but the Combine bindings with @Published didn't fit—the project is too old, or your team came from Android with its MVP culture. Our team has set up MVP on 15+ projects and guarantees the template works from the first commit. In this article, we'll cover key protocols, UIKit isolation, and testing without a simulator.

Wikipedia: Model-View-Presenter is an architectural pattern where the Presenter acts as an intermediary between View and Model. On iOS, this is especially useful for large UIKit projects where MVVM with Combine would require rewriting the code for a reactive stack.

Why MVP Fits UIKit Projects

If your project is not a simple list with details but a complex multi-screen UIKit app, MVP provides clear separation: the Presenter doesn't see UIKit, the ViewController is thinner, and tests are written without a simulator. Unlike MVVM where the ViewModel subscribes to Combine, MVP uses simple protocols and weak references. This lowers the entry barrier and doesn't require rewriting the code for a reactive stack. Such an approach is an element of clean architecture for iOS, as dependencies point from outer layers to the core.

What Is MVP on iOS and How It Differs from MVVM

Per the definition Model-View-Presenter is an architectural pattern where the Presenter acts as an intermediary between View and Model. In MVVM, the ViewController subscribes to @Published properties of the ViewModel via Combine. In MVP, the Presenter knows nothing about UIKit: it communicates with a View protocol implemented by the ViewController. No bindings, no reactivity—full control over the data flow.

// View protocol — interface for Presenter
protocol ProfileView: AnyObject {
    func showUser(_ user: User)
    func showLoading(_ isLoading: Bool)
    func showError(_ message: String)
}

// Presenter — pure Swift, zero UIKit
final class ProfilePresenter {
    weak var view: ProfileView?
    private let userRepository: UserRepository

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

    func viewDidLoad() {
        view?.showLoading(true)
        Task {
            do {
                let user = try await userRepository.fetchCurrentUser()
                await MainActor.run {
                    view?.showLoading(false)
                    view?.showUser(user)
                }
            } catch {
                await MainActor.run {
                    view?.showLoading(false)
                    view?.showError(error.localizedDescription)
                }
            }
        }
    }
}

// ViewController — thin, only UI
final class ProfileViewController: UIViewController, ProfileView {
    private var presenter: ProfilePresenter!

    override func viewDidLoad() {
        super.viewDidLoad()
        presenter.viewDidLoad()
    }

    func showUser(_ user: User) {
        nameLabel.text = user.name
        avatarImageView.load(url: user.avatarURL)
    }

    func showLoading(_ isLoading: Bool) {
        isLoading ? activityIndicator.startAnimating() : activityIndicator.stopAnimating()
    }

    func showError(_ message: String) {
        // Toast or Alert
    }
}

Key point: weak var view: ProfileView?—a weak reference is mandatory, otherwise you get a retain cycle. The Presenter holds the View, the View holds the Presenter; one of them must be weak.

How to Test a Presenter Without a Simulator

The main advantage of MVP: the Presenter is testable without a simulator. Here's an example with a mock:

final class MockProfileView: ProfileView {
    var didShowUser = false
    var isLoading = false

    func showUser(_ user: User) { didShowUser = true }
    func showLoading(_ isOn: Bool) { isLoading = isOn }
    func showError(_ message: String) { /* ignore */ }
}

func testViewDidLoad_success() async {
    let mockView = MockProfileView()
    let mockRepository = MockUserRepository(result: .success(User.fixture))
    let sut = ProfilePresenter(userRepository: mockRepository)
    sut.view = mockView

    sut.viewDidLoad()
    // Short pause for async Task
    try await Task.sleep(nanoseconds: 100_000_000)

    XCTAssertTrue(mockView.didShowUser)
    XCTAssertFalse(mockView.isLoading)
}

The test takes milliseconds, no XCUITest required. Code coverage with such tests reaches 80%, and regression budget savings up to 40%. Compare: a typical MVVM ViewModel with Combine requires setting up XCTestExpectation or Sink—MVP is significantly simpler and faster here.

What's Included in MVP Setup

When you order MVP setup, you get:

• Complete Swift files for the module: Presenter, ViewController, Router.
• Unit tests for the Presenter (5–10 cases per module, 80% coverage).
• Integration instructions for adding new screens.
• Team training (1–2 calls with a demo).

The work takes 2–3 days for a new project. Contact us to assess the volume of migrating existing screens. Get a consultation on implementing MVP in your project.

Navigation in MVP: What Is Router / Wireframe?

The Presenter should not manage navigation directly—that violates Single Responsibility. The classic solution is a Router (or Wireframe in original MVP terms):

protocol ProfileRouter: AnyObject {
    func navigateToEditProfile(user: User)
    func navigateToSettings()
}

A concrete ProfileRouterImpl works with UINavigationController—the UIKit dependency is isolated. The Presenter receives the Router via DI and calls router.navigateToEditProfile(user:) without knowing what happens under the hood.

How to Migrate from MVC to MVP

Migrating an existing MVC screen to MVP is a 4–8 hour task per screen. Create a View protocol, extract logic into a Presenter, add a Router. Move Model dependencies into the Presenter. Implement the View in the ViewController. Test the Presenter. This step-by-step plan applies to any screen, and the final architecture becomes modular and testable.

Step-by-Step MVP Setup for a New Project

1. Define modules. Each screen is a separate module with View, Presenter, Router protocols.
2. Write protocols. View—only display methods; Presenter—lifecycle and event handling methods; Router—navigation methods.
3. Implement the Presenter. All logic, server/DB work. No UIKit.
4. Implement the View (ViewController). Forward calls to the Presenter.
5. Implement the Router. Create a class that uses UINavigationController for transitions.
6. Set up DI. Use a module factory or Swinject to compose dependencies.
7. Write tests. Cover every Presenter method (5–10 cases per module).

MVP vs MVVM Comparison

Common MVP Implementation Mistakes

• Forgetting weak on view—retain cycle, memory leak. Always use weak var view: ViewProtocol?.
• Mixing navigation logic into the Presenter—extract a Router.
• Not testing the Presenter—you lose the main advantage of MVP. Cover with mocks.
• Overcomplicating protocols—one method per screen instead of grouping. Keep the number of View methods reasonable (5–7).

Order MVP setup for your project—get a ready-made template in 2–3 days. We guarantee your project will have a testable structure, and your team will get a workflow without unnecessary overhead. Contact us for a consultation.

Mobile App Architecture

The app is built in a single ViewController with 2000 lines. Network calls, business logic, UI updates—all in one place. Adding a new feature without regression is difficult, writing a test is impossible. This isn’t “bad code”—it’s a lack of architecture. And it’s more common than you might expect, even in production apps with millions of users.

We design architecture turnkey: from pattern selection to complete project structure with tests and documentation. In 7–10 days you get clean, modular code ready for scaling.

Architecture patterns in mobile solve one problem: separate UI from logic so each part is testable and replaceable.

MVVM: Basic Pattern

Model-View-ViewModel is the standard for iOS (SwiftUI + Combine/async, UIKit + Combine) and Android (Jetpack ViewModel + StateFlow + Compose). The ViewModel holds UI state and business logic. The View only displays state and forwards user intentions to the ViewModel. The Model represents data and its source.

Key rule: ViewModel knows nothing about UIKit or Android View classes. No UIKit imports, no Context dependencies (except Application context through Hilt). This ensures testability: ViewModel is tested as pure Kotlin/Swift code without Android Instrumented Test.

MVVM covers 70% of needs. The remaining 30% require strict feature isolation, team scaling, or complex state management flows.

Clean Architecture: When MVVM Isn’t Enough

Adds layers on top of MVVM:

• Domain layer — business logic, platform-independent. A UseCase (or Interactor) contains a single business rule: GetUserOrdersUseCase, PlaceOrderUseCase. Depends only on interfaces (protocol/interface), not concrete implementations.
• Data layer — repository implementations. OrderRepositoryImpl implements OrderRepository from domain. Knows about Retrofit, Room, UserDefaults. The ViewModel doesn’t know where data comes from—network or cache.
• Presentation layer — ViewModel + View. Knows about Domain, not Data.

Dependency rule: dependencies point inward only. Domain depends on nothing. Data and Presentation depend on Domain.

Presentation → Domain ← Data

This allows swapping implementations: tests use an in-memory repository instead of network, the interface remains the same.

Practical caveat: Clean Architecture adds files and layers. For small apps, this is overhead. It’s justified starting from ~15 features and teams of 3+ developers.

BLoC for Flutter: Predictable State Flow

BLoC (Business Logic Component) is the standard pattern in the Flutter community. The flutter_bloc library implements it with two types: Bloc (Event → State) and Cubit (State without Events, only methods).

Bloc processes Event and emits a new State via on<EventType> handlers. State is immutable—a new object for each change. BlocBuilder re-renders only the part of the tree where state changed.

// Event
abstract class CartEvent {}
class AddItemToCart extends CartEvent {
  final String productId;
  AddItemToCart(this.productId);
}

// State
abstract class CartState {}
class CartLoaded extends CartState {
  final List<CartItem> items;
  CartLoaded(this.items);
}

// Bloc
class CartBloc extends Bloc<CartEvent, CartState> {
  CartBloc(this._cartRepository) : super(CartLoaded([])) {
    on<AddItemToCart>(_onAddItem);
  }

  Future<void> _onAddItem(AddItemToCart event, Emitter<CartState> emit) async {
    final current = state as CartLoaded;
    final updated = await _cartRepository.addItem(event.productId);
    emit(CartLoaded(updated));
  }
}

The advantage of BLoC is testability. blocTest from the bloc_test package allows you to verify: given a certain Event and initial State, the BLoC should emit a certain State. No UI, no mocks for the Flutter framework.

VIPER: For Large iOS Projects

VIPER (View, Interactor, Presenter, Entity, Router) is the strictest separation of responsibilities for iOS. Each component has a protocol and concrete implementation.

• View — UI only, delegates everything to Presenter
• Interactor — business logic, network and data operations
• Presenter — mediator between View and Interactor, formats data for View
• Entity — data models (pure structures)
• Router — navigation between modules

Each module (screen or feature) is a separate VIPER module. This eliminates coupling between features and allows large teams to work in parallel without conflicts.

The cost: many files, many protocols. Boilerplate is generated via Sourcery or custom Xcode templates. VIPER is justified for apps with 10+ developers and 50+ screens.

TCA (The Composable Architecture)

TCA by Point-Free is a more modern alternative to VIPER for iOS/macOS. Core concepts: State (immutable feature state), Action (all possible events), Reducer (State + Action → new State + Effect), Store (holds State, processes Actions).

Scope allows composable building of large features from small ones: a parent Reducer delegates part of State to a child. Each feature is tested in isolation via TestStore with precise control over Effects.

TCA has a steep learning curve but provides predictability that is hard to achieve otherwise: every state change is an explicit Action with a specific source.

Which Pattern to Choose for Your Project?

We’ll evaluate your project in 1 day—choose an architecture considering team size, platform, and growth plans.

There is no universal answer. Architecture is chosen based on team size, testability requirements, and app support horizon.

What Components Are Included in Our Architecture Work?

• Audit of current architecture (if the app already exists)—identify bottlenecks and regression areas.
• Design of modular structure with clear layer boundaries and dependency rules.
• Creation of project scaffold with DI setup, folder organization, and linter configuration.
• Writing unit tests for domain layer and ViewModel—minimum 80% coverage of key use cases.
• Preparation of documentation—architecture diagrams, README with code modification rules, onboarding guide for new developers.
• Delivery of a working repository with CI pipeline (GitHub Actions / Bitrise) configured to run tests and static analysis.

All this is included in the design cost. Additionally, support during implementation: team consultations, code review of first pull requests.

How Does Lack of Architecture Affect Development Speed?

Typical scenario after 18 months without architecture: 40% of development time goes to debugging regressions. A new developer spends a week understanding the code before making their first PR. Tests aren’t written “because it’s hard to mock.” Adding a new feature requires understanding half the codebase.

Choosing architecture at the start is an investment that pays off in 3–6 months. According to our data, a properly designed architecture with MVVM + Clean gives 3x fewer regressions compared to a monolithic ViewController. And the cost of implementation is recouped in 2–3 sprints.

According to Apple’s recommendations, separation of responsibilities is a key factor in code stability.

Why Trust Our Team with Architecture?

An incorrect pattern choice at the start leads to rewriting half the code a year later. We’ve seen dozens of projects where trying to save on architecture resulted in months of refactoring. With over 10 years of commercial development experience and work on apps from 1 to 50 developers, we help avoid common mistakes:

• Overengineering for a simple MVP (we assign MVVM, not VIPER).
• Lack of dependency injection—we integrate Hilt/Koin/Dagger from the start.
• Ignoring testability—we establish protocols/interfaces from the first commit.

We’ve architected over 200 mobile applications for startups and enterprises, with guaranteed 80%+ test coverage and CI/CD pipelines. Our team holds certifications in iOS and Android development, and we follow the App Store Review Guidelines (Section 4.2/5.1) to ensure smooth store approvals.

Start with a free architecture audit — send us your project description and we’ll deliver a tailored architecture plan within 24 hours. Reach out via Telegram or email to get started.