Por que a conversa sobre arquitetura muda quando o time passa de 15 engenheiros

Em um aplicativo mantido por três ou quatro desenvolvedores iOS, quase qualquer padrão minimamente organizado funciona bem. Todo mundo conhece cada tela, resolve dúvidas em cinco minutos no chat e ajusta convenções sem atrito. A realidade muda completamente quando o produto escala para vinte, quarenta ou sessenta engenheiros distribuídos em várias squads mexendo no mesmo repositório ao mesmo tempo.

Nesse ponto, a arquitetura deixa de ser uma preferência pessoal de estilo e vira um contrato de coordenação entre pessoas que nunca trabalharam juntas. Se cada squad decide por conta própria onde formatar valores monetários, onde disparar eventos de analytics e quem controla a pilha de navegação, as revisões de PR ficam lentas e o onboarding de um novo integrante leva semanas.

No mercado iOS corporativo, duas arquiteturas dominam esses projetos de grande porte: Clean Swift (VIP: View, Interactor e Presenter) e MVVM-C (Model, View, ViewModel e Coordinator). Já trabalhei anos com as duas em aplicativos financeiros e de varejo, e posso afirmar que nenhuma resolve todos os problemas sozinha. Cada uma cobra um preço diferente.

Critério real de escolha: escolha a arquitetura pelo tipo de erro que o seu time mais precisa evitar. O VIP reduz ambiguidade estrutural ao custo de mais arquivos; o MVVM-C entrega velocidade e encaixe natural com SwiftUI, mas exige disciplina constante no code review para impedir ViewModels inchados.

Comparando o fluxo de dados lado a lado

A diferença prática entre os dois modelos fica evidente quando olhamos para o trajeto de uma ação do usuário, como tocar no botão de carregar o extrato mensal. No VIP, o ciclo é sempre unidirecional e passa obrigatoriamente por três fronteiras de protocolo. No MVVM-C, a View observa o estado exposto pelo ViewModel e a navegação sai da cena por meio do Coordinator.

Clean Swift (VIP)MVVM-CViewControllerInteractorRegra + WorkersPresenterFormatação UIRouter + DataStoreViewUIKit / SwiftUIViewModelEstado + BindingUseCasesDomínio / RedeCoordinatorNavegação e DI
No VIP o ciclo força a separação entre regra de negócio (Interactor) e formatação (Presenter). No MVVM-C o ViewModel concentra estado e delega navegação ao Coordinator.

Clean Swift (VIP) na prática: previsibilidade acima de concisão

O grande mérito do VIP em empresas com alta rotatividade ou dezenas de squads é a previsibilidade absoluta. Se um desenvolvedor abre um módulo de fatura que nunca viu na vida para corrigir um bug de formatação de moeda, ele sabe em dois segundos que o código está no Presenter. Se o bug está na validação de saldo ou na chamada ao serviço, o código está no Interactor ou no Worker.

Veja como um caso de uso real de consulta de extrato fica estruturado em VIP sem misturar responsabilidades:

import Foundation

enum StatementModels {
    enum Load {
        struct Request { let month: Int; let year: Int }
        struct Response { let entries: [StatementEntry]; let totalCents: Int }
        struct ViewModel { let rows: [Row]; let formattedTotal: String }
        struct Row { let title: String; let amountText: String; let isDebit: Bool }
    }
}

protocol StatementBusinessLogic {
    func loadStatement(request: StatementModels.Load.Request)
}

protocol StatementPresentationLogic {
    func presentStatement(response: StatementModels.Load.Response)
}

@MainActor
protocol StatementDisplayLogic: AnyObject {
    func displayStatement(viewModel: StatementModels.Load.ViewModel)
}

final class StatementInteractor: StatementBusinessLogic {
    private let presenter: StatementPresentationLogic
    private let worker: StatementFetching

    init(presenter: StatementPresentationLogic, worker: StatementFetching) {
        self.presenter = presenter
        self.worker = worker
    }

    func loadStatement(request: StatementModels.Load.Request) {
        Task {
            let entries = (try? await worker.fetchEntries(month: request.month, year: request.year)) ?? []
            let total = entries.reduce(0) { $0 + $1.amountCents }
            presenter.presentStatement(response: .init(entries: entries, totalCents: total))
        }
    }
}

final class StatementPresenter: StatementPresentationLogic {
    weak var viewController: StatementDisplayLogic?
    private let currencyFormatter: NumberFormatter

    init(currencyFormatter: NumberFormatter) {
        self.currencyFormatter = currencyFormatter
    }

    func presentStatement(response: StatementModels.Load.Response) {
        let rows = response.entries.map { entry in
            StatementModels.Load.Row(
                title: entry.merchantName,
                amountText: format(cents: entry.amountCents),
                isDebit: entry.amountCents < 0
            )
        }
        let viewModel = StatementModels.Load.ViewModel(
            rows: rows,
            formattedTotal: format(cents: response.totalCents)
        )
        Task { @MainActor in
            viewController?.displayStatement(viewModel: viewModel)
        }
    }

    private func format(cents: Int) -> String {
        let value = Decimal(cents) / 100
        return currencyFormatter.string(from: value as NSDecimalNumber) ?? "R$ 0,00"
    }
}

Testar esse Presenter dispensa rede, banco e UIViewController. Basta passar uma struct Response com valores em centavos (incluindo negativos e zero) e conferir as strings entregues ao StatementDisplayLogicSpy. Por outro lado, note o custo: mesmo uma tela simples acaba gerando cinco ou seis arquivos entre cena, modelos, interactor, presenter, worker e router.

MVVM-C com SwiftUI e UIKit: velocidade com risco de inchaço

O MVVM-C encaixa de forma muito mais natural no modelo declarativo do SwiftUI (usando @Observable ou ObservableObject) e também funciona bem em UIKit com Combine ou closures. Em vez de quebrar uma tela pequena em seis arquivos, você define um estado explícito de tela e delega a lógica pesada de negócio para UseCases injetados.

import Foundation

@MainActor
protocol StatementCoordinating: AnyObject {
    func openEntryDetail(entryId: String)
}

@MainActor
final class StatementViewModel: ObservableObject {
    enum State: Equatable {
        case idle
        case loading
        case loaded(rows: [String], total: String)
        case failed(message: String)
    }

    @Published private(set) var state: State = .idle

    private let fetchStatement: StatementFetching
    private weak var coordinator: StatementCoordinating?

    init(fetchStatement: StatementFetching, coordinator: StatementCoordinating) {
        self.fetchStatement = fetchStatement
        self.coordinator = coordinator
    }

    func load(month: Int, year: Int) async {
        state = .loading
        do {
            let entries = try await fetchStatement.fetchEntries(month: month, year: year)
            let titles = entries.map(\.merchantName)
            state = .loaded(rows: titles, total: "\(entries.count) lançamentos")
        } catch {
            state = .failed(message: "Não foi possível carregar o extrato.")
        }
    }

    func didSelectEntry(id: String) {
        coordinator?.openEntryDetail(entryId: id)
    }
}

O problema que vejo acontecer com frequência no MVVM-C não está no padrão em si, mas na falta de uma camada de domínio por baixo do ViewModel. Sem UseCases claros, o ViewModel começa com 120 linhas e seis meses depois já tem 950 linhas misturando chamadas HTTP, regras de validação, persistência em cache, tracking de eventos e formatação de data. Quando isso acontece, você trocou o antigo Massive View Controller por um Massive ViewModel igualmente difícil de manter.

Em ambos os padrões, controlar corretamente cancelamento de tarefas e isolamento da main thread evita crashes de concorrência; vale combinar essa arquitetura com as práticas descritas em concorrência moderna em Swift com async/await e Actors.

Tabela comparativa para decisão de engenharia

CritérioClean Swift (VIP)MVVM-C (com UseCases)
Direção do fluxo de dadosUnidirecional estrito (View → Interactor → Presenter → View)Reativo / observável (View observa estado do ViewModel)
Encaixe com SwiftUIRequer adaptador de estado (ObservableObject ou @Observable) na ponta da ViewNativo e direto, com pouca fricção
Testabilidade unitáriaMuito alta; formatação e regra de negócio já nascem separadasAlta, desde que lógica pesada fique em UseCases e formatação em helpers puros
Cerimônia e arquivos por tela5 a 6 arquivos por cena, além de structs Request/Response/ViewModel3 a 4 arquivos por tela, reduzindo atrito em features pequenas
Risco arquitetural principalOver-engineering em telas triviais e excesso de pass-throughViewModel acumular regra de negócio, rede e UI no mesmo arquivo
Previsibilidade com 25+ devsMuito alta; cada responsabilidade tem endereço fixoMédia a alta; depende de linter, templates e revisão rigorosa de PR

Armadilhas de memória e navegação que aparecem nos dois modelos

Independentemente da sigla escolhida no quadro branco, três bugs de runtime aparecem com regularidade nas revisões que faço:

No VIP, esquecer weak na referência do Presenter para a ViewController fecha um ciclo forte de retenção (View → Interactor → Presenter → View). A tela fecha visualmente, mas toda a árvore de objetos continua presa na memória até o encerramento do aplicativo. Um teste unitário de vazamento usando addTeardownBlock com referência weak pega esse bug em segundos no CI.

No MVVM-C com UIKit, o vazamento mais comum acontece nos childCoordinators. O usuário abre um fluxo filho via push na UINavigationController e volta usando o gesto nativo de arrastar da borda esquerda da tela. Se o coordinator pai não escuta o delegate da navigation controller (navigationController(_:didShow:animated:)), o coordinator filho nunca é removido do array e acumula na memória a cada visita. Em apps grandes, cruzar essa navegação com o modelo de arquitetura modular e deeplinks em apps iOS ajuda a manter o ciclo de vida limpo entre módulos.

Por fim, evite dogmatismo cego. Já vi time criar seis arquivos VIP completos para uma tela estática de "Termos de Uso" que só exibia texto e um botão de fechar. Criar exceções documentadas para telas puramente apresentacionais poupa tempo sem abrir brecha para desorganização.

Quando escolher cada um e checklist de revisão de PR

Adote Clean Swift (VIP) quando a base principal ainda estiver majoritariamente em UIKit, quando o time tiver mais de vinte engenheiros rodando em múltiplas squads e quando regras complexas de formatação e compliance exigirem fronteiras rígidas e fáceis de auditar. Prefira MVVM-C com UseCases quando o aplicativo estiver migrando ou nascendo em SwiftUI, quando a equipe precisar de menor cerimônia por entrega e quando houver maturidade de engenharia para manter os ViewModels enxutos.

Use este checklist nas revisões de código independentemente do padrão adotado:

  • A camada de View não contém regras de negócio, formatação de moeda/data nem chamadas diretas de rede.
  • Nenhuma dependência concreta de infraestrutura (URLSession, Keychain, banco) é instanciada dentro do Interactor ou ViewModel sem injeção por protocolo.
  • Referências de volta para a View ou para o Coordinator pai estão marcadas como weak e há teste de desalocação de memória para fluxos críticos.
  • Tarefas assíncronas em andamento são canceladas quando a tela é descartada, evitando atualizações tardias de estado.
  • A navegação entre módulos passa por abstração de rota ou Coordinator, sem acoplar diretamente duas cenas de features distintas.