Flutter Advanced - Production-Level Architecture

Developing Real-World Flutter Apps:
App Architecture for Scalable App Design 🏗

Why does code become harder to maintain as apps grow? 🤔

The answer lies in Clean Architecture and the MVVM pattern. This architecture, adopted by big tech companies, is a core design method that systematically manages complex business logic and allows for easy addition of new features.

In this course, we will implement a real-world service-level app using Flutter and Clean Architecture. We will cover in-depth topics that you will encounter in practice, such as Dependency Injection, hierarchical state management, writing testable code, and error handling.
If you're tired of Hello World level tutorials, this course will give you the fun of real architecture design while creating a production ready app! 💪

Features of this course

📌 Presenting problems and solutions that occur in real production environments

📌 Step-by-step source code provided via GitHub

📌 All code is written in a way that allows unit testing and UI testing.

📌 This course is for intermediate and advanced level learners.

1⃣ Guide to building a production-level app from Figma

This lecture will explain in detail the process of developing an app when receiving a design from Figma.

2⃣ Folder structure of the app written in the lecture

The structure of the app written in class.
MVVM, MVI patterns based on clean architecture

3⃣ Not using state management library

Many developers use state management libraries out of a sense of obligation, but there is no need to do so. The basic features provided by Flutter are sufficient for state management.
In this course, we will use only the minimum libraries as follows:

4⃣ Testable UI Design

Create a UI that is not affected by any external factors

5⃣ Deep link friendly router configuration

Guide to configuring a deep link-friendly router that is essential for the workplace

6⃣ Error handling strategies for more complex error handling

Improves the existing Result pattern to provide an appropriate error handling method for complex situations

I recommend this to people who have these concerns.

After taking the class, you will be like this ✨

1. Systematic app design becomes possible

• You can clearly distinguish and design each layer of Clean Architecture.

• When you need to add new features, you can extend it without touching the existing code.

• It allows you to naturally apply SOLID principles to real projects.

2. You can implement professional status management.

• You will learn efficient state management methods without using external libraries.

• Even complex business logic can be handled cleanly.

• Clean state management without memory leaks is possible.

3. You can write testable code.

• You can write code that can be used for everything from unit tests to UI tests.

  
  

• You can continuously monitor and improve code quality.

4. You can write code that is recognized in practice.

 // Before
class HomeScreen extends StatefulWidget {
  @override
  State < HomeScreen > createState() => _HomeScreenState();
}

// After
class HomeScreen extends StatelessWidget {
  final HomeState state;
  final void Function ( HomeAction action) onAction;
  
  // Write testable and reusable code
}

5. Complete a project that can be used as a portfolio.

• You can use high-quality apps with actual service levels as your portfolio.

  


• You can gain real-world project experience applying clean architecture.

Learn about these things.


✅ Clean Architecture: Layer separation and dependency injection

"An app without architecture is like a toy without Legos." Learn how to cleanly separate business logic from UI, and write flexible, testable code with dependency injection.



✅ MVVM Pattern: State Management and Unidirectional Data Flow

"State management is the heart of your app." Learn how to create predictable, easy-to-debug apps with efficient state management and unidirectional data flow design.



✅ Error Handling: Improving User Experience

“Errors are inevitable, but they can be managed.” Covers how to systematically handle network errors, data validation, and exceptions, and provide appropriate feedback to users.



✅ Reusable Components: UI Design and Implementation

"A good component is built once and used forever." Learn how to design and implement reusable UI components, construct efficient widget trees, and optimize performance.

Who created this course

• 2018: Android Writing Until It Happens

• 2018: Written by Oh Jun-seok's Android Survival Coding: Kotlin Edition

• 2020: Korea's first Flutter book: Oh Jun-seok's Flutter Survival Coding (Selected by Sejong Books in 2020)

• 2020 ~ 2024: 9 batches of Flutter developer training

  


Things to note before taking the class

Roadmap