inflearn logo
inflearn logo

Scalable Flutter App: Supabase, Clean Architecture & BLoC

Leap beyond Flutter basics and become an expert in designing production-level architectures. Build scalable apps using Clean Architecture, Supabase, BLoC, and Monorepos.

19 learners are taking this course

Level Basic

Course period Unlimited

Flutter
Flutter
bloc
bloc
monorepo
monorepo
clean-architecture
clean-architecture
supabase
supabase
Flutter
Flutter
bloc
bloc
monorepo
monorepo
clean-architecture
clean-architecture
supabase
supabase
날개 달린 동전

Recommend Course to grow and earn commission!

날개 달린 동전

Marketing Partners

Recommend Course to grow and earn commission!

What you will gain after the course

  • Practical Application of Clean Architecture: Learn how to design a robust, scalable, and testable app structure by separating code into Presentation, Domain, and Data layers, going beyond mere theory.

  • Supabase Full-Stack Development: Build and integrate Authentication, Database, Storage, and Realtime features perfectly using Supabase without writing any backend code.

  • State Synchronization using BLoC and Event Bus: Learn how to maintain data consistency across multiple screens in large-scale apps by introducing an Event Bus architecture and mastering elegant communication methods between BLoCs.

  • Setting up a Monorepo environment: Experience a professional development environment where functions are separated and managed in package units to maximize the reusability of business logic.

  • Implementation of Practical Advanced Features: Implement service-level features such as responsive search with Debounce, infinite scroll using shared logic, and real-time notification systems.

"Go beyond Flutter basics and leap forward as an expert who designs professional-level architectures."

Are you ready to move beyond simple counter apps or TODO list examples and solve complex problems encountered in real-world services? If you have experienced code becoming tangled as you add features, or the app becoming unstable with even a small modification, this course will be the answer.

This course goes beyond simply completing a single app; it teaches solid development methodologies for creating 'scalable and maintainable apps' that remain stable over time.

🏗️ In the AI era, why should we still learn architecture?

We are in an era where AI can write code in just a few seconds. If so, what should we as developers focus on?

  • The power to see the whole, not just the pieces: AI is good at creating single functions or widgets. However, in large-scale projects where tens of thousands of lines of code are intertwined, deciding where each component should be located and how to reduce coupling remains the responsibility of human developers.

  • A solid vessel for AI code: As the amount of AI-generated code increases, so does the risk of it becoming unmanageable 'spaghetti code.' Clean Architecture and Monorepos serve as solid vessels that help systematically organize and safely operate the code snippets created by AI.

  • Irreplaceable Decision Maker: AI only suggests options; it cannot make the optimal technical judgments suited for specific business contexts. This course will evolve you from a mere 'coder' into an 'architect' who commands AI as a tool.



🛡️ Three Pillars Supporting the Course

By building the 'Community Board' app, which serves as a real-world stage, you will master the three core technologies that support large-scale projects.

  1. Robust Architecture (Clean Architecture): Bring order to messy code. Design a structure that is easy to test and maintain by clearly separating concerns.

  2. Modern Backend (Supabase): Drastically reduce backend development time by utilizing Supabase, which provides database, authentication, and real-time features without complex server setup.

  3. Efficient State Management (BLoC & Event Bus): By combining BLoC, the standard state management for Flutter, with an Event Bus architecture that reduces coupling between objects, data across the entire app is elegantly synchronized.





🚀 Key Learning Content and Features

  • Building a Practical Community App: Build all the essential features required for a real-world service from scratch, including authentication, post CRUD, real-time comments/likes, profile management, and responsive search.

  • Monorepo Environment: Learn how to manage large-scale projects and maximize code reusability by separating features into independent package units.

  • Advanced Streams and Real-time Control: Covers professional-level techniques such as real-time notifications using Supabase Realtime, and Debounce and switchMap for search optimization.

  • The Essence of Architecture, Scalability: You will acquire design skills at a level where you can launch a new app by simply changing the state management tool while maintaining the current structure.


Key Learning Content and App Features

📅 Curriculum Roadmap (Learning Path)

  1. Foundation: Mastering the VS Code environment to boost practical productivity and essential tools that reduce boilerplate

  2. Architecture: Establishing Clean Architecture principles, such as separation of concerns and dependency rules

  3. Infrastructure: Building a monorepo for scalability and designing the Supabase backend (SQL, RLS, Functions)

  4. Development: Implementation of core features (Auth, Post, Search) using BLoC and Event Bus

  5. Advanced: Advanced application of Supabase Realtime for real-time data detection and UI reflection

  6. Next Level: Overall project retrospective and discussion on expansion strategies for other state management libraries

🎯 Recommended for these people

  • Those who have built basic apps with Flutter but want to take on larger, more structured projects.

  • Those who are curious about how to implement Clean Architecture used in practice through actual code

  • Solo developers or startup developers who want to maximize backend development efficiency using Supabase

  • Those who need a portfolio demonstrating 'scalable app design skills' for employment or career transitions.

📋 Please check before taking the course (Prerequisites)

  • Flutter & Dart Basics: An understanding of basic widget usage and asynchronous programming (async/await) is required.

  • State Management Experience: It is helpful if you have experience using any state management method such as Provider, Riverpod, or GetX. (The course is designed so that you can easily follow along even if BLoC is new to you.)

  • Basic SQL Knowledge: It is recommended to know basic CRUD syntax for reading and writing data. Complex policies will be learned together during the course.

📂 Lecture materials and source code provided

  • High-quality PDF slides: We provide PDF presentation materials including core theories and architecture diagrams for each section. (Download from the ‘Resources’ tab in each section)

  • Final source code provided:


    Beginner Level: Completed code for productivity tools and core syntax (e.g., data_class) covered in Section 3 is provided.
    Main Project: The full monorepo structure and final implementation code for the community bulletin board app, starting from Chapter 4, are provided.

  • Detailed information regarding source code links and usage instructions will be provided in the first lectures of Chapters 3 and 4.


You will understand the essence of 'why' it should be designed that way, going beyond simply 'how' to build it. Join this journey now to take your skills to the next level!

Recommended for
these people

Who is this course right for?

  • Developers who have built basic Flutter apps but want to learn robust, production-level architecture.

  • Those who feel that maintenance is becoming difficult as their code grows more complex and want to find a solution through 'Clean Architecture'.

  • Solo developers or startup developers who want to launch high-performance apps quickly by utilizing a BaaS like Supabase rather than spending time on backend development.

  • Those who want to learn practical know-how for combining state management tools (BLoC) with systematic architecture, going beyond simple functional implementation.

  • Candidates who want to prove their 'scalable app design skills' in their portfolio for employment or career transitions.

Need to know before starting?

  • Flutter Basics: You should be able to work with basic widgets (Row, Column, ListView, etc.) and have a fundamental understanding of asynchronous programming (async/await).

  • Dart Basic Syntax: This is intended for those who are familiar with the basic concepts of object-oriented programming, such as classes and inheritance.

  • State Management Experience: It is recommended to have experience using at least one state management solution (Provider, Riverpod, GetX, etc.). (Even if BLoC is new to you, you will be able to follow along as long as you understand the basic principles of state management.)

  • Basic SQL Knowledge: It is recommended to know simple SQL CRUD syntax for reading and writing data. Complex queries and security policies will be built together during the course.

  • Passion for learning: You don't need to start with a perfect knowledge of every technology. As long as you have the will to learn new design methodologies, that is enough!

CEO of YourDevEdge | Flutter Expert & 'Heavy Fran' YouTuber

Hello. I am an instructor running the full-stack educational content startup YourDevEdge and the Flutter-specialized YouTube channel ‘Heavy Fran’.

After working for over 20 years at a leading telecommunications company in Korea, I pivoted my career toward development at an age that was by no means young. The experience of teaching myself various languages and frameworks through trial and error has become the foundation of my current educational philosophy and teaching style.

To date, I have released a total of five courses on Udemy—including Flutter Provider, Bloc, Redux, Riverpod, and Dart Frog-based Clean Architecture API development—sharing practical, hands-on learning experiences with students worldwide. Through this journey, I have constantly validated what kind of explanations truly help learners and professional developers, moving beyond mere "theoretically correct" descriptions.

Because I understand the frustration and loneliness of learning new technologies better than anyone, I focus on conveying the essence—not just "how to implement a feature," but why this architecture is necessary and how to structurally solve the complex problems you will face in practice.

I have poured into this course over 20 years of system thinking and all the trial-and-error and know-how gained from establishing myself as a professional developer despite a late start.
By connecting the "core essentials you must understand" with the "details that are easy to miss," I will be a reliable pacemaker helping you leap to the next level without feeling lost on your own.

More

Curriculum

All

145 lectures ∙ (18hr 24min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

Not enough reviews.
Please write a valuable review that helps everyone!

Similar courses

Explore other courses in the same field!

Limited time deal

$59.40

29%

$84.70