Get the best practices professional iOS developers use to create well-structured SwiftUI apps ready for the App Store
Stop copying other people’s code and feeling like you don’t know anything. Get the definitive roadmap with all the essential concepts that will give you a strong mental model of what makes a complete SwiftUI app
“I am really glad that I found your material. In other resources, I get bits and pieces, but in your courses, I get the fuller picture. It almost feels like I’m cheating when I see other developers struggle with fundamental concepts.” – Adrian Tineo
“I did this course for UIKit in the past and now doing again to improve my SwiftUI skills. The unique way you explain the integration of all parts considering the new concepts introduced by SwiftUI is worth it and is better than any other course I’ve done about it, even Apple’s.” – Marcos Rebouças
“I think what you do is awesome! I love the attitude of building a well-structured architecture application in such a way that maintaining it in the long run becomes a no brainer. You are very much correct stating that you cannot find any other online course that teaches you this. They all give examples of how to do this or how to do that in Swift but none of them is about the whole picture. Great job! I tell you this as an experienced programmer (Since 2005)” – Yariv K.
Thanks to SwiftUI, building apps from scratch has never been easier.
However, once you learn the basics, it is frustrating to address more complicated concepts. Anything more complex than basic navigation feels difficult in SwiftUI.
Tell me if you recognize this endless cycle.
You read more articles and buy ebooks, but programming is so huge that when you’re just starting, it feels overwhelming. So you just type whatever code the teacher shows you without understanding what it really means.
Sometimes, you feel like you understand a piece of code but when you try to create your own apps, you are lost.
That’s when you feel helpless and want to quit. No matter how much you learn, you always feel like you don’t know enough.
Maybe the following day, you come back with full motivation, so you restart the grind of reading forums and watching YouTube videos.
But 80% of what you find focuses on the same basic syntax and makes you build yet another to-do app. The remaining 20% is too advanced, leaving little for a beginner who has never worked anywhere.
So you work on personal projects like everyone suggests and experiment with different solutions, but you don’t feel like you’re making progress.
I understand how you feel. My first app took me two years to finish, and I often wondered if the popular apps in the App Store were created the same way. Even after completing it, I still suspected there was a better way to do things.
Hi, I am Matteo Manferdini.
I have worked as a professional software developer for almost 20 years and have developed for iOS since the first SDK was released in 2008.
I was first an employee, then a freelance developer working for big clients. In the meantime, I published several apps on the App Store.
Since 2015, I have taught hundreds of students software design principles and iOS development best practices.
I worked as a freelancer for years and discovered something surprising: many developers, even at famous companies, know very little about software development.
This presents a golden opportunity for those who know how to write clean, concise code. They can stand out from the crowd and gain an advantage over everyone else.
I have seen many projects with code that is so poorly written that nobody wants to touch it. I once had to rescue a terribly late project, which was a complete nightmare.
My client had worked on an app for another company, but the code was ridden with bugs, and the deadline was fast approaching. So, they tasked me with fixing the bugs to make their customer happy.
Unfortunately, after inspecting the code, I realized the problem was not just “a few bugs.” The entire app architecture was messed up.
There was no organized structure, and the author did not understand how to build an iOS app correctly, making the code a “spaghetti” mess. It was hard to debug, and fixing one bug created two more.
In the end, the app had to be entirely rewritten from scratch. Their customer was upset, and my client spent all the budget to have someone else remake the app.
I’ve read countless stories of developers who become increasingly insecure as time passes. They feel hopeless looking at open-source code written by more experienced developers, wishing their projects were better organized.
Learning SwiftUI alone is not enough. Writing clean and well-organized code is essential, and you must learn software engineering principles and best practices.
“I’m excited to learn from you — you seem to have the battled-tested experience that my college professors lacked. I’m building an app right now, but the code structure is beginning to rot, and I had no idea where to start refactoring. I think that your course could be just what the doctor ordered!” – Nicholas Lash
Luckily, there is a light at the end of the tunnel. I know because I went through and came out on the other side.
When I started developing apps, I struggled to put the pieces together. Now, not only have I mastered the fundamental concepts, but I also have a strong mental model of how to structure any app.
I can open Xcode and know what I need to work on immediately. I can move in the right direction from the start and understand precisely where each piece of code should be placed.
Of course, not all the code I write is correct. That’s part of software development. However, as I develop an idea, I can recognize bad practices and immediately avoid costly mistakes.
I also don’t know everything. Nobody does, and do not believe those who pretend otherwise. Software development is a constant learning journey. But you can get a head start.
When I try something new, I have solid foundations to rely on. I can investigate new technologies and integrate them into my projects by following battle-tested best practices that tell me how to structure code I have never seen before.
You can do that too. Once you build your foundation on rock-solid principles, you can bring your ideas to life.
Imagine having the confidence to build any app you wish and always understand what you must do and how.
Imagine breaking down your tasks into smaller pieces and seeing the app’s structure unfold in your mind, knowing precisely what code you need to write and how it interacts with the rest of your app.
Frankly, I am not impressed by many online tutorials and even some courses. Most resources don’t give you the skills to create real-world apps.
They give you a few examples but leave out crucial information. They feel like the “How to draw an Owl” meme.
Some ebooks may show you how to code an entire app but fail to explain how the different concepts interact. They might even teach you something irrelevant you will never need.
When you try to apply what you’ve learned to a real-world project, you must piece together disjointed tutorials that often disagree. This is frustrating and inefficient, leaving you discouraged and unsure of your progress.
Is the material you are reading helping you achieve your goals?
Are you tired of sifting through online tutorials that give you a weak mental model of what makes a complete SwiftUI app?
Do you find yourself copying and pasting code without understanding the underlying concepts?
I don’t know you, but I don’t want to make clones. I always strive to understand the logic behind any iOS app.
However, most resources are written by programmers who do not fully grasp how complicated these concepts can be for less experienced developers.
That’s why I created a comprehensive online course that covers all the “must-haves” for any aspiring iOS developer, giving you a well-organized map of all the essential concepts.
Unlike other resources, which leave you to figure things out on your own, this course follows a logical progression of concepts, building on what you learn at each step.
By the end, you will have a complete understanding of the underlying principles of iOS development in SwiftUI and the skills to create your own apps from scratch.
“This has been one of the best investments I’ve made.” – Natasha Nazari
Introducing…
SwiftUI Structural Foundations
The practical course to build a solid understanding of SwiftUI foundations, enabling you to create any iOS app with confidence.
SwiftUI Structural Foundations is an online course focusing on the best patterns and practices for structuring the code of fully featured iOS apps.
Here’s why this course is perfect for you:
- Say goodbye to the feeling of doing things wrong. Move past basic to-do list apps and copy-pasting the code of others, and start structuring your own apps with complex navigation, confident that you’re doing it the right way.
- Go beyond simple tutorials lacking the concepts you must apply to your SwiftUI code and stop wasting time with incomplete and insignificant examples.
- Gain insights into the design patterns used by successful apps in the App Store. Learn from the best practices used by professional developers at big companies and avoid common mistakes.
- Eliminate messy code that feels unnatural and is difficult to debug. Understand where each piece of code should go and learn how to write reusable and maintainable code.
- Get step-by-step instructions and efficient learning material, providing the necessary foundational concepts to work on your own apps. Discover where to begin, how to progress, and the essential knowledge you need to move forward.
If you’re searching for a comprehensive course that covers the skills distinguishing good developers from bad ones, SwiftUI Structural Foundations is the course you need.
The course modules show you the roadmap to structure large SwiftUI projects. You will develop the correct mental models and overcome any doubt when making architectural decisions for your app.
“Thank you for updating the content to SwiftUI. As always, you bring the discussion to a higher level that can’t be found easily in other materials. Your way of presenting iOS Development is what makes all your courses so valuable.” – Marcos R.
“I followed the course, and I loved it! Even though I already knew 95% of the content, I found the other 5% very educational and beneficial.” – Yariv K.
“Thoroughly enjoying this intense course – it’s hard work, but the rewards are very great!” – Jonathan B.
How SwiftUI Structural Foundations works
The course contains video lessons that explain how SwiftUI works and the best practices for structuring your code. I didn’t know these insights when I started my first iOS developer job, and they took me several years to grasp.
The course is structured into seven modules covering the fundamental aspects of SwiftUI. Since iOS development relies heavily on practical experience, each module includes hands-on lessons. These will assist you in constructing a complete app and demonstrate the process I follow for any app I develop.
The app showcases fully featured screens while the lessons delve into architectural concepts. They illustrate how code is organized in a real-world project and incorporate the most cutting-edge and up-to-date best practices.
Inside the SwiftUI Structural Foundations system
Module 1
Software Design Principles and Structural Patterns
Lesson 1.1 – Architecture
The fundamental concept nobody talks about
Lesson 1.2 – MVC and MVVM
The structural design patterns at the base of any iOS App
Lesson 1.3 – Wireframes and Mockups
Defining an app’s structure before you write a single line of code
Lesson 1.4 – Structures and Classes
The two fundamental abstractions of the Swift language
Lesson 1.5 – Domain Business Logic
How to apply the three fundamental principles of software design
What you’ll learn:
- Why it is better to start with design patterns and best practices when writing well-structured and testable apps rather than diving straight into writing code like in tutorials. Design patterns provide a detailed roadmap that you can use to build any app.
- The three fundamental architectural concepts that govern the development of every iOS app and the dangerous consequences of disregarding them. Developers who merely copy and paste code from tutorials fail to grasp these essential concepts.
- The significance of the MVC and MVVM patterns, which serve as the core design patterns for SwiftUI apps. Design patterns play a crucial role in writing software that is well-designed and robust. Neglecting them will inevitably result in battling against the platform and introducing hard-to-fix bugs.
- The critical differences between Swift structures and classes. A comprehensive understanding of how value and reference types work is essential to prevent unexpected issues, particularly within SwiftUI’s declarative syntax.
Module 2
Modularizing SwiftUI Code
Lesson 2.1 – The Core Components of SwiftUI
Creating views and populating them with data
Lesson 2.2 – Functions and Closures
The commonly used yet often misunderstood features of the Swift language
Lesson 2.3 – View Composition
Editing a SwiftUI view and providing data to Xcode previews
Lesson 2.4 – Stacks and Groups
The most straightforward way to lay out content in SwiftUI
Lesson 2.5 – Basic View Layout
Breaking UI code into modular reusable views
What you’ll learn:
- Functions, closures, and view builders, some of the Swift language features that enable SwiftUI’s declarative syntax. Understanding these features will enhance your comprehension of how SwiftUI works and help resolve any cryptic errors in Xcode.
- Leveraging Xcode previews to speed up interface development and how to effortlessly supply them with preview data that does not depend on external factors, making sure your previews always work.
- The best practices for creating modular SwiftUI views that remain detached from your app’s model. This approach yields robust views that do not break even when your data model changes and are easily previewed in the Xcode canvas.
Module 3
View Modifiers and the Layout of Complex SwiftUI Interfaces
Lesson 3.1 – The SwiftUI Layout Process
How views are arranged on screen in complex user interfaces
Lesson 3.2 – Following the Evolution of your Code
Exploring your repository’s history and comparing changes
Lesson 3.3 – Modifying Views and Chaining Methods
The technique that makes view modifiers possible in SwiftUI
Lesson 3.4 – Custom View Modifiers
Managing the layout of user interfaces and reusing code across SwiftUI views
What you’ll learn:
- The SwiftUI layout system: a simple yet powerful three-step process that positions your views on the screen, even for the most sophisticated user interfaces.
- The Swift programming techniques that enable SwiftUI’s view modifiers and guide you in creating custom modifiers that replicate the behavior of those provided by the framework.
- How to use Xcode tools and shortcuts to organize your code into navigable sections, generate boilerplate code, reuse common code snippets, and efficiently navigate large projects.
Module 4
Adding Events and Data Flow to SwiftUI Views and Enable User Interaction
Lesson 4.1 – User Interaction and Events
Capturing variables in Swift closures to affect state
Lesson 4.2 – State and Data Flow
Updating the SwiftUI view tree and storing data in a single source of truth
Lesson 4.3 – Responding to User Actions
Updating the single source of truth at the root of the view tree
Lesson 4.4 – Chaining SwiftUI Bindings
Propagating user input up the view hierarchy to reach the single source of truth
What you’ll learn:
- Storing mutable state in a single source of truth and understanding how changes trigger SwiftUI’s drawing process. Many developers with limited knowledge are unaware of how SwiftUI’s structural identity functions, resulting in interfaces that exhibit unexpected behavior.
- Creating actions for interactive views by utilizing capturing closures that can modify the global state of a view, even when employing simple Swift structures.
- Using bindings to propagate data changes up the view hierarchy, including how to chain them to access the application’s single source of truth and leveraging them to enable interactive views in the Xcode preview canvas.
Module 5
Structured Interactive Interfaces with Dynamic Data
Lesson 5.1 – Interactive Lists
The most common SwiftUI structured interface for dynamic data
Lesson 5.2 – Data Flow in Structured User Interfaces
Selecting, reordering, and deleting rows in SwiftUI Lists
Lesson 5.3 – Updating Data in SwiftUI Lists
Structuring the view hierarchy and sharing functionality across value types
What you’ll learn:
- The SwiftUI list, the most used and versatile vertically scrolling interface for handling dynamic data and navigation. Including how to quickly enable reordering and deleting of rows while keeping the editing code organized within dedicated methods and how to avoid conflicts with identifiable data.
- The essence of protocol-oriented programming and how to share standard functionality across the model of your app, even when dealing with value types such as structures and
- How to construct modular views for editable list elements and bind them to individual values in a Swift collection. Additionally, the guidelines on organizing files in a large Xcode project to ensure easy access during feature development.
Module 6
Navigation Hierarchies and Data Flows
Lesson 6.1 – Structural Paradigms
Scenes, navigation views, and modal presentation modifiers
Lesson 6.2 – The Skeleton of SwiftUI Apps
Structuring an app’s main navigation flow
Lesson 6.3 – Extending Navigation with Modal Contexts
Forcing user action and canceling data editing
Lesson 6.4 – The SwiftUI Environment
Propagating data in a deep view hierarchy
Lesson 6.5 – Data Flow in Deep View Hierarchies
Custom environment values and modifiers
What you’ll learn:
- The SwiftUI environment, the mechanism that effortlessly channels data to any view, eliminating the need for countless stored properties. Plus, the seamless three-step process for storing your custom types in the environment.
- How to use SwiftUI’s structural paradigms to streamline navigation in even the most intricate apps. Explore the best practices of combining navigation views and presentation modifiers to forge complex navigation flows while maintaining a clean separation between your view hierarchy and data model.
- Crafting powerful view modifiers that tap into environment values, affecting entire view subtrees. This technique, often overlooked in other resources, is a crucial ingredient for making your code more expressive, like the one offered by the SwiftUI framework.
Module 7
Structuring a Fully-featured SwiftUI App
Lesson 7.1 – Identity and Shared State
Connecting SwiftUI views to local and global objects
Lesson 7.2 – Controller Hierarchies
Structuring an app’s main navigation flow
Lesson 7.3 – The Architecture of SwiftUI Apps
Expanding the MVC and MVVM patterns to manage the state and navigation structure of an entire app
Lesson 7.4 – Streamlining an App’s Information Flow
Coordinating navigation, networking, and state management in root views and view models
Lesson 7.5 – Effective SwiftUI Previews
Mocking and dependency management for controllers and view models
What you’ll learn:
- The SwiftUI mechanisms to connect views to objects and seamlessly share state across your navigation hierarchy. Including how to manage data editing flows and ensure changes propagate only when data is saved.
- Creating controller hierarchies to effectively manage the global state of even the most complex apps. Discover the secret many developers overlook – you can have more than one single source of truth in a SwiftUI app.
- How to extend the MVC and MVVM patterns, adding a root layer that orchestrates navigation, global state, networking, data flows, and user interaction. This separation of roles simplifies your view code significantly.
- Using mocking and dependency injection to effortlessly preview SwiftUI views connected to intricate networks of objects that are otherwise hard or impossible to instantiate. Plus, learn techniques to detach content views from objects, making previews a breeze.
“Being able to have such a direct look at Matteo’s way of thinking, you end up catching his enthusiasm, and you want to put together objects that work as they should, with a good architectural design.
This course is not just for beginners but quite the opposite. It is one of the most advanced courses I have done so far (and I have done many), where one can truly learn, since he speaks to you as a human being, explaining all the details.
Don’t think twice. Investing in Matteo’s course is investing in being a top-level iOS developer. You will not find better material.” – Alejandro Mohamad
SwiftUI Structural Foundations also includes
An Xcode project with the entire Git history, allowing you to explore the evolution of the app’s code
The Xcode project lets you explore code in its context, not just in isolated lessons. The Git history documents the complete evolution of the app, enabling you to compare each step with the previous ones to observe which code changed and how.
The repository commits are tagged with lesson numbers, making it easy to refer to the proper lesson in the course and refresh relevant concepts where they were introduced.
Even more material to deepen your understanding
Each module contains extra materials to help you solidify your understanding of iOS development, such as:
- Video transcripts.
- Downloadable slides.
- Wireframes and mockups for the app.
- Links to all the relevant Apple documentation.
- Alternatives to each approach to give you a more comprehensive understanding of the big picture of iOS development.
The course is online and accessible from anywhere, and as it’s pre-recorded, you don’t need to attend live classes in the middle of your day.
You can take the course at your own pace and have lifetime access to the material. This means you can pause the course if you need to go on vacation or if life and work take over, and you can resume whenever you’re ready.
Moreover, lifetime access ensures that you receive updates for free when necessary. Since the course’s introduction, it has been updated seven times, with all students receiving every update at no extra charge.
“I did get the desired results as I understand why the code I already learned to write works. I have used other tutorials, and I think they are great for learning how to write code that works – but learning that way leaves little understanding of why code is written that way. This course helped me understand the bigger picture.” – Peter B.
“Your work helped me in my first app, your approach to the fundamentals helped me in my work. As you said, there are many articles on how to do this and that, but there are not as many explaining the rules and bases. Your articles explain very well the fundamentals and how to go about it. Good work, thanks.” – Wilmer C.
“The course gave me my first real understanding of how to write an app in iOS, the iOS architecture and the main design patterns to be used. I now have the confidence to write my first iOS App!” – SwiftUI Structural Foundations student
Is SwiftUI Structural Foundations right for you?
I want to ensure that my course is the right fit for you.
I don’t want you to go through another course only to find yourself back at square one, still struggling with the same problems.
I prefer working with a small group dedicated to grasping the foundations of iOS development in SwiftUI rather than a large group of programmers who copy and paste code together to create short-term solutions.
SwiftUI Structural Foundations is NOT for you if:
- You lack programming knowledge. This course is not designed for beginners in programming. If you’re unfamiliar with programming concepts, you won’t be able to keep up with the course. The lessons assume you already have a basic understanding of Swift programming. While some courses simultaneously teach programming and iOS development, that approach is flawed. Programming is a substantial subject on its own, and attempting to learn it simultaneously with iOS development can result in missing crucial concepts or feeling overwhelmed by excessive material.
- You prefer to dive into practical tasks immediately, piecing the concepts together later. Some courses require extensive practice and provide the missing information only later. However, I don’t learn that way, and research and experience have shown that others feel the same. My course emphasizes grasping the underlying concepts first, followed by practical examples demonstrating their application.
- You want to jump around the course without a structured approach. To understand best practices, you must progress through the course from beginning to end. If you’re unwilling to invest the necessary time and only seek quick code snippets to copy into your app, this course is not for you. Copy and paste programmers, please leave.
SwiftUI Structural Foundations is RIGHT for you if:
- You want to understand the foundational concepts of SwiftUI rather than relying on specific tutorials that lack broader applicability.
- You are a beginner or already possess some knowledge but desire a deeper understanding of the platform.
- You are patient, organized, and systematic. You acknowledge that iOS development is a complex subject that needs to be slowly understood and internalized and cannot be learned overnight. By putting your effort into understanding instead of mindlessly copying someone else’s code, you will reap the benefits in your career for years to come.
- You seek to understand the overall picture rather than obtaining isolated code snippets for specific tasks.
“SwiftUI Structural Foundations is focused and to the point, covering all key elements for a professional-grade app. Unlike most material out there, Matteo does not hide key discussions from the student, instead elaborating with detail on the design trade-offs that are the trademark of software development” – Adrian Tineo
Frequently asked questions
Do I need to know Swift programming?
Yes, a basic understanding of programming is necessary to follow the course. Some courses attempt to teach Swift programming and iOS development concurrently, but I believe this is incorrect. Both are expansive subjects that should be studied independently.
SwiftUI Structural Foundations solely focuses on iOS development in SwiftUI. Familiarity with the following fundamental Swift programming concepts is recommended:
- Variables and basic operators.
- Control flow statements (if-else, switch, for, etc.).
- Functions and methods.
- Structures and classes.
- Protocols, extensions, and inheritance.
If you understand the concepts above, the course will teach you their purpose, when to employ them, and the best practices for iOS development.
What if I do not know anything about SwiftUI or iOS development?
You do not need to follow other courses, read books, or study tutorials to join SwiftUI Structural Foundations. If you already know how to program in Swift, I will teach you everything you need to know from the beginning without leaving any gaps.
The course covers each concept in a structured order and avoids diving into advanced topics too quickly. This ensures that you always have the necessary knowledge to proceed with the subsequent modules.
What if I already know something about SwiftUI or iOS development?
SwiftUI Structural Foundations can still help you. Many individuals have enrolled in this course to enhance their knowledge and understanding of the platform, even if they possess prior experience.
While I delve into the fundamentals of SwiftUI, I approach the topic with a focus on sound development principles I have acquired over the years. This approach allows you to gain a fresh perspective on the foundational concepts you already possess.
Furthermore, if you are familiar with UIKit and have experience developing apps, transitioning to SwiftUI will require adopting new mental models. This might render you a beginner again in certain aspects. A deep dive into SwiftUI is the most effective way to familiarize yourself with the latest technologies and get up to speed.
How is SwiftUI Structural Foundations different from other courses on the market?
I have reviewed several other courses, which all follow a similar tutorial-like approach. Instead, this course begins by explaining fundamental principles and progresses towards creating a concrete app emphasizing best practices.
How does SwiftUI Structural Foundations relate to other material I am following?
Many online resources either skim through fundamental concepts or assume prior knowledge, making them too advanced for beginners. SwiftUI Structural Foundations is designed to bridge this gap by comprehensively understanding core concepts. With this course, you can tackle other materials that may seem overwhelming.
Does the course cover MVVM, MVP, Composable Architecture, Clean Swift, or Combine?
The course covers MVC and MVVM, the most widespread structural patterns Apple and iOS developers use.
However, it’s important to note that you shouldn’t be fixated on a single, specific design pattern. The course provides you with fundamental architectural concepts and best practices that can be applied to any situation.
The course does not include coverage of Combine because it has limited adoption and has been superseded by Swift concurrency with async/await. Most job opportunities in the market require you to create apps without relying on Combine.
Moreover, it’s not a fundamental technology for SwiftUI or iOS development. Combine, along with other reactive frameworks, is simply a tool. Even when utilizing Combine, it is essential to have a solid understanding of software development practices and design patterns.
Can you show me a preview of the course material?
The emails you have received in the past few weeks are a preview of the course content. On this page, you can also find a video showcasing the content of some lessons.
If you are still requesting additional free material at this point, this course is not for you.
Since joining my mailing list, you have received several eBooks completely on my dime. My blog contains numerous high-quality articles that took hundreds of hours to create and have benefited thousands of developers. Before arriving at this page, you received even more complimentary material via email.
I am confident that if you apply even a fraction of what I have taught in all the freely shared material, you will experience significant improvement that justifies the price of the entire course. I choose to invest in you before you invest in my programs because I genuinely believe in your potential.
You already have abundant material to assess the quality of my work, and my paid courses undoubtedly offer an even higher level of quality. If everything I have presented thus far is still insufficient, then there is no preview I can provide that will change your perspective.
Do I need to be in a specific location or follow the course at a particular time?
No, the course is entirely online and self-paced. You can follow it anywhere in the world at any time.
Do I have to hurry up and follow the course in a defined time frame?
No, the course is self-paced and online, and you have lifetime access. You can progress at your speed and revisit the material whenever you need to review the concepts.
This course does not require you to attend live classes at inconvenient times. However, it can only benefit you if you actively engage with the content. I don’t want individuals to invest money in the course and set it aside. My goal is to have a meaningful impact on your understanding, but you must contribute your effort and diligently follow the course content.
I am already overwhelmed. I do not want another ton of material to study.
I have designed every lesson in SwiftUI Structural Foundations to be concise and straightforward. They are intended to be learned individually, allowing you to grasp the material without overwhelming you with numerous new concepts.
Each video lesson lasts approximately 10 minutes, while each module, including the hands-on exercises, can be completed within an hour. By studying one module per day, you can finish the course in two weeks, although this timeline is not mandatory.
You can allocate different days for theory and hands-on practice or adjust the pace to suit your needs. The course is entirely self-paced and can be completed in as little as 10 minutes per day if that is your only available time.
What if I try SwiftUI Structural Foundations and decide it is not suitable for me?
I stand behind this course with a 100% money-back guarantee. Give the entire course a try for two months and determine if it suits you. This allows you to go through the complete course before making a decision. If you don’t see any results, I will refund 100% of your payment if you make a good-faith effort to follow the material.
Can I do all this on my own?
Yes, definitely. After all, I taught myself everything. Apple’s documentation is freely available, and the internet is filled with free blogs and tutorials. I also produce much free material.
But let’s be honest. You have likely already tried everything, and it hasn’t worked. Every blog covers a wide range of topics, and you never know if they are relevant. It’s challenging to piece everything together.
Consider the amount of time and effort required to figure everything out independently. Compare that to knowing precisely what you must learn to develop most apps. You must focus on the necessary knowledge to advance your career rather than wasting time assembling online tutorials.
I already read all your free material. Isn’t that enough?
I strive to make my free material surpass most paid content available online. However, my paid material offers a different experience.
Within this course, I delve into more concepts and provide in-depth coverage of each topic, granting you a comprehensive understanding of iOS development. All modules are thoughtfully organized logically, eliminating the need to search through separate articles and piece together the concepts on your own.
Additionally, I will guide you through developing a complete app with a complex flow and a level of instruction that is not feasible within my free articles. While I am happy to assist as many developers as possible with my free material, I designed this course for those who desire a deeper exploration and a more structured, comprehensive curriculum.
I do not have time to take any courses.
Time can be challenging, but learning complex skills like software development requires a significant time investment. As life progresses, your available time tends to decrease rather than increase. If you are unwilling to dedicate time to grasping the required concepts, this course may not suit you. However, I understand that time is valuable, and I want to ensure you don’t waste it.
Each video lesson is designed to be concise and focused, concentrating on a single fundamental concept. This approach allows you to progress through the course at your own pace, making it possible to fit lessons into any available time slot during your day.
The course grants you lifetime access, alleviating concerns about finding time to keep up with the lessons. Additionally, the practical lessons adhere to the same approach, briefly presenting the code required to implement what has been explained in a module. Moreover, all the code is downloadable, eliminating the need to type it out manually if you prefer not to.
I am already studying a lot of other material and don’t have time for more.
If you’re feeling stuck and unable to connect all the pieces to grasp the big picture, it’s likely because you’re consuming too much material.
Moreover, you are likely reading content that is irrelevant to your current experience level. I designed this course to enable you to disregard all other material and concentrate solely on learning what is necessary for you to know.
If you lack time due to the overwhelming amount of material you’re consuming, my course can help you reclaim some time. Once you’ve completed the course and gained a solid foundation, you can always return to the other material to broaden your understanding of less fundamental topics.
Do you offer discounts for bulk purchases for company/team access?
Yes, but not directly on this page. If you want to gain access to the course for your entire team or company, please contact me at support@purecreek.com and indicate the size of your team.
Please note that this option is exclusively for company purchases intended for their employees. I do not permit individuals to form groups to obtain a discount. If you try to cheat, I will ban you from accessing all my courses.
Is the material current with the latest iOS, Swift, and Xcode versions?
Although the fundamental concepts of iOS development have remained consistent over the years and SwiftUI has matured, I continually update the course to align with the latest versions of iOS, Swift, and Xcode. Since its inception, I have updated this course seven times to ensure it reflects the industry’s current best practices.
Yes, you have other options to learn SwiftUI and iOS development
I have already shown you how SwiftUI Structural Foundations covers all the essential topics and best practices for building any app independently.
However, I won’t deceive you by claiming that these concepts can only be learned here. You can also find them in other resources.
It took me a computer science degree and almost 20 years of experience in various companies and projects to learn many of the lessons I teach in this course. Obviously, you can invest the same amount of time and effort.
There are also other options available. Perhaps you have even tried some of them already:
Attend iOS boot camps: These typically cost $3,000 to $20,000. While some can be excellent, I have encountered many who attended boot camps and didn’t even learn half of what I teach in this course. Additionally, boot camps require you to be physically present for an extended period.
Learn iOS development on the job: You can gain valuable experience by working as an iOS developer in certain companies and engaging in discussions with other developers. However, this assumes that you can secure such a job. Moreover, you might be the only iOS developer in small companies without anyone to learn from. To learn from experienced developers, you would need to work at a larger company, which means more challenging interviews.
Learn from books, free articles, YouTube videos, and paid subscriptions: I have personally used these resources. I subscribe to almost 50 iOS development newsletters, watch countless videos from Apple’s WWDC and other conferences, purchase eBooks, and pay for video subscriptions.
However, I often encounter superficial explanations, unstructured code, and concepts presented haphazardly. Many of these resources may appear appealing, but they can be time-consuming, and I often find them a waste of time. When you consider their cumulative cost, it can even exceed the price of my course.
Do nothing: Yes, you also have the option of doing nothing. You can continue copying and pasting code from online tutorials, learning bad practices, and repeating the same mistakes. How long can you continue like that?
“The SwiftUI Structural Foundations course has been extremely helpful for me. I finally understand how to structure iOS apps properly; I know why and how to do it.
By the end of the course, I feel much more confident now as an iOS developer. In fact, it has enabled me to totally refactor several apps, and they are working much better now.
I am so glad I purchased this course. This investment in these key skills will make me a successful iOS developer after I launch my apps.” – Doug Warren
An unbeatable guarantee: try SwiftUI Structural Foundations for a full 60 days, 100% risk-free
If this course does not help you advance your understanding of SwiftUI and iOS, 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 looked at many other books and courses and saw that they all follow the same approach. They make you do some exercises and assume you will magically understand the best practices of iOS development. Some courses try to teach you programming and iOS development simultaneously, giving you a poor understanding of both.
My research showed me that several students are left more confused by these courses and cannot put into practice what they learn. I believe my approach can help many to get back on the right track.
That’s why I guarantee SwiftUI Structural Foundations.
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 pretty reasonable.
I know without a shadow of a doubt from my students the value my course produces, even for developers already familiar with making iOS apps. I have plenty of testimonials that show that.
What I don’t know is whether you’ll study the material as I structured it and apply the techniques that 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 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.
It’s really simple. 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, 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, absorb the material, and put it into practice.
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. I’ll refund 100% of your price.
By the way, I ask you to show me that you’ve applied the concepts I teach 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. Skipping the work, reading a few random lessons, and doing the same things you did before will not make any difference.
I’ve spent years to learn these concepts and more years developing this course, and I’d like to share it with you if you’re ready to finally call yourself an iOS developer.
I want as many people as possible to understand how to structure iOS apps in SwiftUI properly. That’s why I created a payment plan in addition to my unbeatable money-back guarantee.
SwiftUI Structural Foundations typically costs $299, while many others charge much more for a fraction of the results. However, you don’t have to pay it all at once to get started today.
Not only will you have two full months to complete the course and start using what you learn straight away in all the apps you write—and see for yourself what difference it makes—but you can get started for just $49. Then, you will pay only $49 for the next six months (7 total payments). That’s just $1.63 a day. You can’t even get a coffee for that price in most places.
And you know the kind of salary an iOS developer gets nowadays. What if you could get a raise at your job? What if you could start freelancing and make apps for different clients, earning money from home? Or sell your apps in the App Store?
But it’s not just about the money. It’s also the satisfaction of making great products used by thousands, if not millions, of people.
Just remember, SwiftUI Structural Foundations will soon close to new members. If you are interested, you need to act now.
“I was doubtful because the course is not published on any of the major education platforms. But it has been, without a doubt, the best decision regarding online-paid courses I’ve ever made.
What gave me trust was being able to read Matteo’s free articles and compare them with what I’d previously read. If I had this impression reading his free content, what could I be missing out from a full course?
I can surely say the content’s quality and the architectural approach Matteo delivers are exceptional on both of his courses.” – Alejandro Jimenez
Which option is right for you?
Option #1
SwiftUI Structural Foundations
- SwiftUI Structural Foundations: The practical course to build a solid understanding of SwiftUI foundations, enabling you to create any iOS app confidently. SwiftUI Structural Foundations is an online course focusing on the best patterns and practices for structuring the code of fully featured iOS apps.
7 monthly payments of $49
(That’s only $1.63 per day. Sales taxes may apply depending on your location)
If you have any questions or concerns about the course, email me. I am happy to help. Team/bulk discounts are also available.
Option #2
The Ultimate iOS Professional Bundle
- SwiftUI Structural Foundations ($349): The practical course to build a solid understanding of SwiftUI foundations, enabling you to create any iOS app confidently. SwiftUI Structural Foundations is an online course focusing on the best patterns and practices for structuring the code of fully featured iOS apps.
- The SwiftUI Compendium ($49): The missing SwiftUI manual designed for aspiring iOS developers seeking to understand the basics of SwiftUI through a practical project, leveraging Apple’s official documentation. The SwiftUI Compendium is a concise quick-start guide without unnecessary details to build a foundation from which you can expand your knowledge and skills.
- Early access to Scalable Networking Architecture ($349): Learn to build advanced networked apps in SwiftUI with a scalable architecture. The course is under development and will take a few months to complete, so it’s currently accessible only through this bundle. You will get early access to the already developed modules and receive the new material as it gets published.
- Git for iOS Development ($79): The practical course to fully use Git, safeguard your Xcode projects, and share code with other iOS developers without being frightened by its arcane-sounding commands. Git can be remarkably difficult to use if you get the wrong mental model taught by many “Getting Started” guides that only teach basic commands. Git for iOS Development covers everything you need to know about Git in Xcode and the Terminal.
- Total value: $826. This course bundle lets you save $113 on the total price when buying the two courses separately.
7 monthly payments of $99
(That’s only $3.3 per day. Sales taxes may apply depending on your location)
If you have any questions or concerns about the course, email me. I am happy to help. Team/bulk discounts are also available.
Stop being a developer that can only copy code from others
It took me considerable time to get where I am now. I can finally experience the satisfaction of creating any app I want. I have worked with multiple clients and successfully published my apps in the App Store.
However, this wasn’t always the case. I faced several obstacles, made mistakes, developed apps incorrectly, and suffered the consequences.
You have the potential to gain my experience much faster than I did. Instead of copying code from tutorials, you can start writing your own. This will enable you to build the apps you desire rather than struggling to understand where to begin.
Consider the impact this change could have on your career as an iOS developer in the upcoming years. My course can guide you towards a more successful path to achieving your goals, whether obtaining a better job, pursuing a freelancing career, or publishing your own apps.
The knowledge you gain from this course will serve you for years. You have already witnessed the concepts I explained in my emails, and now you have the opportunity to master them.
The time to make a decision is now. SwiftUI Structural Foundations will close soon, and I do not know when I will reopen it. And, as time passes, I keep increasing its price.
“Your material was very well written and laid out as good as, if not better than, any guide to learning iOS that I had ever read. I was a member of every site imaginable, so there were plenty.
Even though I attribute my learning of programming to each of the different sites and resources I have used, I know that your understanding and ability to coach through great lessons helped me tremendously. I now have multiple iOS applications in the app store that I have personally developed.
Developing is a scary thing to learn, especially with all of the different ways anything in code can be (correctly even) done. Having professional, driven instructors like yourself is 100% why I stuck with it and why I have been as successful as I am now.” – Christopher H.
Option #1
SwiftUI Structural Foundations
- SwiftUI Structural Foundations: The practical course to build a solid understanding of SwiftUI foundations, enabling you to create any iOS app confidently. SwiftUI Structural Foundations is an online course focusing on the best patterns and practices for structuring the code of fully featured iOS apps.
7 monthly payments of $49
(That’s only $1.63 per day. Sales taxes may apply depending on your location)
If you have any questions or concerns about the course, email me. I am happy to help. Team/bulk discounts are also available.
Option #2
The Ultimate iOS Professional Bundle
- SwiftUI Structural Foundations ($349): The practical course to build a solid understanding of SwiftUI foundations, enabling you to create any iOS app confidently. SwiftUI Structural Foundations is an online course focusing on the best patterns and practices for structuring the code of fully featured iOS apps.
- The SwiftUI Compendium ($49): The missing SwiftUI manual designed for aspiring iOS developers seeking to understand the basics of SwiftUI through a practical project, leveraging Apple’s official documentation. The SwiftUI Compendium is a concise quick-start guide without unnecessary details to build a foundation from which you can expand your knowledge and skills.
- Early access to Scalable Networking Architecture ($349): Learn to build advanced networked apps in SwiftUI with a scalable architecture. The course is under development and will take a few months to complete, so it’s currently accessible only through this bundle. You will get early access to the already developed modules and receive the new material as it gets published.
- Git for iOS Development ($79): The practical course to fully use Git, safeguard your Xcode projects, and share code with other iOS developers without being frightened by its arcane-sounding commands. Git can be remarkably difficult to use if you get the wrong mental model taught by many “Getting Started” guides that only teach basic commands. Git for iOS Development covers everything you need to know about Git in Xcode and the Terminal.
- Total value: $826. This course bundle lets you save $113 on the total price when buying the two courses separately.
7 monthly payments of $99
(That’s only $3.3 per day. Sales taxes may apply depending on your location)
If you have any questions or concerns about the course, email me. I am happy to help. Team/bulk discounts are also available.