Free through lesson 3

Dart & Flutter for Beginners

From setup through Dart syntax, widgets and layout, navigation and forms, state management with Riverpod, HTTP and storage, testing, and signing and store submission. Over 50 lessons, you'll get to the point where you can build a memo app, with tests, that ships to iOS, Android, and the web from a single codebase. Every piece of code and every output shown was actually run on Flutter 3.47.5 / Dart 3.13.4.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are split into 7 chapters. We recommend going in order from chapter 1, but feel free to jump to whatever interests you. Note: the code can't run in the browser, so install Flutter SDK 3.47.x locally and try it with dart run and flutter test. Chapters 1 to 5 need no device or emulator. From chapter 6 on, you'll use a simulator and an emulator.

Chapter 1 — Dart Syntax (lessons 1–9)

We cover just the Dart you need to read Flutter code, running everything as we go. We work through types and null safety, collections, classes, sealed classes, and async. Once you finish this chapter, the code in chapter 2 onward won't stop you with "syntax I've never seen."

1

How Dart and Flutter Relate (and How They Differ from Flet)

What Flutter does, and that the language it uses is Dart. We start by sorting out how it differs from Flet, which you use from Python.

Free
2

Setting Up and Running with dart run

How to install the Flutter SDK and check that it's installed. Run a single file with dart run and learn to read flutter doctor.

Free
3

Variables and Types (var, final, const)

Type inference with var, the difference between final and const, and common built-in types. See for yourself that const values are fixed at compile time.

Free
4

Null Safety (?, ?., ??, !)

How Dart separates types that can hold null from those that can't. Safely navigate with ?. and ??, and learn when it's OK to use !.

🔒 Basic
5

Collections (List, Map, Set)

When to use each of the three collections, and transforming them with map, where, and friends. See how spreads and collection if shorten UI code.

🔒 Basic
6

Functions and Named Parameters

Named parameters and required, used everywhere in Flutter code. Get comfortable passing functions as arguments: anonymous functions, arrows, and closures.

🔒 Basic
7

Classes and Constructors

The this.x shorthand, named constructors, getters, inheritance, and mixins. Write copyWith to lay the groundwork for replacing state later.

🔒 Basic
8

Sealed Classes and Switch Expressions

How to express "exactly one of these" with types. Patterns in switch expressions, and letting the compiler find missing cases. Records too.

🔒 Basic
9

Async (Future, async/await, Stream)

How to write slow operations. Run code to see what happens before and after await, how to catch errors, and how Streams deliver values over and over.

🔒 Basic

Chapter 2 — Getting Flutter Running (lessons 10–16)

You'll create a project, show your first screen, and learn the widget tree, StatelessWidget and StatefulWidget, and the basics of layout. At the end, you'll measure the rule "constraints go down, sizes go up" for yourself, until you can fix overflow errors on your own.

10

Your First Flutter App (flutter create)

What the files from flutter create are for, and how to strip main.dart down to the minimum and read it. Run the starter test to confirm it works.

🔒 Basic
11

Reading the Widget Tree

A screen is made of nested widgets. Dump a real tree and tell apart the pieces you wrote from the ones Flutter added.

🔒 Basic
12

StatelessWidget (build Can Run Any Number of Times)

A widget that just takes values and returns how things look. Count how often build runs to see why heavy work doesn't belong there.

🔒 Basic
13

StatefulWidget and setState

A widget that remembers its own values. Tap for yourself to see that State isn't recreated and the screen won't change unless you call setState.

🔒 Basic
14

Column, Row, and Expanded

Two widgets for vertical and horizontal layout, and how leftover space is shared. Learn the main and cross axes and measure how many pixels Expanded's flex gives.

🔒 Basic
15

Container, Padding, and Stack

Which widget handles spacing and decoration. Measure the order inside a Container and where children land when layered in a Stack.

🔒 Basic
16

How Constraints Are Passed

Constraints flow from parent to child, and sizes flow back up. Print real constraints with LayoutBuilder and reproduce an infinite height.

🔒 Basic

Chapter 3 — Building Screens (lessons 17–24)

You'll put together lists, scrolling, navigation, input forms, and themes to build screens that feel like a real app. At the end, you'll build a memo list screen, the starting point we'll lift into state management in the next chapter.

17

Showing Lists with ListView

Three ways to build a ListView and when to use each. Count calls to confirm that builder only creates the items that are visible.

🔒 Basic
18

Scrolling and Slivers

What a scrollable area really is, and how CustomScrollView merges a header and a list into one scroll. Measure an AppBar that grows and shrinks.

🔒 Basic
19

Moving Between Screens with Navigator

How screens stack up and pop back. See push and pop, when a back button appears automatically, and how to count the screens on the stack.

🔒 Basic
20

Passing Values to and from Screens

Pass values through constructors and get results back from pop. See what an awaited push returns, and what you get when the user cancels.

🔒 Basic
21

TextField and Handling Input

Where to keep an input field's value. Separate the roles of controller, onChanged, and FocusNode, and type text to track how the value changes.

🔒 Basic
22

Forms and Validation

How to validate several input fields together. Write validators and run them to see when error messages appear and disappear.

🔒 Basic
23

Themes and Material 3

Pick one color and everything matches. Print what ColorScheme.fromSeed produces and switch to dark mode.

🔒 Basic
24

[Project] Building a Memo List Screen

Combine the pieces from chapters 1 to 3 into one screen. Build listing, adding, checking, and deleting with setState only, ready to lift into state management next chapter.

🔒 Basic

Chapter 4 — State Management (lessons 25–31)

First you'll see exactly where setState hits its limits, then move values out of the widget tree with InheritedWidget and Riverpod. You'll narrow what gets rebuilt while counting rebuilds, and finally move the memo app onto Riverpod.

25

The Limits of setState

What happens when you lift values up. Build it yourself to see why sibling widgets can't share a value, and what happens when prop drilling gets deep.

🔒 Basic
26

InheritedWidget and of(context)

Flutter's built-in way to hand values down while skipping the widgets in between. Write your own version to see what Theme.of is doing.

🔒 Basic
27

Adding Riverpod

The roles of ProviderScope and Provider. Learn the difference between ref.watch and ref.read, and how to test with just a ProviderContainer, no widgets.

🔒 Basic
28

Updating State with Notifier

From read-only Providers to Notifiers you can update. See that assigning to state sends a notification, and that assigning the same value does nothing.

🔒 Basic
29

AsyncNotifier and AsyncValue

One type for loading, success, and failure. Split into three with when, and measure how Riverpod 3 silently retries on failure.

🔒 Basic
30

Narrowing What Gets Rebuilt

Make full use of the fact that only widgets that watch get rebuilt. Watch a single field with select, and shrink the rebuild area with Consumer.

🔒 Basic
31

[Project] Moving the Memo App to Riverpod

Split the setState version from lesson 24 into state and UI. Drive the Notifier directly in tests so you can check behavior without drawing a screen.

🔒 Basic

Chapter 5 — Connecting to the Outside World (lessons 32–38)

You'll run a local server and make HTTP round trips, map JSON onto types, and represent kinds of failure with types. Then you'll move on to saving settings and files, and finish with a memo app whose data survives closing and reopening.

32

Fetching over HTTP

Using the http package and handling status codes. Run a local server and make real GET and POST round trips.

🔒 Basic
33

Converting JSON to Types

How to map the dynamic that jsonDecode returns onto your own classes. Decide where to handle missing keys, wrong types, and null.

🔒 Basic
34

Representing Network Failures with Types

Handle "can't connect," "too slow," "server error," and "broken response" separately. Enumerate failure kinds with a sealed class, down to the messages you show.

🔒 Basic
35

Saving Small Values on the Device

Saving small values like settings or the last open tab. How to use SharedPreferences and which types it can and can't store.

🔒 Basic
36

Reading and Writing Files

Where your app is allowed to write, and how to use File from dart:io. Plus how to write so data isn't corrupted if the app dies mid-write.

🔒 Basic
37

Showing Images

Network images, assets, and raw bytes. Decide what to show while loading and on failure, and avoid holding needlessly large images.

🔒 Basic
38

[Project] Saving and Restoring Memos

Connect file saving to the Notifier from lesson 31. Put the storage location in a Provider so it can be swapped, and test that memos survive a restart.

🔒 Basic

Chapter 6 — Device Features and Testing (lessons 39–44)

You'll learn how to branch by platform and how the permission flow works, and how to write the three kinds of tests: unit, widget, and integration. We also cover how to read a failing test, so red output won't leave you stuck.

39

Changing Behavior by Platform

How to tell iOS, Android, web, and desktop apart. The difference between Platform and kIsWeb, and what adaptive widgets actually turn into.

🔒 Basic
40

Requesting Permissions

What to do before using the camera or location. The three steps of declare, request, and handle denial, and how to check the flow without a device.

🔒 Basic
41

Testing Basics

Unit tests vs. widget tests, where they live, and how to run them. Use setUp, tearDown, and group, all checked in a single file.

🔒 Basic
42

Find, Act, Verify

The three beats of a widget test. Choosing Finders, writing taps and scrolls, and measuring the difference between pump and pumpAndSettle.

🔒 Basic
43

Reading a Failing Test

Where to start reading failure output. Trigger the three ways tests fail (wrong value, exception, timeout) and settle on how to fix each.

🔒 Basic
44

Integration Tests (integration_test)

Tests that run as the real app on a device. How they differ from widget tests, where they live, and how to run them, by running one yourself.

🔒 Basic

Chapter 7 — Shipping (lessons 45–50)

Starting from the difference between debug and release, you'll go through Android signing, iOS builds, icons, and store submission prep with real commands. Finally, we line Flutter up against Flet once more and give you a map of where to go next.

45

Build Modes (debug, profile, release)

The three build modes and what changes in each. Make a real web build and look at what comes out and how big it is.

🔒 Basic
46

Shipping to Android (APK and AAB)

APK vs. AAB, the size gap between debug and release, and signing. Create a key and make the release build use it.

🔒 Basic
47

Shipping to iOS

What CocoaPods and Xcode are doing. Get a simulator build through, and sort out what else a real device and submission need.

🔒 Basic
48

Icons and App Names

How to set the name and icon shown on the home screen. Generate every size from one image and see what was actually created.

🔒 Basic
49

What to Prepare Before Submitting to the Stores

Versioning, common reasons for review rejection, and a list of what to submit. Walk through the final pre-submission checks with real commands.

🔒 Basic
50

[Project] Flutter vs. Flet, and What's Next

Compare two tools that draw with the same Flutter engine. How to choose between them, and where to go after this course.

🔒 Basic

Once you finish all 50 lessons, try the Flet Fundamentals Course, which uses the same rendering from Python; the Kotlin & Android Intro Course or Swift for Beginners to see things from the native side; or API Design for Beginners to design the APIs your apps talk to. A membership unlocks every course.