Free through lesson 3

FastAPI for Beginners

From setting up your environment through validation from type hints, dependency injection, SQLAlchemy 2.0, authentication and authorisation, and testing, all the way to deploying to production with Docker. Twenty lessons that build one task management API from the first line to the last. Every piece of code and command output was produced by actually running Python 3.13 and FastAPI 0.141.

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are grouped into five chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: FastAPI cannot run inside the browser, so try everything in the project you create in lesson 1.

Chapter 1 — Getting started (lessons 1–2)

You create a virtual environment, stand up your first endpoint, and see how type hints become validation and documentation on their own. By the end you understand why the order you register routes in changes the result.

1

Setting up and your first endpoint

Creating a virtual environment, installing fastapi[standard] and standing up three endpoints. Returning a dict gives you JSON, and /docs appears on its own.

Free
2

Path parameters and type conversion

Receiving part of the URL as a function argument. How a type hint doubles as conversion and validation, and why fixed paths come before variable ones.

Free

Chapter 2 — Requests and responses (lessons 3–6)

A full pass over the way in and the way out of an API: query parameters, bodies and responses. Finally you measure the difference between async def and def so you can decide which to write yourself.

3

Query parameters and Annotated

Any argument not in the path becomes a query parameter. A default value decides required versus optional, and constraints, descriptions and aliases go in Annotated.

Free
4

Receiving a request body with Pydantic models

Write the shape of the JSON you want as a class and get validation, conversion and documentation with it. Including how to write a PATCH that does not wipe out the keys you did not send.

🔒 Basic
5

Response models and status codes

Separating an output model to structurally prevent returning fields you must not. How to return 201 and 204, and how to add headers.

🔒 Basic
6

Choosing between async def and def

The same "wait one second" takes one second or five depending on how you write it. Measure it, then decide which to use.

🔒 Basic

Chapter 3 — Structure and validation (lessons 7–10)

You split main.py up, write shared logic as dependencies, and settle the shape of input checks and errors. Everything in the second half — the database, authentication and tests — sits on the foundation you build here.

7

Splitting the project with APIRouter

Separating files by feature and keeping main.py as a table of contents. How to use prefix and tags, and how to fix the import errors that appear right after you split.

🔒 Basic
8

Dependency injection (Depends)

The mechanism for writing shared logic as an argument. Creating type aliases, writing guards, and cleaning up with yield. Everything in the second half sits on this.

🔒 Basic
9

Building out validation

Constraints with Field, transformation with field_validator, and cross-field checks with model_validator. Plus extra="forbid", so unknown keys are not silently discarded.

🔒 Basic
10

Error handling and exception handlers

Raise your own exceptions that know nothing about HTTP, and do the conversion in one place. Turn a 500 for a missing ID into a 404, and reshape the 422 body into your own format.

🔒 Basic

Chapter 4 — The database (lessons 11–15)

You store data with SQLAlchemy 2.0 and implement CRUD, relationships, search and file attachments. For the N+1 problem, you count the actual SELECT statements to confirm it.

11

Connecting a database with SQLAlchemy 2.0

One engine, one session per request. A yield dependency keeps it to one session per request, and models.py and schemas.py stay separate.

🔒 Basic
12

Completing CRUD (PUT versus PATCH)

Moving the SQL out of the router into crud.py, then applying PUT and PATCH to the same record to see the difference in the response. Duplicates get a 409.

🔒 Basic
13

Relationships and the N+1 problem

Getting clear on the difference between ForeignKey and relationship, then counting the SELECT statements to see the N+1. Eleven queries become two.

🔒 Basic
14

Search, paging and sorting

Returning a list as "this page plus the total count". Extracting the condition building into a function, and closing the sort fields with an Enum.

🔒 Basic
15

Forms and file uploads

Receiving with UploadFile, counting the size as you read, and choosing the stored name yourself. Written on the assumption that Content-Length and content_type are both self-declared.

🔒 Basic

Chapter 5 — Authentication and running in production (lessons 16–20)

You add JWT authentication and authorisation, CORS, background work and tests. Finally you push configuration out into environment variables and get it production-ready with Alembic and Docker.

16

Authentication with the OAuth2 password flow and JWT

pwdlib, not passlib. PyJWT, not python-jose. From hashing through token verification to the Authorize button in /docs actually working.

🔒 Basic
17

Authorisation, CORS and middleware

Being signed in and being allowed to touch it are different things. Ownership checks on single items, filtering on lists. Also CORS, which curl will never reproduce.

🔒 Basic
18

Background tasks, lifespan and logging

Adding 0.3 seconds of post-processing still leaves a 0.006-second response. The limits of BackgroundTasks, start-up and shutdown work with lifespan, and why print has to go.

🔒 Basic
19

Writing tests (dependency_overrides)

Because there is dependency injection, you can test the whole API without a real database. In-memory SQLite, layering fixtures, and testing the permission logic.

🔒 Basic
20

Configuration, Alembic and going to production with Docker

Gathering configuration into BaseSettings and failing at start-up when something is missing. From create_all to Alembic, and on to a multi-stage Docker image.

🔒 Basic

Once you have finished all 20 lessons, learn to run this API in a container with Docker. Membership unlocks every course.