abanoub-ashraf/ios-architecture-interview

iOS Architecture Interview

Senior iOS interviews heavily focus on architecture discussions. This skill prepares you to discuss, defend, and critique various iOS architectural patterns.

When to Use This Skill

• Preparing for senior/staff iOS interviews
• Learning when to apply which architecture
• Understanding trade-offs between patterns
• Discussing modularization strategies

Architecture Patterns Deep Dive

1. MVVM (Model-View-ViewModel)

The Go-To Pattern for Most iOS Apps

// MODEL
struct User: Codable, Identifiable {
    let id: String
    let name: String
    let email: String
}

// VIEWMODEL
@Observable
class UserProfileViewModel {
    private(set) var user: User?
    private(set) var isLoading = false
    private(set) var error: Error?

    private let userRepository: UserRepository

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

    func loadUser(id: String) async {
        isLoading = true
        do {
            user = try await userRepository.getUser(id: id)
        } catch {
            self.error = error
        }
        isLoading = false
    }
}

// VIEW
struct UserProfileView: View {
    let viewModel: UserProfileViewModel

    var body: some View {
        Group {
            if viewModel.isLoading {
                ProgressView()
            } else if let user = viewModel.user {
                Text(user.name)
            }
        }
    }
}

Interview Question: What are the limitations of MVVM?

1. ViewModels can become bloated ("Massive ViewModel")
2. No strict guidance on navigation/coordination
3. ViewModel-to-ViewModel communication can get messy
4. Side effects aren't explicitly managed

2. The Composable Architecture (TCA)

For Apps Requiring Predictable State

import ComposableArchitecture

@Reducer
struct UserProfileFeature {
    @ObservableState
    struct State: Equatable {
        var user: User?
        var isLoading = false
    }

    enum Action {
        case onAppear
        case userResponse(Result<User, Error>)
    }

    @Dependency(\.userClient) var userClient

    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .onAppear:
                state.isLoading = true
                return .run { send in
                    let result = await Result { try await userClient.fetch() }
                    await send(.userResponse(result))
                }

            case .userResponse(.success(let user)):
                state.isLoading = false
                state.user = user
                return .none

            case .userResponse(.failure):
                state.isLoading = false
                return .none
            }
        }
    }
}

When to choose TCA over MVVM?

• Complex apps with many interconnected features
• When you need time-travel debugging
• Apps requiring extensive testing of state transitions
• Teams that benefit from strict architectural patterns

3. Clean Architecture

For Large Enterprise Apps

┌─────────────────────────────────────────────────────────────┐
│                    Presentation Layer                        │
│         (ViewControllers, ViewModels, Views)                │
├─────────────────────────────────────────────────────────────┤
│                     Domain Layer                             │
│      (Use Cases, Entities, Repository Protocols)            │
├─────────────────────────────────────────────────────────────┤
│                      Data Layer                              │
│    (Repository Impl, API, Database, DTOs)                   │
└─────────────────────────────────────────────────────────────┘

// DOMAIN LAYER - Use Case
protocol GetUserUseCase {
    func execute(userId: String) async throws -> User
}

class GetUserUseCaseImpl: GetUserUseCase {
    private let userRepository: UserRepository

    func execute(userId: String) async throws -> User {
        return try await userRepository.fetchUser(userId)
    }
}

// DOMAIN LAYER - Repository Protocol
protocol UserRepository {
    func fetchUser(_ id: String) async throws -> User
}

// DATA LAYER - Repository Implementation
class UserRepositoryImpl: UserRepository {
    private let apiClient: APIClient

    func fetchUser(_ id: String) async throws -> User {
        let dto = try await apiClient.get("/users/\(id)", as: UserDTO.self)
        return User(dto: dto)
    }
}

Dependency Injection Patterns

// 1. Constructor Injection (Preferred)
class UserViewModel {
    private let repository: UserRepository

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

// 2. Environment Injection (SwiftUI)
struct UserView: View {
    @Environment(\.userRepository) var repository
}

// 3. Factory Pattern
protocol ViewModelFactory {
    func makeUserViewModel(userId: String) -> UserViewModel
}

class AppViewModelFactory: ViewModelFactory {
    private let dependencies: AppDependencies

    func makeUserViewModel(userId: String) -> UserViewModel {
        UserViewModel(
            userId: userId,
            repository: dependencies.userRepository
        )
    }
}

Modularization Strategies

App Target
    │
    ├── FeatureHome (Framework)
    │       └── depends on: Core, Networking, DesignSystem
    │
    ├── FeatureProfile (Framework)
    │       └── depends on: Core, Networking, DesignSystem
    │
    ├── Core (Framework) - Models, Utilities
    │
    ├── Networking (Framework) - API Client
    │
    └── DesignSystem (Framework) - UI Components

Benefits:

• Faster build times
• Clear dependency graph
• Enforced boundaries
• Team scalability

Architecture Decision Matrix

| Pattern | Complexity | Testability | Team Size | Best For | |---------|------------|-------------|-----------|----------| | MVC | Low | Low | 1-2 | Prototypes | | MVVM | Medium | High | 2-5 | Most apps | | TCA | High | Very High | 5+ | State-heavy apps | | Clean | High | Very High | 10+ | Enterprise apps |

Common Interview Questions

1. "Describe your ideal architecture for a new app"

   • Start with MVVM, add coordinators if navigation is complex
   • Use repository pattern for data layer
   • Dependency injection for testability

2. "How do you handle navigation?"

   • Coordinator pattern for UIKit
   • NavigationStack with path for SwiftUI

3. "How would you modularize a monolithic codebase?"

   • Start with shared modules (networking, design system)
   • Extract feature modules one at a time
   • Use protocols at module boundaries

How to Use

Ask me to:

• "Explain when I'd choose MVVM over TCA"
• "How should I structure a 50-screen app?"
• "Quiz me on Clean Architecture"
• "Review my architecture diagram"