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.

Including:

  • 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 decade, I created iOS apps for big companies and published my own apps in the App Store for iOS, iPadOS, and macOS.

Today I teach iOS development to more than 18.000 readers every month, 11.000+ subscribers, and hundreds of students who joined my courses on iOS development.

In the past years, I have built complex iOS apps for large clients, working both in big teams and as the only developer, and asked high rates for my work.

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 software architecture, design patterns, MVC/MVVM/VIPER, the SOLID principles, and all the other buzzwords you read nowadays on iOS development blogs.

Back then, I had to learn iOS development all by myself. It was the beginning of iOS, and there was no excellent course to study.

After months 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 first, it went smoothly. I completed my first tasks and gained confidence in my skills.

But then I hit a roadblock.

They asked me to introduce unit testing in the project. I started reading all the material I could find online about unit testing in iOS. But I could not figure out a way to test the actual code of a real app.

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

The reality is that most online articles are geared towards beginners and cover only basic examples. That can be great when you are starting, but excellent architecture is not something you can copy from a tutorial.

As it turned out, that was not the only time I had such a problem.

Two years later, while working at an agency where I was building an app for a big investment bank in Amsterdam with strict requirements.

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

At that point in my career, I had become complacent. I thought I knew everything there was to know about iOS development. I felt I produced well-written code, and the reviewers would be impressed by my skills.

The verdict was not what I expected.

Their report was ruthless:

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

That stung. Still, my arrogance prevented me from learning from that feedback. I thought the reviewers were not good enough to realize how perfect my code was. And who needs tests anyway? Nobody does that in iOS.

Luckily, that blindness did not last long.

Not much later, 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 good code and sound architecture.

Knowing how to create iOS apps is not enough

If you don’t adopt the proper practices, you will end with unmaintainable code and technical debt that will only create problems later.

Unfortunately, that realization only got me so far.

Architecture is a difficult concept. You can’t copy and paste it from a Stack Overflow answer. Nevertheless, it is necessary in today’s iOS development world. Realizing this is important but does not show you how to move forward.

iOS apps are getting bigger and more complex. Teams are growing, and development costs are increasing. Maintaining an existing app and adding features is more important than releasing its first version in the App Store. 

Good architecture is critical.

When I was freelancing, clients often hired me to fix projects with too many issues. And they were always caused by botched architecture and spaghetti code. I saw companies that had to throw away all the code in a project and rewrite their entire app from scratch.

Experience showed me that too many iOS developers don’t know the best practices to build robust iOS architectures that stand the test of time

Many books and courses out there only talk about superficial concepts with small code samples. They rarely speak about best coding practices, intricate patterns, or test coverage.

Most authors believe that there is no audience for advanced stuff. I beg to differ.

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. For me, 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, like Lisp or Haskell, only to understand the core ideas behind the buzzwords of the moment.

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.

Now, I can also see other things.

Remember the project I could not write unit tests for? That was only partly my fault. I now realize that its code was almost impossible to test. At the time, I had no idea, but now I know how I could refactor it to make it testable.

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 the best course of action with other developers.

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 all 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 and is extensively used by SwiftUI. Others, instead, push functional programming. Aren’t these two contradictory?

What about the SOLID principles? You hear they are essential but aren’t they about object-oriented programming? How do they fit in Swift apps?

And where does unit testing fit in all this mess?

The reality is that these concepts are all useful!

So how do you use them all correctly in your apps?

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

As such, they don’t 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.

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 implementing a real app.

Many of my students are always surprised at 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 all 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

If you use inferior quality materials when you build a house, you can use the best tools and follow the most fantastic project, but your house will still collapse.

Building iOS apps is the same. You have to pay attention to the whole app architecture and the small pieces of code in your methods.

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 changing 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 nonetheless.

They apply to any code you write and any design patterns you use. They are a great tool to make sure that your code 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 actual benefits.

Insight #3

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

The ideas behind programming paradigms, development principles, and design patterns are all critical. Still, thinking about them all the time can be overwhelming.

Even when you know these concepts well, it’s impossible to consider them all simultaneously 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 not seem like a very sophisticated pattern. In fact, if you use its most common version, you will soon run into problems, like massive SwiftUI views that contain too much code.

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

But it does not stop there.

The different layers in MVC communicate with each other through several connections. But if you investigate the nature of these connections, you realize that many of them are “weak” mechanisms, like delegation, callbacks, and published properties.

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

If you look at the SOLID principles of object-oriented programming, for example, they encourage 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 also with unit testing.

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

But the MVC pattern comes to the rescue again. Its tree structure also dictates the types of references you can have between each layer. 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 SOLID principles;
  • writing testable code;
  • easier memory management.

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

If instead, you think about software practices individually, you will 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 that.

You can also find more general books on 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 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

Introducing…

The only advanced course covering the architectural concepts for real-world iOS apps and the techniques to write code that is easy to read, test, and maintain.

I put together everything I have learned in the last 10+ years working as an iOS developer in a single unique system.

  • Become a quality developer that can build complex and scalable apps. Get the real-world techniques and practices to create a beautiful architecture with well-organized code that is easier to read and navigate.
  • Get the confidence to discuss best practices with your colleagues. Grow to the next level in your professional career and get the experience to get hired by great companies, lead a project, and become a senior developer.
  • Get out of tutorial hell. Go past the beginner stage and leave aside courses for entry-level developers. Watch how real developers work and think, and learn how they design their elegant code.
  • Stop feeling complacent and go past what you already know. Get new perspectives on the concept you are already familiar with and fill holes in your knowledge you didn’t even know existed.
  • Follow a complete system that goes deeper and shows you both the theory and the real-world practice to move your development forward with tremendous strides.

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

How The iOS Architect works

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

The course is divided into modules covering a specific piece of the whole system, going from techniques and programming paradigms to clean code and correctness, architectural patterns, complex networking, unit testing, and much more.

The old version of the course already included 10h+ and several hands-on lessons that go in-depth into the practice of building scalable apps. The new SwiftUI version will match and surpass that, including all the latest advanced features of Swift and SwiftUI. It already contains 3h+ of videos, plus hands-on lessons with new techniques that were not present in the UIKit version.

Inside The iOS Architect system

The course approach is first to cover the theory behind every concept in-depth. But also expect many practical examples. The hands-on lessons go over creating a networked app with a complex architecture and discuss all the problems and the edge cases of real-world app development.

Module 1

Laying Solid Foundations for an iOS App Before Writing any Code

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) – The Psychology of Software Development

Dealing with Colleagues, Bosses, and Clients

Lesson 1.4 – Design Tools for Developers

Using Wireframes and Mockups to Cut Down Development Time

Lesson 1.5 – Wireframes and Mockups

How to produce high-quality app design with only a few basic design principles

  • How following the 5 phases of app development, you can create well-designed and well-architected apps that you will be proud and eager to maintain. You will also get the confidence to express your opinion about best practices with your team members and colleagues.
  • Why quick but poor solutions like singletons create nasty technical debt that spreads like cancer in your app. Shortcuts gain you a bit of time now but cause massive waste of time in the future and can cause a project to fail.
  • How to confidently estimate software projects and how to deal with colleagues, bosses, or clients that might disagree with you without fearing they will think you are not good enough. It is essential for your career to be able to provide estimates even when you can’t predict the future without feeling the pressure of looking bad.
  • Wireframes and mockups, the simple design tools that will prevent you from writing a lot of code only to throw it away. With these, you will be excited to create great designs and great software.
  • Deciding the right amount of features for a minimum viable product based on your customers’ real needs. Many developers take months or years to create apps that no one needs.
  • How to create a requirement specification by carefully considering the ramifications of each decision you make. Getting this wrong might mean wasting time on complex features that no one needs or having to throw away a lot of code later.
  • The few fundamental guidelines that will help you create better designs than most App Store apps and the tools I use to do it quickly and effectively. Use these concepts, and you will consistently produce designs you are satisfied with, avoiding analysis paralysis and constant revisions.

Module 2

The Guiding Principles of iOS Software Development

Lesson 2.1 – Paradigms, Principles, and Patterns

How to Write Correct, Well-Structured and Maintainable Code

Lesson 2.2 – Programming Paradigms in Swift

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

Lesson 2.3 – The iOS App Blueprint

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

Lesson 2.4 (hands-on) – Creating an App’s model layer

How to Define Model types Following External Constraints

  • 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.
  • 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.
  • 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 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 the imperative programming model is at the core of any code you write in Swift (regardless of any popular topics, this is a part of Swift you cannot ignore).

Module 3

Writing Clean Swift Code to Prevent Human Mistakes and Minimize Bugs

Lesson 3.1 – You Are Not as Clever as You Think

Why Clean Code is your Best Tool Against Bugs in your Apps

Lesson 3.2 – Spacing, Comments, and Naming

Making Each Line in your Code More Readable

Lesson 3.3 – Grouping Code Logically

How to Organize Code into Smaller, More Cohesive Structures

Lesson 3.4 (hands-on) – Adding Business Logic

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

Lesson 3.5 (hands-on) – Automatic Code Formatting

Using the swift-format Linter to Enforce Style Guidelines

  • How to increase your code’s readability by giving proper names to variables, functions, types, magic values, and workhorse lines. Swift idioms can be elegant and concise, but you will feel like a dumb kid in Swift land if you don’t know them.
  • 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.
  • The importance of Swift guards and why you should use them in your code if you don’t do so already. Some developers reject them as a mere preference, but they were introduced in Swift to avoid the “pyramid of doom” problem.
  • How to write helpful code comments and the ones you should never write. Many developers pollute their code with misleading statements that do more harm than good.
  • How to keep code organized using Swift extensions for protocol conformance. This is more than a mere stylistic choice and has concrete advantages.

Module 4

Formal Techniques to Guarantee Code Correctness

Lesson 4.1 – Keeping State Consistent

Avoiding Ambiguities and Enforcing Dependencies in Code

Lesson 4.2 – Fatal Errors, Preconditions and Assertions

Making Code Safer by Catching Programming Mistakes

Lesson 4.3 (hands-on) – Semantic Consistency

Creating Types to Make Code Easier to Manage and Reuse

Lesson 4.4 – Generics

Making Functions more Reusable by Loosening Restrictions on Types

Lesson 4.5 – Leveraging the Type System

Taking Advantage of Swift’s Strong Typing to Make Mistakes Impossible

Lesson 4.6 (hands-on) – Safeguarding Code

Using Sum and Product Types to Remove Ambiguities and Prevent Inconsistent States

  • The difference between sum and product types, and when to use each. These combinations help you remove from your code states that should not be possible at all.
  • How to manipulate types using generics and phantom types so that the compiler can check if you make any mistakes. This is a powerful technique that allows you to make a class of errors impossible leveraging the type inference of the Swift compiler.
  • Using computed properties and property observers to guarantee consistency in the state of your types (and avoid weird bugs).
  • How to remove duplicate empty states to write more explicit and less error-prone code. This technique allows you to remove optionals by making their meaning more explicit and preventing ambiguity.
  • Assertions and fatal errors: detecting programming mistakes and choosing the correct function to use in each case.
  • How to use generics to make the Swift type system infer types for us, making our code more fluent. The powerful type inference of the Swift compiler allows us to write code that is expressive, concise, and safe.
  • Safeguarding stored properties through custom types and avoiding accidental assignments (solutions like this one are very simple yet powerful).

Module 5

A Strategic Approach to Unit Testing and Refactoring

Lesson 5.1 – Understanding Unit Testing

The Benefits of Unit Tests, How They Work, and How to Set Them up Correctly

Lesson 5.2 – Unit Testing Methodologies

Test-Driven Development and the Different Schools of Thought on how to Write Unit Tests

Lesson 5.3 (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

Lesson 5.4 – Pareto Unit Testing

How to Avoid Writing Useless Tests, and the Psychological Burden of TDD

Lesson 5.5 (hands-on) – Identifying the Right Tests for your App

Test Reuse, Code Coverage, and When to Write Tests for a Unit

Lesson 5.6 (hands-on) – Testing Large Codebases

Breaking a Project into Testable Modules using Swift Packages

Lesson 5.7 (hands-on) – Refactoring Bad Code

How to Fix Bad Practices Incrementally without Breaking your Entire Codebase

  • The red-green-refactor process of test-driven development that dictates what tests to write, their order, and how to write code that is constantly verified. This is the fundamental idea behind the Detroit school of TDD but has serious drawbacks.
  • How unit testing relates to the different layers of the MVC pattern in a real app and which parts are easiest to test. This will help you write the tests that will give you the most benefits with the least time investment.
  • 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 for your app without worrying about the trivial ones. No more feeling like a slacker because you don’t follow TDD.
  • How to split an Xcode project into independent modules using Swift Packages. This technique is used in many large companies to speed up development, manage code ownership, and create continuous integration workflows.
  • 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.
  • The problems you will experience when refactoring large codebases made of spaghetti code. When code follows poor practices, a small change can spiral into too many errors that can make refactoring feel like a lost cause.
  • How to use firebreak types to avoid breaking existing code and proceed with your refactoring incrementally. This technique allows you to keep shipping updates and respect deadlines even if your refactoring spans over a long period.

Limited offer: get The iOS Architect at a lower price while in development

This kind of material is very complicated to put together, so I am still completing it. But as I have learned from Jay Abraham, I cannot punish my students because of my limited resources. I must share what I know as soon as I can.

Since my current students already got a ton of value from the existing material, I am confident that others will as well. So I decided to open the course at a special price before I finish it. I have already raised the price of this course once, and I’m going to do it again when it is complete.

Bonus: Get the full UIKit curriculum free of charge

SwiftUI is a new framework and it’s only available on the latest versions of iOS. Many companies have long-standing projects built with UIKit and customers with old devices, so you’ll also need to be proficient in UIKit for years to come.

For these reasons, I am including the full UIKit curriculum at no extra charge.

That means you get two courses in one:

  • The UIKit course, which is complete and, in the past years, helped hundreds of my students jump forward in their career, and, in one case, even triple their salary.
  • The SwiftUI course, to master the new technologies that will be at the core of iOS development for the next decade.

The iOS Architect also includes…

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

Along with the theoretical lessons, I apply each concept to the step-by-step implementation of a complex, real-world app that deals with 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 necessary details.

You will see what decisions and considerations 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 an actual 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 entire git history to explore the evolution of the app’s code

The material includes the complete 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 detailing the whole evolution of the app. That allows you to compare each step to the previous ones and see which code changed and how.

Each commit in the repository has a tag with a lesson number to help you quickly go back to the proper lesson and refresh the relevant concepts right where they were introduced.

Closed-captioned videos with downloadable slides and transcripts

Each theoretical video lesson has closed captions and speed controls to help you follow the material at your own pace without missing anything. Video lessons also have complete downloadable slide decks, transcripts, and code snippets to quickly go back to the salient parts without sifting 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.

Lifetime access

he 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 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 each lesson to refresh your knowledge and 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 SwiftUI’s syntax, standard views and modifiers, SwiftUI’s property wrappers and data flow, and basic design patterns like MVC. You also need a foundational understanding of storing data on a device, making network calls, and asynchronous callbacks. You can find these in my entry-level course, The Confident iOS Professional.
  • 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 writing actual 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. A course this complex takes time and effort to absorb. Although some students have incredible results in a short time, I cannot guarantee that. 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 systematic. 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 repeatedly 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 create different user interfaces, and courses on the new trends of the moment like Combine.

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.

Why? Because such material is extremely hard to produce and keep up to date. I seem to be the only one crazy enough to do so.

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 in 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.

I am a student of The Confident iOS Professional. Do I get any credit on the final price of The iOS Architect?

Yes. You can take the total price of The Confident iOS Professional ($499) from the final price of The iOS Architect. You will find a link below the payment button to log in and reclaim your discount.

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

Absolutely. The iOS Architect follows my usual approach: understanding the theory first and then applying the concept 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 quickly, including model types and business logic, various controllers for networking and caching and views complex interaction. Plus, unit testing at every level. 

Do you cover the MVVM and VIPER design patterns?

Yes, but what I cover is significantly different from other material you find online. I  expand concepts and techniques that you cannot find anywhere else.

Do you cover functional reactive programming frameworks like Combine or RxSwift?

At the moment, I do not plan to cover any FRP framework. Despite what some developers claim, such frameworks are just tools. Like any tool, you can decide to use them or leave them aside. They are not necessary.

That said, if you chose to use them anyway, everything I cover in this course remains true. I focus on software principles and patterns that have existed for decades in many fields and languages. You can integrate these with every approach you take.

Will The iOS Architect help me if I am just a beginner in iOS development and 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 follow The Confident iOS Professional first.

But if you already have experience making iOS apps and want to take your understanding to the next level, this course is for you. And if you find that this material is above your head, you can always follow 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. In fact, that’s what I recommend. Biting off more than you can chew can be discouraging.

Even if you proceed slowly, picking one concept at a time can have a significant and immediate 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 my specific project?

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 example app you will find in the course, the concepts I cover will apply to practically every type of app you work on. Whether you are working on a networked app, a social network app, or a business tool, the architectural concepts in this course always apply to your code. In fact, I use them in every single app I make.

I can’t think of any app where you won’t need these fundamental ideas. The only exception might be games, but 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?

That’s 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.

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. Finally, I developed some unique approaches you will find only here.

Rest assured that you must be a pretty advanced developer not to 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 architect 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 I cover in it.

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 their 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 the concepts together all by yourself. Even without considering this massive time investment, if you were to add together the prices of alternative books and courses to learn everything I cover in this course, their price would likely be higher.

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. And if you prefer to pay in smaller amounts instead of a lump sum, I offer monthly payment plans.

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. Throughout the course, 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?

Both. Since the two frameworks require different mental models, The iOS Architect offers two independent curricula.

The course’s primary material is based on SwiftUI, and I will keep it up to date with the latest updates from Apple. I am also offering the old UIKit version of the course completely free of charge, so you can use it if you need to work on apps that use UIKit.

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.

That said, I will not lie and tell you that you can learn these concepts only here. You can find them in other places, too (excluding the unique techniques I developed myself).

Here is what it took me to put together all this information into a coherent system:

  • A bachelor’s degree in computer science and master’s degree in computational logic;
  • 10+ year of experience in different programming languages and projects, working for several companies and teams, both as an employee and as a freelancer;
  • Years of research with online articles, books, Apple’s documentation, and WWDC videos;
  • Thousands of hours of experimentation with code both in my published apps and during the creation of this course.

If you want, you can do the same too.

You have other options as well. 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 introductory course, let alone any of the material in The iOS Architect.

Get the required experience on the job

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 get experience 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 also 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 continuously follow all the iOS newsletters out there, watch countless videos from Apple and other conferences, and read several books on advanced Swift, unit testing, advanced networking, etc. I even studied functional languages like Lisp, Clojure, and Haskell. 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 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, better than 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. On top of that, I will buy you any book or course of your choice from my competitors, up to $200 in value.

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 make iOS apps.

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

And none of these ever considered the architecture of a real app. Most of these books focus on beginners or give simple solutions that you cannot apply to your work. 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 the best solution for your app.

It took me years 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. And I know there is nothing else like it on the market.

That’s why I more than guarantee The iOS Architect.

Are there any catches to my offer? Not at all, but there is one simple stipulation. I’m sure you’ll agree that it’s quite reasonable.

I know without a shadow of a doubt from my students the enormous potential my course produces and how it allows you to move forward in massive strides. One of my students even tripled his salary two months after joining.

What I don’t know is whether you’ll study the material as I structured it and apply the techniques I explain to your work. So, I ask only that you agree to follow through and document you did so.

If you want to join the course just because you are curious, coast along, check lessons at random or even leave the course aside to gather dust, that is your prerogative. Your time and money are yours to dispose of as you please. But I cannot take responsibility for your inaction.

Take the course and see for yourself. If it does not work, I want you to email me and prove that you made a good-faith attempt to follow the course. I will refund you 100% of your money, and I will buy you one book or course of your choice from one of my competitors, up to $200 in value.

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, 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.

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 will not cut it.

I’ve spent years learning these concepts and more years researching and creating this unique 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 $149

(That’s only $4.9 per day. Sales taxes may apply depending on your location)

Get Instant Access

Pay now in full and save $289

For students of The Confident iOS Professional

Claim your discount now (worth $500)

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

support@purecreek.com

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. 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 helpful 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. Unfortunately, I didn’t have such a choice. I wish I had this course when I started. Instead, I had to go through 10+ years of experience and research to build the knowledge I have now.

But now, 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 few months, you can get insights that it took me years to discover. A student of mine tripled his salary two months after joining the course.

Where will this lead you in a few years?

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

I have learned three critical principles from my mentors that allowed me to propel my life forward faster than I could ever do alone. I give them 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 projects 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 a 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 into 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 too long.

When I got good enough to make apps, 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 every year in courses and coaching because 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, for starters, a book on SOLID principles, a book on unit testing, a book on functional programming, and a book on advanced Swift techniques. Each of these books will only cost you 10 to 30 bucks.

Or you could learn from someone who already read all those books and many others, worked on complex projects for big companies, and made several complex apps that are, to this day, 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 students that joined this course already told me so. I know this material is solid.

If you want to create apps with a beautiful architecture that stands 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 apps, you have to act now.

You can already get 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 $149

(That’s only $4.9 per day. Sales taxes may apply depending on your location)

Get Instant Access

Pay now in full and save $289

For students of The Confident iOS Professional

Claim your discount now (worth $500)

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

support@purecreek.com

Disclosure