iOS System Design

API Client Architecture

Design a flexible networking layer with protocol-based abstraction. Define an Endpoint struct that encapsulates path, method, headers, body, and query items. Create an APIClient protocol with a generic request method that returns Decodable objects.

protocol APIClient {
    func request<T: Decodable>(_ endpoint: Endpoint) async throws -> T
}

Request and Response Handling

The NetworkService implements APIClient. Build URLRequest from Endpoint, execute with URLSession, and decode responses. Handle HTTP status codes with specific errors for unauthorized, not found, and server errors. Use JSONDecoder with date strategies for consistent parsing.

Retry and Error Recovery

Implement a RetryPolicy that determines whether to retry based on error type and attempt count. Retry on timeout and 5xx server errors. Use exponential backoff for retry delays. Add circuit breaker pattern to stop retrying after repeated failures.

Authentication

Handle token-based authentication with automatic refresh. Store tokens in Keychain. Intercept requests to add authorization headers. Refresh expired tokens transparently. Support multiple authentication methods through strategy pattern.

Multi-Layer Caching

Implement a caching hierarchy with memory cache (NSCache) for fast access, disk cache for persistence, and network as the final source. Each layer checks before fetching from the next layer.

class CacheManager {
    let memoryCache = NSCache<NSString, AnyObject>()
    let diskCache: DiskCache
    
    func get<T: Codable>(_ key: String, type: T.Type) async throws -> T {
        if let cached = memoryCache.object(forKey: key as NSString) as? T {
            return cached
        }
        if let diskData = try await diskCache.get(key) {
            let decoded = try JSONDecoder().decode(T.self, from: diskData)
            memoryCache.setObject(decoded as AnyObject, forKey: key as NSString)
            return decoded
        }
        throw CacheError.notFound
    }
}

Cache Invalidation

Use time-based expiration (TTL), event-based invalidation (user action), and version-based invalidation (API version changes). Tag cached entries for group invalidation when related data changes.

Image Caching

Use a dedicated image cache with downsampling. Cache images at display size, not original size. Implement memory pressure handling to evict images under pressure. Use URLCache for HTTP-level caching of image requests.

Data Synchronization

Store data locally with CoreData or SwiftData. Queue mutations when offline. Sync when connectivity returns. Handle conflicts with last-write-wins or merge strategies.

Sync Strategies

• Optimistic sync: Apply changes locally immediately, sync in background
• Pessimistic sync: Wait for server confirmation before applying locally
• Conflict resolution: Use timestamps, version vectors, or operational transforms

Connectivity Monitoring

Use NWPathMonitor to track network state. Queue operations when offline. Retry failed syncs when connectivity returns. Show sync status to the user.

Modular Architecture

Split the app into feature modules with clear boundaries. Each module owns its data, networking, and UI. Use protocols for inter-module communication. Share common infrastructure through a core module.