The best practices of professional iOS developers for 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

Get the skills separating good and bad developers and:

  • Finally crack that job interview
  • Start freelancing and earn money working from home
  • Bring your app ideas to life and publish them in the App Store

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 on fundamental concepts. – Adrian Tineo

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.

If you’re anything like me, you were drawn to iOS development because of your love for Apple products and programming. You wanted to work on something interesting and exciting and create apps used by millions that positively impact people’s lives.

Now is the perfect time to start creating iOS apps. The app economy is thriving, salaries are competitive, and being an iOS developer provides job security and flexibility. You can even work from home and earn money as an employee, freelancer, or by publishing your apps in the app store.

Thanks to SwiftUI, creating an app from scratch has never been easier. There are countless free articles and tutorials available online that can help you get started.

Learning a new skill is fun and exhilarating, but eventually, things change.

  • You read more articles and go through examples without gaining a deeper understanding you can apply to your apps.
  • You type whatever code the teacher writes without understanding its significance.
  • You feel helpless and think there’s much more you don’t know.

No matter how much you learn, you always feel like you don’t know enough.

You feel stuck, and although you work on personal projects like everyone suggests, you don’t feel like you’re making progress. After putting in all that effort, you still can’t seem to crack that interview or lack the confidence to start freelancing and become independent.

So, you return to the hair-pulling and frustrating process of reading forums, watching YouTube videos, and experimenting with different solutions to problems. However, all you seem to come across are online tutorials for yet another to-do app.

I understand how you feel. It took me two years to finish my first app, and I would wake up early to work on it for two hours before heading to my actual job.

It was challenging, and even when I completed the app, I still sensed that there was a better way to do things. I often wondered if the popular apps on the App Store were created the same way.

Hi, I’m Matteo Manferdini

I have worked as a professional iOS developer for more than 15 years. I was first an employee, then became a consultant for big clients, and independently published many apps on the App Store. Since 2015, I have taught hundreds of students iOS development best practices.

The wrong app structure can make your projects crash and burn

I worked as a freelancer for years and discovered something surprising: many developers, even at famous companies, know little about their work. Many projects have code that is so poorly written that nobody wants to put their hands on it.

This presents a golden opportunity for those who understand how to write clean, concise code to stand out from the crowd and jump ahead of everyone else.

I once had to rescue a project that was terribly late, and it turned out to be a complete nightmare. My client had created an app for another company, but their code was ridden with bugs, and the deadline was fast approaching. They only tasked me with fixing bugs for one week, so it sounded like a quick assignment.

I was wrong.

After inspecting the code, I realized the problem was not just “a few bugs.” The whole app architecture was completely messed up. There was no organized structure, and the author did not understand how to correctly structure an iOS app, making the code a total mess. The app more or less worked, but it was hard to debug, and fixing one bug created more issues.

After a week of trying to fix it, we concluded that the app had to be entirely rewritten from scratch. The final customer was understandably upset, and my client spent all the remaining budget on hiring another company to rewrite the app. They practically worked for free.

As a developer, it’s essential to understand that writing clean, organized code is crucial. If you don’t, you could end up like the developer who wrote the app I had to rescue. He must have felt terrible when he learned his app needed a complete rewrite.

Online, I’ve read stories of developers who become increasingly insecure as time passes, who feel hopeless when they look at open-source code and wish that their projects were better organized.

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

Do you know how to avoid those deadly mistakes?

Luckily, there is a light at the end of the tunnel. The reality is that the basics matter a great deal, and by mastering the fundamental concepts of writing iOS apps in SwiftUI, you can steer clear of costly mistakes. 

With this knowledge, you’ll be able to write any app, heading in the right direction from the outset and understanding precisely where each piece of code should be placed — resulting in clean, well-structured, and maintainable code.

Do you have this ability now? Can you recognize bad practices and comprehend why they are errors in the first place?

Imagine having the confidence to initiate any project you wish and always understand what you must do and how to do it. As you sit at your computer and open Xcode, in mere seconds, you know precisely where to begin and how to proceed.

Envision effortlessly breaking down your task into smaller parts and seeing the app’s structure unfold in your mind, knowing precisely what code you need to implement and how it interacts with the rest of the app.

But does all the material you read help you achieve your goals?

Frankly, I am not impressed when I look at many online tutorials and even some courses. Most online resources lack the comprehensive knowledge and skills to create apps. 

They give you a few examples but leave out crucial information. They may show you how to code an app but fail to explain how the different concepts interact. You may even learn something you will never use.

And when it comes to applying what you’ve learned to real-world projects, you’re left on your own. You’ll spend countless hours putting together disjointed tutorials that often disagree. It’s a frustrating and inefficient process that can leave you feeling discouraged.

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 of what you’re doing?

I always want to understand the logic and the underlying concepts behind any iOS app, not just make a clone. However, most resources seem to be written by programmers who don’t understand 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 that leave you to figure things out on your own, this course takes you through the logical progression of concepts, building on what you’ve learned at each step. By the end, you’ll have a thorough understanding of the underlying principles of iOS development in SwiftUI and the skills to create your own apps from scratch.

This course has been one of the best investments I’ve made. – Natasha Nazari

Introducing…

SwiftUI Structural Foundations

The practical course that provides a solid understanding of how to structure your SwiftUI code, enabling you to build any iOS app with confidence.

SwiftUI Structural Foundations is an online course that focuses on the best patterns and practices to properly structure the code of fully-featured iOS applications.

Here’s why this course is perfect for you:

  • Say goodbye to the feeling of doing things wrong. Make the jump from creating basic to-do list apps through copy-pasting, and start structuring your own apps with complex navigation, all while feeling confident that you’re doing it the right way.
  • Move beyond simple tutorials that fail to equip you with concepts you can apply to your SwiftUI code. 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 and avoid common mistakes.
  • Eliminate messy code that feels unnatural and is difficult to debug. Understand where each piece of code should go and master writing reusable and maintainable code.
  • Get step-by-step instructions and efficient learning material that provide you with the necessary expertise. Discover where to begin, how to progress, and the essential knowledge you need to acquire before moving 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 encompass the entire roadmap for structuring large SwiftUI projects. You’ll develop the correct mental model and overcome any difficulties in 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 to present 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 educating and beneficial for me. – 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 why behind the implementation choices. These are insights I wasn’t aware of when I started my first iOS developer job and took me several years to grasp.

The course is structured into seven modules, which cover the fundamental aspects of SwiftUI. Since iOS development relies heavily on practical experience, each module includes hands-on lessons. These lessons will assist you in constructing a complete app and demonstrate the same process I follow for any app I develop.

The app showcases fully designed screens, while the lessons delve deep into architectural concepts. They illustrate how code is organized in a real project, incorporating the most cutting-edge and up-to-date best practices available.

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 did 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 full Git history, allowing you to explore the evolution of the app’s code

The Xcode project lets you explore the in its context and 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 right 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 already been updated seven times, with all students receiving every update at no extra charge.

I did get the desired results as I understand the 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 iOS development’s foundations 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 programming in Swift. While some courses teach programming and iOS development simultaneously, I believe 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 through 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 look elsewhere.

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

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. 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 possess a basic understanding of 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 have taken other courses, read books, or followed 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 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, and they all appear to adhere to a similar tutorial-like approach. Instead, this course begins by explaining the fundamental principles of iOS development and progresses towards creating any 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 / VIPER / Clean Swift and 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’s not considered 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.

Furthermore, Combine has seen 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.

Can you show me a preview of the material in the course?

The emails you have received in the past few weeks provide a glimpse of the course content. If, at this point, you are still requesting additional free material, this course is not for you.

Since you joined my mailing list, you have received several eBooks completely on my dime. My blog contains numerous high-quality articles that have taken countless hours to create and have benefited thousands of developers. Before reaching this page, you have already 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, any time you like.

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 for the material to have a meaningful impact on your understanding, but you need to 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 right 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 as long as 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 a lot of free material.

But let’s be honest. You have likely already tried everything, and it hasn’t worked. Every blog out there covers a wide range of topics, making it difficult to determine their relevance. 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 need to 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 guide you through developing a complete app with a complex flow, a level of instruction not feasible within my free articles. While I am happy to assist as many individuals 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 follow any course.

Time can be a challenge for everyone, but learning complex skills like software development requires a significant investment of time. As life progresses, your available time tends to decrease rather than increase. If you are unwilling to dedicate time to grasp the required concepts, this course may not suit you. However, I understand that time is valuable, and 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 excessive material.

Furthermore, there’s a high probability that you’re reading content entirely irrelevant to your current experience level. I designed this course to enable you to disregard all other materials 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 any of my products.

Is the material current with the latest iOS, Swift, and Xcode versions?

Although the fundamental concepts of iOS development remain consistent over the years and SwiftUI has matured, I continually update the course to align with the latest versions of iOS, Swift, and Xcode. Consequently, I have revised this course seven times since its inception to ensure it reflects the industry’s current best practices.

I am in a bad financial situation and need a job quickly. Will your course help me?

Even though many of my students have obtained great new jobs thanks to my course, I cannot guarantee the same outcome for everyone. People come from diverse backgrounds and are in different situations, so the results may vary. Additionally, since my students take varying amounts of time to complete the course, I cannot estimate how long it will take for you.

Learning iOS development is time-consuming, and my course is no exception. If you face financial difficulties, dedicating a significant amount of time to learning a new skill may not be the most practical choice.

If you have been following my free materials, you should already have acquired more knowledge than I possessed when I landed my first job as an iOS developer. If you cannot secure a job in iOS development, it might be advisable to consider pursuing another job initially and transitioning your career to iOS development later.

However, this decision is not mine to make. You should have complete control over your life, and I trust you to make the best decision for yourself. If you believe my course could improve your life, you are welcome to join.

Yes, you have other options to learn SwiftUI and iOS development

I have already informed you that SwiftUI Structural Foundations covers 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 find them in other resources as well.

It took me a computer science degree and over 15 years of experience in various companies and projects to acquire many of the lessons I teach in this course. Naturally, you can invest the same amount of time and effort.

There are other options available to you as well. Perhaps you have even tried some of them already:

Attend iOS bootcamps: These typically cost $3,000 to $20,000. While some can be excellent, I have encountered many who attended bootcamps and didn’t even learn half of what I teach in this course. Additionally, bootcamps 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. In small companies, you may be the sole iOS developer without anyone to learn from. To learn from experienced developers, you would need to work at a larger company, which often means more challenging interviews.

Learn from books, free articles, YouTube videos, and paid subscriptions: I have personally used these resources. I subscribe to nearly 50 iOS newsletters, watch countless videos from Apple’s WWDC and other conferences, purchase eBooks, and pay for video subscriptions. However, I often come across 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 mostly 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 I 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 quite reasonable.

I know without a shadow of a doubt from my students the value my course produces even for developers that are 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 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.

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, show me you’re applying the material, but it does not work for you. I’ll refund 100% of your price.

By the way, I ask you to show me you’ve applied the concepts 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 couple of random lessons, and doing the same things you were doing 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 $89. Then, you will pay only $89 for the next 3 months (4 total payments). That’s just $2.97 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 close to new members soon. 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 out there. 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?

SwiftUI Structural Foundations
Pro level

  • SwiftUI Structural Foundations, covering the foundations and best practices of developing iOS apps in SwiftUI.
  • Git for iOS Development, the practical course to fully use Git to safeguard your projects and share code with other developers.
  • Save $19 on buying the two courses separately.

Click here for the full details

4 monthly payments of $89
(That’s $2.97 per day)

SwiftUI Structural Foundations
Master level

  • SwiftUI Structural Foundations, covering the foundations and best practices of developing iOS apps in SwiftUI.
  • Git for iOS Development, the practical course to fully use Git to safeguard your projects and share code with other developers.
  • Save $19 on buying the two courses separately.

Click here for the full details

4 monthly payments of $104
(That’s $3.47 per day)

Option #1

SwiftUI Structural Foundations
Master Level

At the Master level, you will get the complete SwiftUI Structural Foundations course. On top of that, you get Git for iOS Development, my practical course to fully use Git to safeguard your projects and share code with other developers.

  • SwiftUI Structural Foundations: all the lessons covering the foundations of developing iOS apps in SwiftUI. The course gives you the required knowledge you need to create and structure your apps. It also explains the reasons behind the concepts and the best practices you should follow when writing any app of any size and complexity.
  • Git for iOS Development: Take advantage of all the Git features and best practices to improve your daily iOS development workflow. Get the peace of mind of knowing you can experiment with your code and work with others without being terrified of arcane commands that could mess up your repository.
  • This course bundle lets you save $19 on the total price when buying the two courses separately.

4 monthly payments of $104

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

Get Instant Access

Pay now in full and save $67

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

support@purecreek.com

Option #2

SwiftUI Structural Foundations
Pro Level

At the Pro level, you will get the complete SwiftUI Structural Foundations course.

  • SwiftUI Structural Foundations: all the lessons covering the foundations of developing iOS apps in SwiftUI. The course gives you the required knowledge you need to create and structure your apps. It also explains the reasons behind the concepts and the best practices you should follow when writing any app of any size and complexity.
  • Git for iOS Development: Take advantage of all the Git features and best practices to improve your daily iOS development workflow. Get the peace of mind of knowing you can experiment with your code and work with others without being terrified of arcane commands that could mess up your repository.
  • This course bundle lets you save $19 on the total price when buying the two courses separately.

4 monthly payments of $89

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

Get Instant Access

Pay now in full and save $57

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

support@purecreek.com

Stop being a developer that can only copy code from others

It took me considerable time to reach where I am now. I can finally experience the satisfaction of creating many new apps. 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 along the way. I made the mistake of developing apps incorrectly and suffered because of it.

You have the potential to reach the level I am at much faster than I did. Instead of copying code from tutorials, you can start writing your own code. This will enable you to build the apps you desire rather than struggling to comprehend where to even 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 achieve your goals, whether it’s 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 explain 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, when I do, I will increase 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.

SwiftUI Structural Foundations
Pro level

  • SwiftUI Structural Foundations, covering the foundations and best practices of developing iOS apps in SwiftUI.
  • Git for iOS Development, the practical course to fully use Git to safeguard your projects and share code with other developers.
  • Save $19 on buying the two courses separately.

Click here for the full details

4 monthly payments of $89
(That’s $2.97 per day)

SwiftUI Structural Foundations
Master level

  • SwiftUI Structural Foundations, covering the foundations and best practices of developing iOS apps in SwiftUI.
  • Git for iOS Development, the practical course to fully use Git to safeguard your projects and share code with other developers.
  • Save $19 on buying the two courses separately.

Click here for the full details

4 monthly payments of $104
(That’s $3.47 per day)