Free through lesson 3

Flet Fundamentals Course

From setting up your environment to layout, input, declarative code, screen transitions, theming, persistence, networking, charts, and distributing as .app / .exe / .apk. Over 20 lessons, you'll work up to building a household budgeting app with nothing but Python and packaging it for distribution. All code and output were run for real on Python 3.13.15 / Flet 0.86.5.

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are split into 5 chapters. We recommend working through them in order starting from Chapter 1, but feel free to skip around to whatever interests you. * These lessons can't run in the browser, so install Flet 0.86.x yourself with pip install "flet[all]" and try them with flet run. Most articles online cover 0.6x or earlier and won't work as-is.

Chapter 1 — Flet Basics (lessons 1–4)

You'll set up your Flet environment, place and arrange widgets on screen, and polish how things look. By the end, you'll be able to build a single budget entry as a card with padding, a background color, and rounded corners.

Running Flet — Setup and Your First Screen

Install flet[all] and use flet create. Show your first screen with ft.run(main) and page.add(), then push the same code to the browser with --web.

Free

Controls and page.controls

A control is just a data class. You'll meet the 4 types of buttons and ListTile, and share one handler across controls using e.control and data.

Free

Row and Column — Claiming Space with expand

The main axis uses alignment; only the cross axis gets its own name. expand=True is the real trick behind pushing something to the right. Handle overflow with wrap and scroll.

Free

Shaping Appearance with Container

padding gets painted, margin doesn't. You'll meet 0.86's capitalized classes and how to specify colors by role.

Chapter 2 — Events and Input (lessons 5–8)

You'll drive the app from buttons and input fields. You'll get a handle on how updates reach the screen, then build a form with validation and a list of entries you can swipe to delete.

How Events and State Updates Work

How assigning to an attribute reaches the screen. The two situations where update() is required, and how to yield to surface progress along the way.

TextField and Validation

In 0.86, it's error, not error_text. Gather validation into one function, clear errors early and show them late. focus() needs an await.

Choosing the Right Selection Control

Choose based on how many options you have. Only Dropdown uses on_select, SegmentedButton's selected takes a list, and DatePicker is never added with page.add().

Building a List with ListView and Dismissible

ListView only builds what's visible. Why expand=True is required, and how to clear both the data and the screen together on a swipe-to-delete.

Chapter 3 — Writing Declaratively (lessons 9–11)

You'll move from "change the screen like this" to returning "this is what it should look like." You'll handle state with component and hooks, finishing by pulling state out into a store that knows nothing about the UI.

Writing Declaratively with component and use_state

Stop saying "change the screen like this" and return "this is what it should look like" instead. Controls get frozen, how to hand over new values, and how to assign keys.

use_effect, use_memo, and use_ref

How to load data just once on startup, and how to avoid redoing a heavy calculation every time. Measured: 336ms → 52ms. The rule about hook ordering.

Centralizing State with Observable and Context

Stop passing props down a chain. An @ft.observable store, create_context / use_context, and why a plain global reference never updates.

Chapter 4 — Assembling Screens (lessons 12–16)

You'll give a single-screen app a real skeleton. Split it into screens with routing, then add navigation, dialogs, theming, and responsiveness to screen width — shaping it into something that actually feels like an app.

Splitting Screens with Router

ft.Router and render_views. The back button doesn't appear because no View gets stacked. How to handle URL parameters and 404s.

AppBar and Navigation

The View owns the skeleton. Compute the selected bottom tab from the route. "Going deeper" is children; "switching" is siblings.

Dialogs and SnackBar

Whether something's open is state too. Call use_dialog every time. For undo, remember the position before deleting. When to use a confirmation versus an undo.

Theming and Dark Mode

Pass a single color to color_scheme_seed and get both light and dark palettes. The payoff for why colors written by role never break.

Responsive and Adaptive

ResponsiveRow can only change how things are arranged. To change the structure itself, watch width with on_resize. How to handle SafeArea and adaptive.

Chapter 5 — Data and Distribution (lessons 17–20)

You'll make the app remember things after it closes. Handle persistence, external APIs, charts and tables, and finish by packaging it with flet build into a distributable .app / .exe / .apk.

Persisting Data

Get the save location from FLET_APP_STORAGE_DATA. Write via a temp file and swap it in, and include a version from day one. SharedPreferences is a service.

Async Processing and External APIs

Isolate the networking layer down to a single exception type. timeout, 3 states, finally. Anything asyncio can't offload goes to run_thread.

Charts and DataTable

There's no ft.PieChart. Charts live in flet-charts. Legends are DIY, and series colors are fixed. DataTable never sorts itself.

Distributing with flet build

Building per OS and what each one requires. pyproject.toml's dependencies get bundled in. The difference between flet run --web and flet build web.

Once you've finished all 20 lessons, head over to the Python Fundamentals Course to strengthen your foundations, or the FastAPI Fundamentals Course to write the API side in the same language. A membership unlocks every course.