The iOS Architect – Build Advanced iOS Apps with a Complex Architecture

Finally, a complete program to build complex real-world iOS apps with a scalable architecture and code that is easy to read, test and maintain

Get past material for beginners with trivial examples and learn the advanced techniques and practices I use to build apps for big clients with code that stands the test of time.


  • complex asynchronous networking
  • unit testing and test-driven development
  • memory management with ARC
  • clean code
  • advanced architectural design patterns

And much more.

Hi, I’m Matteo Manferdini. Over the past 10+ years, I created iOS apps for big companies and published apps in the App Store on my own.

Today I teach iOS development to more than 18.000 readers every month, 10.000+ subscribers, and hundreds of people have joined my premium courses on iOS development.

I consult with big clients, and I can ask high rates for my work. I have built complex iOS apps for many clients, working in big teams as well as the only developer.

But when I made my first app for the iPhone back in 2008, I could not do any of this.

I could not even get a decent haircut

I just got out of university and I all I knew was how to program.

I didn’t know anything about architectural principles, design patterns, MVC, SOLID and all the buzzword you read nowadays on iOS development blogs.

Back then, I had to learn iOS development all by myself. Since it was the beginning of the iPhone, there was no sound material around.

After a lot of trial and error, I published my first app in the App Store. That helped me land my first job as an iOS developer, which was a significant milestone at the time.

At first, it went smoothly. I completed the first tasks I got assigned and gained confidence in my skills.

But then I hit the first roadblock.

They asked to introduce unit testing in the project. I started reading all the material I found online about unit testing in iOS and mocking frameworks. But I could not figure out a way to write any unit test in the real app.

After weeks of research online, I had nothing to show for it

As it turned out, that was not the only time.

Fast forward two years later. I was working at an agency, where I wrote an app for a prominent client. This was a big investment bank in Amsterdam, so it had stringent requirements.

When I completed the project, they sent my code to a third party to review.

At this point, I thought I knew everything there was to know about iOS development. I thought my code was well written and the reviewers would be impressed by my skills (does this sound familiar?)

The verdict was not what I expected.

Their report was ruthless:

My code was hard to read, too complicated, hard to maintain and had zero tests that ensured its correctness

That stung. But my arrogance prevented me from learning from that feedback. They just were not good enough to realize how perfect was my code. And who needs tests anyway? Nobody does that in iOS.

Luckily, that did not last long.

It was not much later that I joined some newsletters about iOS development and started reading articles about architecture and design patterns.

My world shattered and I realized how little I knew about iOS development.

Knowing how to create iOS apps is not enough

If you don’t adopt the right architecture and design patterns, you will end with unmaintainable code that will create many problems later.

But this realization only got me so far.

Architecture is a hard concept, but it is necessary in today’s iOS development world. Knowing this is important, but does not tell you how you should organize your code.

Today, projects are getting bigger and more complex. Teams are growing, and development costs are increasing. Maintenance is now more important than releasing the first version of an app.

Good architecture is now critical in any project.

This is a common problem. During my freelancing career, I got often hired to fix projects with too many issues. And they were always caused by botched architectures.

Too often we came to the hard but necessary conclusion that we had to throw away all the code and rewrite the whole app from scratch.

This is a hard decision to take in any project. It means you wasted all the money and time you put in the development, and you have nothing to show for it.

Experience has shown me that many iOS developers don’t know much about the best practices of building robust iOS architectures that stand the test of time.

Many blogs out there only talk about superficial concepts with small code samples. They almost never talk about best coding practices, intricate patterns or test coverage.

Do any of these sound familiar to you?

I have not come across any books or tutorials that show you how to build a quality grade app. Most of them focus on beginners and disregard good architecture, or when they cover advanced material, they focus only on a specific feature or aspect. After the beginner stage, you are almost left in the dark as how to proceed forward.

I have read about Clean Architecture, listened to many podcasts, read articles on the web. A reference app would be precious. I mean a real big app, not just a TODO app like the sample from the VIPER guys. That is good to learn the concepts, but it’s too short. It’s just a toy app.

There is no complete course, they teach you only the most basic stuff. Most of the authors say that there is no audience for the hard things, but in my opinion, they are wrong. I want real-world techniques and practices.

I want to write cleaner code that is easier to read and maintain, and which handles real-world situations.

I would like to create several apps, and would love to have an excellent architecture for them. Code really separated. Right now all my files start with the template code, and then it’s lines and lines of customization. I know they shouldn’t be there. I Just don’t see where.

Architecture is still tricky for me because you can’t easily copy it from a Stack Overflow post.

I understand each one of these. It was a long process to put all the right ideas together.

I read countless articles and books. I even learned different programming languages that I never used only to understand the core ideas behind the buzzwords of the moment (like Haskell, or, as a fellow developer defined it, “the language everybody talks about but nobody uses”).

I had to put all these concepts together myself. I tried them in real projects and discussed them with other developers. I kept the ones that worked and threw away the ones that did not fit iOS development.

Ten years later I can finally produce high-quality code that I am proud of

I can now look back at the time when I thought I knew everything and see all my shortcomings. In all honesty, I didn’t know much at all.

But now I can also see other things. Remember the project I could not write unit tests for? It was not just my fault. I now realize that its code was not testable the way it was written. At the time I had no idea, but now I also know how I could refactor it.

There is a reason why now I can work for big companies with very skilled developers.

I now know not only how to create complex architectures that are easy to maintain and test. I can also see the shortcomings of existing code and discuss with other developers about the best course of action.

I can also read articles and books about new ideas and judge whether they are solid or where they could create problems.

I can do this because I learned some significant insights about iOS architecture.

Insight #1

Programming paradigms, development principles and design pattern all work in concert

When you read many articles about iOS development, it’s easy to get lost into buzzwords

Which ones of these concepts should you use?

Protocol-oriented programming seems to be hot in Swift nowadays, but so is functional programming. Aren’t the two contradictory?

What about S.O.L.I.D. principles? You hear they are essential but aren’t they about object-oriented programming?

And where does unit testing fit in all this mess?

The reality is that these concepts are all useful!

So how do use them all correctly in your apps?

The key is in understanding their purpose is the same. This means that in many aspects they overlap. But they approach problems in software development from different angles.

As such, they don’t necessarily contradict, but complement, each other.

Think about building software as building a house. You have materials, tools, practices, and blueprints. These are all different things, but we use them all for the same purpose: building the house.

The same is true for all the concepts in iOS development.

Once you understand how these concepts work in concert, it’s easier to see how they fit into the implementation of a real app.

Many of my students are always surprised on how I can come up with clean solutions like these:

The truth is, I am no genius.

I know how to separate code because I grasp how the concepts work together. I also have seen how these work in practice and the problems you get when you ignore them.

Insight #2

Good code is as much about the macro level architecture as it is about the micro level techniques

To continue with the house building metaphor, if you use terrible materials, you can have the best tools and the coolest project, but your house will still collapse.

Building iOS apps is the same. You have to pay attention to the whole app architecture, but also to the small pieces of code in your classes.

You write clean code applying many different concepts and techniques:

  • You make your code easier to understand. Using a consistent coding style, naming variables, and types appropriately, and writing only necessary comments can make your code much better without altering any of its structure.
  • You give your code a reliable and well-organized structure. Separating code by scope, making a clear separation between pure functions and pure procedures, and pushing the happy path to the left are all practices that can make your code more readable.
  • You use formal techniques to avoid mistakes and even make some of them impossible. For example, you can ensure the consistency of the state in a class by using computed properties and property observers. And you can even use Swift’s type system to prevent mistakes using advanced techniques like phantom types.

These are low-level techniques that are independent of the architecture you adopt in your app. But they are essential too.

They apply to any code you write and any design patterns you use. So they are a great tool to make sure that the code you write is robust and maintainable in the future.

While theory and examples are helpful to understand the concepts, it’s only when you see them applied to real-world code that you comprehend their real benefits.

Insight #3

The correct iOS design patterns allow you to apply the right principles without effort

As I said, all the ideas behind programming paradigms, development principles and design pattern are all critical.

Still, it can be overwhelming to have to think about them all, all the time.

Even when you know them all well, it’s impossible to each one at the same time for every piece of code you write.

But you don’t have to.

Architectural design patterns in iOS help enforce many best practices without having to think about them. This was a great revelation for me.

It all starts with the MVC pattern.

On the surface, this might seem to be not a very sophisticated pattern. In fact, if you use its most common version, you will soon run into problems, like massive view controllers that contain too much code.

I often point out in all my material that the real version of MVC in iOS has four layers and not three. Introducing the model controllers layer, with its responsibilities, allows you to organize the code in your app better and keep clutter out of view controllers.

But it does not stop there.

The different layers in MVC communicate with each other over various links. But if you investigate the nature of these connections, you realize that many of them are weak mechanisms, like delegation and callbacks.

If you keep only the active links, you discover that the MVC pattern has the shape of a tree.

This has many implications.

If you look at the S.O.L.I.D. principles of object-oriented programming, for example, they promote a top-down design of your classes. The tree structure of MVC does too.

If you think about unit testing instead, the London school of test-driven development also prescribes a top-down approach to the design of units. So the tree-shaped MVC helps with unit testing too.

Finally, memory management in ARC can be quite complicated in an iOS app. If you don’t pay attention, it’s easy to create strong reference cycles that leak memory and make your app crash.

But the MVC pattern comes to the rescue again. It’s tree structure also dictates the types of references you can have between the layers. If you pay attention to a few focal points, memory management becomes much more straightforward.

So, with just one pattern, you get three benefits:

  • respecting the S.O.L.I.D. principles
  • writing more testable code
  • easier memory management

In fact, the advantages of MVC are even more than these three.

You can see that if you have to think about all of them separately, you would have a hard time figuring out how and when to apply them to your code.

It took me a long time to come to these conclusions.

The information you find in articles and books is too fragmented. You can get a book on unit testing, but all you get is a few techniques.

How do they relate to the rest of the development process of an iOS app? These specific books usually don’t explain it.

You can also find more general books on the high-level principles. A book often recommended is “Structure and interpretation of computer programs.” You can even read it for free online.

It’s a book that has many great ideas. But it was written in 1985, and all the code is in Lisp. So you need to learn a programming language you will never use to be able to read that book. And believe me, Lisp is an entirely different beast from Swift and other imperative or object-oriented languages. It will take you a while to grasp it.

And after that, how do you map the concepts to iOS development? How do you know which ones are relevant and which ones do not belong to Swift?

It took me years of study, experimentation, and discussion with other developers to put all these concepts together into a coherent system.

And now I want to share that system with you.

This material informs my everyday task as iOS developer and I’m sure it will still be valuable for years to come, because it addresses primarily the underlying concepts, not just the operational details as most tutorials out there do. – Adrian Tineo

This course is perfect for iOS developers who want to take the next step in their career advancement by supercharging their thought processes and coding skills when developing and maintaining apps. – Nicholas Lash


The complete system to build advanced iOS Apps with a complex architecture, using the best practices to write code that is easy to read, test and maintain.


I put together everything I have learned about advanced iOS architecture in the last ten years of working as an iOS developer.

You will learn about different programming paradigms, advanced Swift techniques, design patterns and testing techniques to build complex iOS apps. All this in a coherent system that will make you write maintainable code that stands the test of time.

How The iOS Architect works

The iOS Architect is a 4 module online course that distills everything I have learned about creating scalable and maintainable architectures for iOS apps.

Each module covers a specific piece of the whole system, from the different techniques and programming paradigms, to clean code, architectural patterns, complex networking and testing.


Inside The iOS Architect system

The course approach is first to cover the theory behind every concept in depth. Then we will immediately apply each idea to the creation of a networked app with a complex architecture.

The course includes 10+ hours of video lessons on the theory, but also expect a lot of practical examples. The hands-on readings go over the creation of a complex app and touch all the problems and the edge cases of real-world app development.

Module 1

The Guiding Principles of iOS Software Development

  • Cohesion and coupling: how to set boundaries between modules, reduce complexity and increase readability, code reuse, and maintainability. These concepts let you build the confidence to recognize which code works and which doesn’t.
  • The useful ideas of functional programming that will make your code more robust and readable. These are the reasons why functional programming has seen a renaissance since the introduction of Swift.
  • Wireframes and mockups, the simple design tools that prevent useless code that gets thrown away. With these, you will be excited to create great designs and great software.
  • The tree-shaped nature of the MVC pattern and how it guides the writing of your code (this is a concept at the foundation of a well-structured app architecture that very few developers know)
  • How object-oriented programming organizes code into reusable modules and the problems of inheritance. iOS apps are developed using OOP, so this paradigm is here to stay.
  • What makes code well structured and maintainable in the long term and why even code that works might not be correct.
  • The 5 phases of app development to create well-designed apps that you will be proud of and eager to maintain.
  • How protocol-oriented programming solves the problems of object-oriented programming and multiple inheritance (protocol-oriented programming has been in the mouth of everyone since Apple introduced it).
  • The few fundamental concepts to create better designs than most apps in the App Store, avoiding analysis paralysis and constant revisions (including the tools I use to create designs quickly).
  • Confidently estimating software projects and dealing with colleagues, bosses or clients that disagree with you (without having them think you are not good enough).
  • Specifying requirements and knowing all the ramifications of your decisions (get this wrong, and you will waste time on useless code you will throw away later).
  • How you should plan your model types structure before you write any code and the problems of recursive structs in Swift. This is an annoying problem you are likely to encounter in any real-world app.
  • How to sort through the noise of trends and fads and the scattered and confusing approach to iOS development you find in most online material. It’s easy to write a short tutorial, but no one ever shows you the big picture and the relationship between all these concepts in a real app.

Lesson 1.1 – The App Development Cycle and Technical Debt

The Reasons Behind Tools, Best Practices, and Advanced Techniques

Lesson 1.2 (hands-on) – Requirements Specification

How to Avoid Wasting Time on Useless or Impossible to Make Features

Lesson 1.3 (hands-on) – Wireframes And Mockups

How to Produce High-Quality App Design Following Only a Few Basic Design Principles

Lesson 1.4 – Paradigms, Principles, and Patterns

How to Write Correct, Well Structured and Maintainable Code

Lesson 1.5 – Programming Paradigms in Swift

The Foundation of Your Code’s Structure and the Problems to Avoid

Lesson 1.6 – The iOS App Blueprint

The Principles and Patterns That Guide the Structure of All the Code You Write

Lesson 1.7 (hands-on) – Creating the App Model

How to Define Model Types According to External Constraints

Module 2

Writing Well Structured and Correct Code

  • What it means to write clean code, why you should do it and why debating about code style is a waste of time (this is what you want to know to avoid juggling with trade-offs).
  • The anatomy of unit tests and how you can understand testing without involving any complicated framework. Once you take the tools out of the equation, unit testing will become much more transparent.
  • Increasing the readability of your code by giving proper names to variables, functions, types, magic values, and workhorse lines. Swift idioms can be elegant and concise, but if you don’t know them, you will feel like a dumb kid in Swift land.
  • Test coverage: how much is enough in a project and how to get a high coverage without using test doubles or complex techniques for asynchronous code.
  • Generics: writing reusable code by loosening restrictions on types. If you always felt that Swift generics look like magic, this will finally help you nail them down.
  • A complete discussion about decoding JSON datausing the Swift 4 capabilities, including advanced decoding of JSON data into custom types. In a real-world app, the simple automatic decoding offered by Swift is not enough.
  • Assertions and fatal errors: detecting programming mistakes and choose the correct ones to use for each case.
  • Pure functions and pure procedures: how to make your code more readable and more comfortable to reason about. Very few developers know this, but it makes a huge difference.
  • Using computed properties and property observers to guarantee consistency in the state of your types (and avoid weird bugs)
  • The best practices to keep your code clean all the time instead of refactoring later and feeling lousy throwing code away.
  • How higher-order functions allow you to reuse code that would not be reusable otherwise (this will help you if you have repeated logic that but you can’t figure out how to refactor it)
  • Non-primitive and phantom types: the formal techniques that leverage Swift’s type system and make some mistakes impossible.
  • How unit testing relates to the different layers of the MVC pattern in a real app and which parts are the easiest ones to test. This will help you write the tests that will give you the most benefits with the least time investment.
  • The Detroit and the London schools of test-driven development: the differences between bottom-up and top-down approaches to unit testing.
  • The psychological barriers of test-driven development nobody talks about (if test-driven development and unit testing always feel overwhelming to you, this will show you why)
  • My Pareto Unit Testing methodology: designed for humans to make sure that you write the critical tests or your app without worrying about the trivial ones. No more feeling like a slacker because you don’t follow TDD.
  • The process to refactor a massive project that has no tests (and the firebreaks technique to keep refactored code separated from code not yet refactored)

Lesson 2.1 – Minimizing Bugs in iOS Apps

Writing Clean Swift Code that Prevents Human Mistakes

Lesson 2.2 – Higher Order Functions and Generics

Advanced Swift Concepts to Improve Code Reuse in your Apps

Lesson 2.3 – Guaranteeing Code Correctness

Formal Techniques to Prevent Ambiguities and Accidental Mistakes

Lesson 2.4 (hands-on) – Adding Business Logic

How to Safely Represent and Convert Data in the Model of an App

Lesson 2.5 – Unit testing

Techniques and Methodologies to Make Sure the Code You Write Is Correct

Lesson 2.6 (hands-on) – Testing the Model of an App

How to Write Effective Unit Tests for Any Project, Even if You Don’t Follow Test-Driven Development

Module 3

Advanced Architectural Principles for iOS Apps

  • The S.O.L.I.D. principles, cohesion and coupling: how to organize your code better and create distinct classes that are easy to reuse and test.
  • Testing the logic of a class without using test doubles: how to keep units separated in unit tests and make test code more readable. Many developers resort to sophisticated testing techniques because they don’t know how to do otherwise.
  • How to visualize the flow of your code before you write it. This is how you correctly distribute responsibilities to classes.
  • Automatic Reference Counting (ARC): how memory leaks and dangling references create problems.
  • Value types and value semantics: the simple distinction between values and references is not enough to avoid hard to fix problems.
  • The most critical points in iOS apps where you have to be careful about memory management issues. Focus on these focal points, and you will fix all the memory problems an app can have.
  • Top-down architecture design: how the S.O.L.I.D. principles and the London school of TDD guide the design of the right architecture for your specific app.
  • The guidelines to keep all your classes free from strong reference cycles and memory leaks. Making sure a few classes handle memory correctly can prevent memory problems in the whole app.
  • Logic and behavior: how to make your classes easier to understand and test (this is a compelling but little-known concept that will help you boost the correctness of all your code).
  • The top-down interface design of model controllers: creating a well-thought architecture independent from implementation details.
  • Where and how table view delegates and data sources should interact. Given their role, they need to be arranged in a specific way to have a properly working architecture.
  • The fundamental differences between values and references and how to use them properly in iOS apps (if you never know when to use structures or classes, this is for you)
  • How separating logic from behavior improves reusability and makes code easier to read, while respecting the S.O.L.I.D. principles (this concept will change how you think about the code in your apps).
  • How MVC and other patterns respect and enforce the S.O.L.I.D. principles so that you don’t have to worry about them all the time.
  • Interface controllers: the correct architectural pattern for advanced table view behavior. This includes resizing cells without reloading data, jumping the typing cursor to other cells and scrolling content above the keyboard.
  • A more pragmatic approach to the MVVM pattern with view models as value types. Use this if you want to keep your view architecture well organized and easily testable.
  • The big problem of many open source libraries: subclassing UIKit classes and interface pollution.

Lesson 3.1 – The S.O.L.I.D. Principles of Object-Oriented Programming

Making your App’s Architecture More Understandable, Flexible and Maintainable

Lesson 3.2 (hands-on) – The Heart of iOS Apps

Applying the S.O.L.I.D. Principles and the Top-Down Design of Model Controllers

Lesson 3.3 – Separating Logic from Behavior

How Value and Reference Types Behave in Swift and Memory Management in iOS Apps

Lesson 3.4 (hands-on) – Extracting Logic from Model Controllers

Isolating Responsibilities, Managing Memory and Testing Classes Without Using Test Doubles


Lesson 3.5 – The Architecture of User Interfaces

How to Move Data from the Model of an App to its Complex Dynamic UI

Lesson 3.6 (hands-on) – The MVVM Pattern and Table Views

Isolating UI Code and Reusing Common Logic Across Data Sources

Lesson 3.7 (hands-on) – Advanced Table Views

Using Multiple Cell Prototypes and Sections to Lay Out any Complex Screen

Lesson 3.8 (hands-on) – Complex UI Interaction

Responding to UI Events and Updating the View Hierarchy Respecting the Principles of OOP

Module 4

Complex iOS Design Patterns and Networking Architecture

  • The Lotus MVC pattern, my overarching pattern that addresses all the architectural problems of a real app without forcing you to create objects you don’t need. This is the result of years working in different teams and personal research that you won’t find anywhere else.
  • Making classes testable using dependency injection, without radically changing the structure of your code or making it harder to read. Including the techniques to refactor code that uses singletons or system frameworks to make it testable.
  • The similarities between MVC, MVVM+C, VIPER and all other design patterns. There are core architectural ideas in iOS you cannot dispense with.
  • The role of coordinators in view controller communication, and how they remove responsibilities from view controllers and decouple them entirely.
  • The architecture of the networking layer of iOS apps, and the common problems of networking code: hyper-parametrization and the violation of the Open-Closed Principle.
  • Sharing code across network requests using multiple inheritance hierarchies through protocol extensions.
  • The guidelines to split monolithic storyboards into multiple ones, including some uses of storyboard references that you probably have not seen before.
  • How HTTP requests and responses are structured and how to handle HTTP methods and status codes. When you build a serious networked app, you cannot ignore the underlying protocols.
  • How to make Swift’s strong type system accept test doubles in place of dependencies, even if they are separate types.
  • How to write safe test doubles with the minimal amount of code needed to assert the exact code paths you want to test.
  • Authentication through the OAuth protocol. Modern apps need to deal with this multi-step authentication protocol, so you need to understand how it works.
  • Hot to make asynchronous code synchronous in unit tests instead of relying on expectations to test networking code.
  • The undocumented memory layout of network callbacks and why it’s important to avoid memory leaks and callbacks to dismissed view controllers.
  • Working with the iOS Keychain without relying on third-party libraries.

Lesson 4.1 – Testing Complex Dependency Graphs

Injection Techniques to Replace Dependencies with Test Doubles

Lesson 4.2 (hands-on) – Refactoring Classes for Unit Testing

Making Dependencies Injectable and Disentangling System Frameworks

Lesson 4.3 – MVVM+C, VIPER and Lotus MVC

The Overarching Ideas of iOS Architectural Patterns

Lesson 4.4 (hands-on) – Managing Navigation Through Coordinators

How to Remove the Last Responsibilities from View Controllers

Lesson 4.5 – Complex Networking Architecture

Dealing with HTTP, OAuth and the iOS URL Loading System

Lesson 4.6 (hands-on) – Protocol-Oriented Programming for Network Requests

Using Multiple Inheritance and Generics to Avoid Hyper-parametrization

Lesson 4.7 (hands-on) – Networked Navigation in iOS Apps

Bringing Together View Controllers, Network Requests and Navigation through Coordinators

Module 5

Managing Multiple Asynchronous Execution Paths (in progress)

  • The Dispatch Framework: the low-level and lightweight concurrency technology Apple designed to solve the problems of concurrency.
  • UML state machines: the time-tested paradigm to manage complexity in many software systems. State machines are a better alternative to reactive frameworks that can help you streamline the code of view controllers.
  • Method chaining and custom operators: the advanced but dangerous techniques to create embedded domain-specific languages in Swift.
  • Operation queues: the preferred high-level concurrency solution that allows you to control sophisticated background code without worrying about threads, race conditions, and deadlocks.
  • A top-down approach to error handling that follows the SOLID principles and the London school of TDD, including how to handle errors from multiple sources and make them bubble up through the layers of the MVC Pattern
  • Prioritizing network requests in your app using operation queues with various qualities of service.
  • How to identify a Domain Specific Language and how to define custom operators that fit Swift’s type system rules. Including how to combine operators with method chaining to create a uniform DSL.
  • How to extract common view controller behavior from concrete implementations into a protocol hierarchy. Plus, the two strategies to make view controllers conform to complex protocol hierarchies.
  • How reactive functional programming tries to address the emerging complexity of view controllers by transforming asynchronous code into sequential streams of data. Here I will highlight all the drawbacks reactive frameworks bring to your project.
  • How to express the complex parallel functionality of a view controller using state machines with orthogonal regions.
  • Custom operations: getting a fine-grained control over the execution state of background tasks to cancel and suspend operations that are already running.
  • What are the differences between processes and threads, and how the operating system schedules them. This is a common question that gets often asked in job interviews.
  • How multithreaded code can cause race conditions that create inconsistent states in your app. This can happen even in the most straightforward and tested code.
  • Hot to simplify the interface of an object using method chaining to remove needless repetitions. This includes complex method chaining with intermediate types that preserve context between calls.
  • How to handle paging in table views that fetch incremental content by separating the logic from the asynchronous code in view controllers. Including the correct techniques and architectural layout to fetch the images for the rows of a table view.

Lesson 5.1 – Error Handling in Swift

Handling Errors Coming from the iOS Frameworks and Asynchronous Callbacks

Lesson 5.2 (hands-on) – The Fallibility of Networks

Categorizing, Managing and Resurfacing Asynchronous Errors in Network Requests

Lesson 5.3 – Keeping Complexity Under Control

How to Manage Asynchronous Callbacks and Errors in View Controllers

Lesson 5.4 (hands-on) – State-Machine-Driven View Controllers

Streamlining the Complexity of Asynchronous View Controllers into Well-defined Grammars

Lesson 5.5 (hands-on) – Complex Domain-Specific Languages

Creating an Embedded State-Machine Grammar in Swift Using Method Chaining and Custom Operators

Lesson 5.6 (hands-on) – Protocol-Oriented Behaviors

Extracting Common Code from View Controllers into Complex Protocol Hierarchies

Lesson 5.7 (hands-on) – Asynchronous Table Views

Paging Content and Concurrently Fetching Cell Images

Lesson 5.8 – Running code in the background

Avoiding hard concurrency problems with Dispatch and Operation queues

Lesson 5.9 (hands-on) – Controlling Background Execution

Using Queues and Operations to Schedule, Suspend and Cancel Network Requests and other Background Tasks

The iOS Architect also includes…

Step by step analysis of a real-world complex networked app

Along the theoretical lessons, I apply each concept to the step by step implementation of a complex, real-world app. This app deals with all the complexities and edge cases you face when developing real apps.

No more toy apps that show you only one concept in isolation and leave out the critical details.

You will see what decisions and consideration go into each stage of the app’s development. I will not merely give you the completed code. I will show you how to adapt and refactor it as the app grows as it happens on a real software project.

If you are looking for examples of real solutions you can apply to your projects, you will find them in this course. This is all possible because the final app will have a user experience ready for the App Store.

Xcode project with full git history to explore the evolution of the app’s code

The material includes the full Xcode project so that you can see the code in its context and not only in an isolated lesson. The project comes with the entire git history of the whole evolution of the app. That allows you to compare each step to the previous ones and see which code changed.

Each commit in the repository has a tag with a lesson number. In this way, you can quickly go back to the right lesson in the course to refresh the relevant concepts right where they were introduced.

Downloadable slides and transcripts

Each theoretical video lesson comes with full downloadable slide decks and transcripts, to quickly go back to the salient parts of a lesson without sitting through a whole video.

Requirement specifications, wireframes, and mockups to follow the whole app creation process

The course does not only cover the writing of the code. It also includes the discussion of the initial requirement specification and the creation of the app’s wireframes and mockups. These are all downloadable in PDF, Omnigraffle, and Sketch formats.

A look into the Future: Transitioning to SwiftUI (Coming Soon)

At WWDC 2019, Apple introduced SwiftUI, a new framework to build interfaces for apps on iOS and other platforms.

While this will cause some changes to the course, I predict that the material will stay mostly the same.

Moreover, SwiftUI came out of beta in autumn 2019 and is available only from iOS 13 forward. That means that you won’t be able to adopt it in any real app for at least one to two years if you want to target the full iOS market.

So, in the foreseeable future, you will need to build apps using the current UIKit and Auto Layout, which I cover in this course.

User interfaces are just one of the aspects of a complete. Regardless of the framework you use, the architectural concepts I teach in this course remain largely the same.

After Apple will release the second iteration of SwiftUI, consolidating the framework and its best practices, I will update the whole course. If you join now, you will get the entire update free of charge.

Lifetime access

The course is online and accessible from anywhere. It is pre-recorded, so you don’t have to show up for live classes in the middle of your day. You can follow it at your own pace, and you will have lifetime access to the material. Maybe you need to pause the course to go on a vacation, or life and work take over, not leaving you enough time. That’s not a problem since you get lifetime access to the course and can resume whenever you want. You can go over the entire course to have a high-level understanding of each advanced concept now. In the future, you can review the different ideas to refresh your knowledge or deepen your understanding.

The iOS Architect course has allowed me to make a much larger impact on my team as a junior mobile developer at a consulting company. Before the course, I was timid in expressing opinions, refactoring code, architecting apps, and diving into Swift features of which I was unfamiliar. – Nicholas Lash

Is The iOS Architect right for you?

This is an advanced course, so it’s not for everybody.

The iOS Architect is NOT for you if…

  • You are a beginner in iOS development and don’t know the basic concepts. These include view controllers and containers, and basic design patterns like MVC and delegation. You also need a foundational understanding of storing data on a device, making network calls and asynchronous callbacks. (Join my other course, The Confident iOS Professional, to learn about these. The iOS Architect will be here when you are ready).
  • You are starting from scratch and never made any iOS app in the past. While you don’t need to have a job as an iOS developer, only some experience in writing real code will help you understand what I discuss in the course.
  • You are just looking for code templates to use in your apps and you are not serious about learning advanced architectural and software principles. This is not what this course offers. Copy and paste developers please leave.
  • You need to get a job and make money soon. In fact, I don’t recommend you even join my basic course if this is the case. Although I encourage people to learn new skills to move to a different career, if your priority at the moment is getting a job, I believe that buying a new course on iOS development is not the right move. This is especially true for an advanced course like this one, that takes a long time to absorb. Your focus should be somewhere else. Fix your finances first, then come back. My courses will be here when you are ready.

The iOS Architect is RIGHT for you if…

  • You already have experience making iOS apps and want to take it to the next level.
  • You want to go deep into the advanced concepts behind the architecture of complex iOS apps, and you are looking for a complete system, instead of getting random techniques that you don’t know how to apply to your apps.
  • You are patient, deliberate and methodical. You know that advanced topics need to be understood and internalized with time and practice and are not learned overnight.
  • You want to know critical concepts, instead of mindlessly doing the same things again and again just because you don’t know any better.
  • You want to understand the big picture of a complex app in its entirety, not just read specific code pieces to do this or that task.

Although I already had a good grasp on programming and architecture in general, I found out the painful way that there is a lot specific to iOS development. It’s hard to prioritize and it’s easy to feel overwhelmed. Matteo’s course addresses all key aspects for a first-class, production-ready app in a direct and clear manner, demystifying buzzwords and always with a practical approach, clearly illustrated with examples. – Adrian Tineo

Frequently Asked Questions

How is The iOS Architect different from any other course on the market?

This is the only course that focuses on the complete architecture of an app and includes all the advanced concepts you need.

There are plenty of books and courses out there that focus on specific single topics. You can learn the ins and out of unit testing if you want, or some particular iOS pattern like MVVM. You can also find courses on specific iOS technologies like Core Data, courses that show you how to make many different types of apps, and courses on new hypes like reactive frameworks if you want.

But this is the only course that focuses on all the aspects of iOS development in a coherent system. My students confirmed that there is nothing else on the market like The iOS Architect.

How is The iOS Architect different from The Confident iOS Professional? Which one should I get?

The Confident iOS Professional is my entry-level course to iOS development. It already covers architectural concepts that other courses don’t include, but given its nature, it cannot go deep into any of them.

The iOS Architect comes naturally after The Confident iOS Professional and explores all the concepts in more depth. The two courses do not overlap though. The iOS Architect assumes you are familiar with the basic concepts covered in The Confident iOS Professional and does not repeat any of them. If you are not familiar with those basic ideas, you won’t be able to follow The iOS Architect. In this case, I recommend joining The Confident iOS Professional first.

There seem to be a lot of theory in the course. Is there also some practice?

Absolutely. The iOS Architect follows my usual approach: understanding the theory first and then applying the concepts to real-world code.

The first lessons are slightly tilted on the theoretical side, to introduce the various ideas. As the course progresses, there are more and more hands-on lessons that show you the creation of a complete app.

The Xcode project grows in size pretty soon, including model types and business logic, various model controllers for networking and caching, and view controllers with complex table views and interaction code. Plus, unit testing at every level.

Do you cover MVVM and VIPER design patterns?

Yes, but I will include them differently other material you find online. I will be expanding different concepts and techniques that you cannot find anywhere else.

Do you cover functional reactive programming frameworks like RxSwift, ReactiveSwift or ReactiveCocoa?

No. If you have been following my material for a while, you know I am opposed to these frameworks. They might allow you to write some code fast, but they work too much like magic, introduce too much hidden complexity that creates problems later and restrict your architectural choices. For this reason, I recommend against them.

This said, if you chose to use them anyway, everything I cover in this course could go along with those frameworks. I focus on software principles and patterns that have existed for decades in many different software development fields, and you can integrate with every approach you take.

Will The iOS Architect help me if I am just a beginner in iOS development and I don’t understand iOS architecture well?

Maybe. If you miss the underlying architectural concepts, this course will be too advanced for you, and I recommend that you join The Confident iOS Professional first.

But if you already have experience making iOS apps and want to take your understanding to the next level, then this course is for you. And if you find that this material is above your head, you can always join my other course to fill the gaps.

Do I have to commit time every day to follow the course?

No, the program is self-paced so that you can follow it at your speed. How much time you commit to the course is entirely your choice.

I divided the videos into manageable sizes and text lessons into sections that are always to the point. This allows you to move through the material in discrete steps. Regardless of your speed, even picking one concept at a time can have a significant impact on how you write your apps.

The app in the examples looks different from the one I am working on. Will The iOS Architect help me with the specific project I am working on?

Most certainly yes. Every concept in the course is presented both in general theory and in practical examples which show you how to each idea in code.

Regardless of the nature of the app which we will create in the course, these are concepts that you should use in practically every type of app you work on. Whether you are working on a networked app, on a social network app or a business tool, the architectural concepts in this course always apply to your code.

I can’t think of any app where you won’t need these fundamental ideas besides games. And even in that case, most concepts you will find in this course are always valid.

I already have some years of experience in iOS development. Will I benefit from this course?

Likely. Many of these concepts took me years of research and practice to master. Even if you have worked on iOS for some time, you might not have seen them applied in a real app.

The people you work with have a massive impact on the number of ideas you are exposed to. There is, of course, the chance that you are advanced enough and you know most of the concepts already, and that is why I have a 60 days money back guarantee.

Since you have been on my mailing list for so long,  I think that there is a good chance you will learn new concepts.

I am afraid that this course might be too basic. Is it really an advanced course?

Yes, it is. I poured into this program all the knowledge I gathered through years of experience and research. I worked with many developers with different backgrounds and studied other languages too. I also personally tested and expanded each concept before exposing it in each lesson.

Rest assured that you must be a pretty advanced developer to not find any new idea in this course. If that will be the case, I have a 60 days money back guarantee, so you might as well give it a try and see for yourself.

Do I need a professional Mac or a laptop for this course?

No. The concepts exposed in this course are about how to write code correctly and architecting apps accurately. They are advanced on a conceptual level, not computationally complex. Any Mac computer that runs the latest version of Xcode is enough.

How is an iOS Architect role different from a lead / uber / rock star / ninja developer?

Role titles change a lot depending on the company you work for. I called the course The iOS Architect to be crystal clear about the topics covered in the course.

Some companies use “architect” as a job title, but nowadays there is a strange fashion of using cool-sounding but meaningless terms like rock star or ninja. The iOS Architect is a course for any role past junior or intermediate levels, whatever the name might be.

It’s for people who already have some experience in iOS development and want to have a higher role. Senior developer or team lead might be two of the possible titles for these positions. It’s also for people who wish to contribute more to the decisions taken in their team or company, regardless of their status.

Can I find this information in cheaper courses on the market?

No, at least, to my knowledge, not at this level of depth and organized in a single system.

If you are looking for cheaper solutions, you can sometimes find good material on specific topics. My experience though is that they usually leave out many real-life development problems and practices. Moreover, you have to spend a lot of time putting all the concepts together all by yourself.

Think about how much your time is worth when considering pricing. I believe my course has a higher return on investment than other material on the market. Of course, you might disagree, and that’s why I offer a 60 days money back guarantee.

I am just interested in a specific module. Can I buy only part of the course?

No. I structured the course in a way where every concept relies on other ones. There are constant references to ideas explained in previous lessons. Taken in isolation, a lot of material does not make sense or misses essential concepts.

Does the course cover SwiftUI or UIKit?

Don’t rush to learn these new frameworks yet. If you work as a developer, freelancer or ship apps on your own, for a few years you will need to support older iOS versions, where SwiftUI and Combine are not available. The iOS ecosystem will not change overnight. You will need the concepts I explain in this course for years to come.

There will come a moment, though, when the community at large will transition to SwiftUI. That will require some restructuring in this course. The concepts will stay mostly the same, but I will need to rearrange some lessons. It’s still too early to say how that will look like.

While I cannot promise to deliver a new, overhauled course completely free of charge, I will try my best to do that. If that will not be possible, I promise that I will offer it to my existing students at a fraction of the cost.

But to be honest, that would be a poor use of your time. Once you know the fundamental architectural principles of iOS apps, you won’t need to follow an entire course again. Since most ideas will stay the same, you will only need to update your knowledge.

What I can guarantee you is that I will soon add new material to help you transition to SwiftUI and Combine when the time comes, completely free of charge.

I will also show you how to integrate old code with the new one during the transition, a skill that will be in high demand for the coming years.

Compare this to the cheap eBooks and courses you find online, which will be just updated to use SwiftUI and Combine, leaving to you the hard work of transitioning to these new technologies.

The iOS Architect is a course that stands out on its own. The material is in-depth without feeling too heavy and overwhelming. It’s the only course I’ve come across that not only deals with the tech side of iOS development, but also the psychological and emotional sides of being a developer in a team environment. – Frank Manno

Yes, you have other options to learn these concepts

I already told you that The iOS Architect includes a complete system that covers all the advanced concepts you need and shows you their relationship.

This said I am not going to lie and tell you that you can learn these concepts only here. You can find them in other places too.

It took me a degree in computer science and 10+ year of experience in different companies and projects to put together all this information into a coherent system. If you really want, you can do the same too.

You have other options too. Maybe you even tried some of them already:

Attend iOS Bootcamps, retreats or corporate trainings

These usually cost between $3.000 to $20.000. Some can be excellent, but I have met many people that attended them and did not even learn the concepts I cover in my basic course, let alone any of the material in The iOS Architect.

Get the required experience on the field

You can learn a lot working as an iOS developer in some companies and interacting with other developers. If you join a top company, you can learn a lot and get paid for it! Unfortunately, at most jobs, you might be the only iOS developer with no one to learn from, or you might work in a company where most of the developers in the team just want to do their job and go home. You might be the one that knows more than others. You might even face resistance from colleagues when you want to try new approaches.

Learn all the concepts from books, online articles and open source projects

I did a lot of this myself. I follow all the iOS newsletters out there, I watch countless videos from Apple and other conferences, and I read many specific books on advanced Swift, unit testing, advanced networking, etc. That is why it took me 10+ years to put together all this knowledge. You can do that too, but why would you?

Do nothing

Yes, you have this choice too. You can just keep doing your job in the way you know it, making the same mistakes again and fixing problem after problem. How much time can you go on like that?

An unbeatable guarantee

Try The iOS Architect for a full 60 days, 100% risk-free

Try the entire The iOS Architect. If it doesn’t help you build advanced iOS apps, I insist that you get 100% of your money back.

I’ll even eat the credit-card processing fees.

Let me tell you why I offer this unbeatable guarantee.

I tried many other books and courses, watched countless talks and nobody ever covered these concepts. I had to pick all the ideas apart to build a coherent system to use to make iOS apps.

Many times I bought “advanced” books on specific topics like unit testing or networking only to be disappointed. All they do is build a sample app, show you a collection of tactics and then leave you to figure out the rest all by yourself.

And none of these ever took the architecture of a real app into consideration. Most of these books just focus on beginners or give simple solutions that you cannot apply to your case. I am honestly tired of these books. Software development does not happen with copy and paste. You need to understand all the implications of what you do to decide what is the best solution for your app.

It took me months of work to organize and put together this material in a coherent system that progresses logically and allows you to build concepts upon one another.

I know this material works. It includes everything I have learned and used in 10+ years of iOS development. I have discussed these techniques with many other iOS developers. And I tested the course with different students, and they got massive value.

That’s why I guarantee The iOS Architect.

It’s really simple. Take the course and see for yourself. If it does not work, I want you to email me, prove that you did the work and I will refund you 100% of your money.

This guarantee extends for a full 60 days after you join, which is more than enough to go through the ENTIRE course.

If you don’t love it, just email me at ANY TIME during the first 60 days and show me you’re applying the material, but it does not work for you. I’ll refund 100% of your price.

By the way, I ask you to show me you’ve applied the concepts of the course because I know how powerful they can be when used.

I have no intention of keeping your money if you’re dissatisfied, but I insist that you commit to taking action if you want the results from this program. Just reading a couple of lessons and doing the same things you were doing before is not going to cut it.

I’ve spent years to learn these concepts and months developing this material, and I’d like to share it with you if you’re ready to build more complex, maintainable, testable and scalable iOS apps.

I’ve already applied what I’ve learned in this course into client projects I’ve been involved with, including one of Canada’s top financial institutions. I’ve been able to write better, more maintainable code because of what I’ve learned. A true end-to-end course in a league of its own, I highly recommend it to anyone looking to take their development career to the next level. – Frank Manno

Yes, I want lifetime access to

12 Monthly Payments of $99

(That’s only $3.25 per day)

Get Instant Access

Pay now in full and save $191


If you have any questions or concerns about the course, email me. I am happy to help. Team/bulk subscriptions are also available.

Learning how to make complex iOS apps is not an accident.

You can get to the point where you can confidently put together a simple app and ship it to the App Store. And that is not even an easy task by itself. It’s an accomplishment that many fail to reach.

But that gets you only that far.

When a project grows in complexity, it becomes less and less evident how you should organize your code. You keep adding code to existing classes because it seems natural until they become unmanageable and untestable monsters.

And that happens again and again, in every app you make.

The kind of experience you need to make scalable iOS apps and write reliable code takes time to accumulate. You need to spend significant time working on big projects with experienced developers from which you can learn.

But those are rare and hard to find. If you want to become one yourself, what paths have you left?

Specific books can help. I read tons of them and learned valuable lessons. But those were still scattered across many different books that took me ages to read. Not counting the books that had no useful insight at all.

And I still had to put all these ideas together myself.

You can do that too. If you are the kind of person that enjoys the painstaking process of putting together all the pieces of the puzzle, go for it. You will have enough to keep yourself busy for a long time.

Take a shortcut to mastery

I don’t know you, but I prefer to get to my goal as soon as I can. I don’t care about piecing the information together all by myself.

I want to make apps, not discover what others have already found. I didn’t have a choice though. I had to go through the 10+ years of experience to build the knowledge I have now.

But you have a choice.

You can get there in a fraction of the time that cost me. Spending only a few hours per week you can start right now writing better and better code in your apps.

In a couple of months, you can get insights that it took me years to discover.

Where will this lead you in a few years?

You can get much further in your career, ship more sophisticated apps to the App Store and get more satisfaction from the work you produce. I don’t know what impact this can have on your life, but you do.

I have learned three critical principles from my virtual mentor Ramit Sethi that allowed me to propel my life forward faster than I could ever do alone. I give him all the credit for teaching me these lessons, but I also know I was the one who took action and implemented them.

You can do that too.

Do what other developers won’t do

Most developers follow a few tutorials, copy and paste code from Stack Overflow and spend their whole career making the same mistakes again and again. I’ve grown tired of fixing messed up architectures created by agencies or other freelancers.

That approach works for one shot apps that are left to rot in the App Store after publishing. Apple brags about the 2+ million apps in the App Store, but we know that most of them are garbage.

For better or for worse, these low-quality developers won’t go away. There is always demand for cheap and quick app development.

Is that the kind of work you want to produce?

You can surpass these people by putting your focus and effort in learning the high-level concepts of complex iOS architectures.

That is harder than copying and pasting code from tutorials. But that’s good. Since most people won’t go past a low bar, doing otherwise will put you immediately in front of everybody else.

Give yourself every advantage

When I started making apps, I had to find all the information by myself. That led me to a problem: I kept the same mentality for a too long time.

When I got good enough to make apps by myself, I had enough knowledge to be dangerous. I released app after app that failed miserably in the App Store. When I later decided to become a freelancer, I almost went bankrupt before I learned how to run a business properly.

It’s only when I got serious and stopped trying to figure everything by myself that I jumped forward. Now I spend thousands of dollars in courses and coaching because I know that it gives me a tremendous advantage over everyone else.

It’s for that exact reason that I am here teaching you everything I learned.

Learn from the best

In every human endeavor, a few people get the most of the results. This is called Pareto Principle: 20% of the people get 80% of the rewards.

This is because these people had more experienced and trained more than others. They have seen more novel situations, and all this accumulated knowledge has a powerful compounding effect that puts them at the top.

That is why I now learn from the best in every field, even if I have to pay 100x the money I would spend on a few books.

If you want to make complex apps, you can buy, a book on S.O.L.I.D. principles, a book on unit testing, a book on functional programming and a book on advanced Swift techniques (for a start). Each of these books will only cost 10 to 30 bucks.

Or you could learn from someone who already read all those, worked on many complex projects for big companies and made many complex apps that were used by thousands of people.

Who would you rather learn from?

The coding principles have led me to write more concise, elegant, and significantly less buggy code. The architectural concepts have helped me know where to start when building and maintaining apps. I have adopted a pragmatic, effective, and less stressful approach to software testing that is able to catch many bugs that often sneak into production. My newfound confidence has strengthened my ability to give informed feedback in code reviews and confidently merge my colleague’s pull requests. I am able to better express my opinions and back them up with solid examples. – Nicholas Lash

Jump ahead instead of trying random tactics that give you no results

I believe that what I put together in this course will propel you forward in ways no other material on the market can. The few beta students I allowed in the course while I was creating it already told me so. I know this material is solid.

If you want to create apps with beautiful architectures that stand the test of time, you can get there much faster than you think. It’s not just about the money that can come from it. We all do it for ourselves, to take pride and satisfaction in the code we create.

It’s time to make a decision.

The iOS Architect will close soon. When I close my courses, I often don’t re-open them for months. So if you want to make complex iOS app, you have to act now.

You can get already massive value from the course even at this uncompleted stage. My students already did. That is why I am offering it to you now, at a lower price.

I also protect you with a 60-day, money-back guarantee to make your decision completely risk-free.

A year from now, you’ll be a year older. What are you going to do?

Yes, I want lifetime access to

12 Monthly Payments of $99

(That’s only $3.25 per day)

Get Instant Access

Pay now in full and save $191


If you have any questions or concerns about the course, email me. I am happy to help. Team/bulk subscriptions are also available.