iOS is the mobile operating system that powers iPhones, iPads, Apple TV, and other Apple devices. Understanding its architecture and development process is essential for product managers working on Apple platforms.
iOS is the mobile operating system developed by Apple Inc. It powers devices like the iPhone, iPad, and Apple TV. The first iPhone launched in 2007, introducing iOS to the world. iOS apps are distributed through the Apple App Store.
The programming languages historically used for iOS development include Objective-C, C, C++, and Swift. Today, Swift is the primary language, with Objective-C largely phased out but still present in legacy codebases.
As a product manager working on iOS apps, you don’t need to write code, but you must understand the development process and architecture to make informed decisions and work effectively with your engineering team.
From idea to iPhone: the six stages of app development
Taking an app idea to a live iPhone app involves several key stages. As a PM, you typically focus on the early stages, but awareness of the full flow is critical.
-
Discovery
This is the initial phase where the problem space is explored. You identify user needs and validate the opportunity. -
Concept
Refine the idea and objectives. Write a technical specification document that guides the team on what to build. This phase is primarily the PM’s responsibility. -
Wireframe
Create a user roadmap and information architecture blueprint. Map out screens and user flows. This bridges concept and design. -
Design
UX and UI designers create prototypes and establish a style guide or design system. They produce mocks for the development team. -
Software Architecture Planning
Software architects or senior engineers design the underlying system architecture that supports the app. -
Coding
Developers write the code that brings app functions to life, integrating APIs and backend services. Testing is conducted at unit and integration levels. -
Testing
QA teams and sometimes users test the app for bugs, usability issues, and performance before submission to the App Store.
Throughout this process, there is a feedback loop between design and software architecture planning to iterate on prototypes and technical feasibility.
Understanding the MVC design pattern in iOS apps
iOS apps are built using the Model-View-Controller (MVC) design pattern. This is a fundamental architectural pattern that organizes code into three core components:
| Component | Role |
|---|---|
| Model | Represents the data and business logic (data objects) |
| View | Handles the user interface (UI) elements the user interacts with |
| Controller | Manages the app’s behavior, responding to user input and coordinating between Model and View |
The MVC pattern breaks down the app into manageable pieces, separating concerns and making the app easier to maintain and extend.
Model
Models hold the data objects and are often represented by classes. They provide data to the controller, which then populates the views. Models can be built using iOS frameworks like Foundation or Core Data.
View
Views are the graphical user interface components. Each screen or page in the app is a view, comprising buttons, text fields, images, and other UI elements. Views are typically described in storyboards and assembled using tools like Interface Builder within Xcode’s UIKit framework.
Controller
Controllers handle the app’s behavior and flow. They respond to events (like taps or gestures), update models, and refresh views accordingly. iOS apps follow event-driven programming, where controllers process incoming events and manage transitions between views.
The controller also manages the app lifecycle, including handling interface orientation changes, suspending or resuming activities, and responding to system events like proximity sensing.
Anatomy of an iOS app
Key objects in the MVC architecture include:
- UIApplication: The singleton object that manages the app’s lifecycle and event loop.
- AppDelegate: Responds to high-level app events, like launching, backgrounding, and termination.
- ViewController: Manages a single view and its subviews, making them visible and handling user interaction.
- UIWindow: The container for views displayed on the screen.
Product and engineering sync meeting
You (PM): “Our iOS developer mentioned MVC is central to the app’s architecture. Can you explain how that affects feature delivery?”
Karthik (iOS Developer): “Sure. MVC ensures that UI changes don’t mess with data logic. It lets us iterate on the user interface without breaking the backend logic, and vice versa.”
You (PM): “So if we want to add a new feature, the controller will handle the flow between the new UI and data?”
Karthik (iOS Developer): “Exactly. It keeps responsibilities clear and code modular.”
Understanding MVC helps you communicate clearly with engineers and anticipate where bugs or delays might occur.
How architecture patterns influence feature delivery
The layered architecture of iOS
Beyond MVC, iOS itself is structured into layered frameworks. As a PM, you’ll mostly interact with the Cocoa Touch layer, but understanding the full stack is useful.
| Layer | Description and Examples |
|---|---|
| Media Layer | Graphics, audio, and video frameworks (e.g., Core Graphics, AVFoundation) |
| Cocoa Touch Layer | High-level frameworks for UI and app services (e.g., UIKit, MapKit, PushKit, GameKit, EventKit, Twitter framework) |
| Core Services | Fundamental system services (e.g., Core Data, CloudKit, Core Location, HealthKit, Foundation Framework) |
| Core OS Layer | Low-level services like Bluetooth, security, and authentication |
Most app development focuses on the Cocoa Touch layer, which provides the UI toolkit and app infrastructure. For certain apps, especially those requiring media interaction or device features, the media layer and core services may come into play.
The product manager’s role in iOS app development
Your main responsibilities align with the early stages of app development:
- Leading discovery and refining the concept and objectives.
- Writing and owning the technical specification document, which guides design and engineering.
- Collaborating closely with UX/UI designers during wireframing and design to ensure the user experience matches the problem and objectives.
- Coordinating with software architects and engineers to ensure the architecture supports the product vision and technical requirements.
- Understanding the MVC pattern and iOS architecture enough to communicate effectively with developers and anticipate technical constraints or trade-offs.
You are not expected to code but should be conversant in the tools and frameworks your team uses. For example, knowing that the IDE is Xcode, that Swift is the primary language, and that UIKit and related frameworks provide the UI components.
Test yourself: Prioritizing an iOS app feature
You are the PM at a Bangalore-based early-stage startup building an iOS app for food delivery. The engineering team says that adding a live order tracking feature will require changes to the Model and Controller layers and take 6 weeks. A simpler ETA display based on estimated times can be done in 2 weeks using mostly View changes. The CEO wants the live tracking ASAP for a key investor demo in 4 weeks.
The call: How do you prioritize the live tracking feature versus the simpler ETA display? How do you communicate this to engineering and leadership?
Your reasoning:
You are the PM at a Bangalore-based early-stage startup building an iOS app for food delivery. The engineering team says that adding a live order tracking feature will require changes to the Model and Controller layers and take 6 weeks. A simpler ETA display based on estimated times can be done in 2 weeks using mostly View changes. The CEO wants the live tracking ASAP for a key investor demo in 4 weeks.
Your task: How do you prioritize the live tracking feature versus the simpler ETA display? How do you communicate this to engineering and leadership?
your reasoning:
Field exercise: Map your app’s architecture
Pick an iOS app you use regularly or are building. Write down:
- What are the main data models (Model) the app uses? For example, user profile, orders, messages.
- What are the key screens or views? List the main UI components visible to the user.
- Identify the controllers that connect the models and views. How do they manage user interactions and data flow?
- Sketch a simple diagram linking these three components for one feature.
This exercise will help you internalize the MVC pattern and understand how it applies to real-world apps.
Where to go next
- If you want to deepen your understanding of product architecture: Software Architecture for PMs
- If you want to learn about user experience design for mobile: Mobile UX Design Basics
- If you want to improve collaboration with engineering: Engineering Communication
- If you want to explore Android app development differences: Android Mobile Apps
PL alumni now work at Flipkart, Razorpay, Swiggy, PhonePe, Amazon, Microsoft, and 30+ other companies.