Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

FastAPI Complete Course: JWT, SQLModel, Celery & Deployment

Name: FastAPI Complete Course: JWT, SQLModel, Celery & Deployment
Rating: 4.1 (25 reviews)

Master FastAPI: Build REST APIs with JWT, Async SQLModel, RBAC, Celery, Redis, Email, Testing & Production Deployment

Created byEduVerse Academy

Last updated 1/2026

English

English [Auto],

What you'll learn

Build FastAPI projects from scratch with modular structure and organized API routers for scalable applications.
Handle path & query parameters, request bodies, headers, and run web servers efficiently.
Develop CRUD REST APIs with validation, response models, exception handling, and async operations using SQLModel.
Implement JWT authentication, refresh tokens, HTTP Bearer Auth, and token revocation using Redis.
Create user accounts, enable email verification, password resets, and secure role-based access control (RBAC).
Manage background tasks with FastAPI and Celery + Redis, including monitoring and async job handling.
Document APIs professionally with SwaggerUI and Redoc, and perform unit & integration testing with Pytest, Mock, Schemathesis.
Deploy production-ready FastAPI applications with PostgreSQL, Celery, Redis, and cloud platforms.

Course content

10 sections • 25 lectures • 15h 5m total length

Introduction and Project Setup (Part 1)8:00
Learn to build web applications with fast api, and set up a project with a virtual environment, install fast api, and verify the first api application.
Web Server Basics: Path & Query Params, Request Body, Headers (Part 2)42:13
Build a FastAPI web server by creating a main app, defining get and post endpoints with path and query parameters, and validating request bodies and headers with Pydantic models.
Build a CRUD REST API: Response Models, Validation, and Exceptions (Part 3)33:36
Build a CRUD rest API for books with create, read, update, and delete operations in an in-memory store, using FastAPI, Pydantic models, response models, and error handling.
Modular Project Structure with FastAPI Routers (Part 4)14:56
Learn to modularize a FastAPI app by creating API routers, moving book data and schemas into a books package, and exposing endpoints under a versioned /api/v1/books prefix.

Databases with SQLModel: Connection, Lifespan Events, and Models (Part 5)48:41
Use sqlmodel with PostgreSQL to replace in-memory data; set up neon or PostgreSQL, configure env vars, and implement an engine, lifespan events, and a uuid book model with timestamps.
CRUD with Async SQLModel: Introduction to Dependency Injection (Part 6)1:06:28
Learn to implement a complete async CRUD service with SQLModel in FastAPI, including dependency injection of an async session, a dedicated book service, and create, read, update, delete operations.
Create a User Authentication Model (Database Migrations with Alembic) (Part 7)26:22
Set up a user authentication model with SQLModel, add uuid, username, email, and is_verified fields, and manage migrations with Alembic to create the users table.
User Account Creation: Email & Password (Part 8)43:10
Create a FastAPI user signup flow by building an auth router, defining signup schemas, hashing passwords with a util, migrating with Alembic, and wiring a user service with dependency injection.

JWT Authentication: Create Access and Refresh Tokens (Part 9)30:59
Learn to implement jwt authentication in FastAPI by creating access and refresh tokens, encoding user claims, and validating tokens for protected endpoints.
JWT Authentication: Protect Endpoints with HTTP Bearer Auth (Part 10)19:23
Protect endpoints with HTTP bearer authentication in FastAPI by creating an access token bearer dependency, decoding and validating JWT tokens, and returning user details for authorized requests.
JWT Authentication: Renew User Access Using Refresh Tokens (Part 11)16:50
Learn how to renew a user's access token with refresh tokens in a FastAPI JWT setup, including token pair and a refresh endpoint that issues a new access token.
JWT Authentication: Revoke Access Tokens Using Redis (Part 12)17:34
This lecture demonstrates revoking tokens on the server side using Redis as a token blacklist. It implements a logout endpoint that adds the token's JWT id to the Redis block list, rendering the token invalid and requiring a new token.
Role-Based Access Control Using Dependency Injection (User Roles) (Part 13)32:00
Explore role-based access control in a simple FastAPI app by implementing admin and user roles with permissions, using dependency injection and a role checker to guard endpoints.

Model and Schema Relationships: One-to-Many SQLModel (Part 14)26:27
Explore one-to-many relationships with SQLModel by linking users to submitted books, using a foreign key and relationship attributes to serialize and expose related data through API endpoints.
More Database and Schema Relationships (Part 15)54:21
Expand one-to-many relationships among users, books, and reviews. Fix serialization with a user books model and add a reviews table via Alembic; expose a review API returning books with reviews.

Error Handling: Custom API Exceptions (Part 16)33:36
Learn to implement custom error handling in FastAPI by creating an errors module with application-specific exceptions and attaching handlers to return detailed, consistent error responses.
Middleware: Custom Logging and CORS (Part 17)32:08
Learn to implement FastAPI middleware, including custom http logging and cors via asgi middleware, and attach authorization checks and error handling to requests and responses.

User Account Verification via Email (Part 18)1:03:09
Implement email verification and password resets in a FastAPI app by sending verification emails with a mail module, generating and decoding url-safe tokens using itsdangerous, and updating user is_verified.
Handling Password Resets (Part 19)33:00
Implement an email-based password reset flow with a password reset request and a password reset confirm endpoint, using tokenized links and account verification checks before accessing protected endpoints.

API Documentation with Swagger and Redoc (Part 21)12:06
Document your FastAPI with OpenAPI specification using Swagger and Redoc, automatically generating clear documentation from defined endpoints and Pydantic models.
API Testing with Unittest Mock, Pytest & Schemathesis (Part 22)33:11
Learn to implement automated api testing using unittest mock, pytest, and Schemathesis, including dependency overrides, fixtures, test clients, and OpenAPI driven test generation.

Deploying FastAPI, PostgreSQL, Celery & Redis (Part 23)43:06
Deploy a FastAPI web service with a PostgreSQL database, Redis as broker, and Celery workers on Render, configuring environment variables, migrations with Alembic, and a Redis-backed task queue.
Testing a FastAPI App with Pytest1:11:20
Create effective integration tests for FastAPI apps using pytest, the FastAPI test client, fixtures, and dependency overrides to test endpoints, data validation, and database interactions.

Requirements

Basic Python knowledge (variables, functions, loops, lists, dicts).
Familiarity with REST API concepts is helpful but not required.
Willingness to learn databases, async operations, JWT auth, and FastAPI basics.

Description

Learn how to build, secure, test, and deploy FastAPI applications from scratch! FastAPI is one of the fastest-growing Python frameworks for building high-performance APIs, and mastering it will take your backend development skills to the next level.

This course is designed for beginners and experienced developers alike. Whether you have some experience with Python and APIs or are starting from zero, I will guide you step by step through every concept, making complex topics easy to understand and immediately applicable. Every lecture is hands-on, ensuring you learn by doing, and focuses on creating production-ready, secure, and scalable applications.

You will start with project setup and web server fundamentals, learning how to handle path and query parameters, request bodies, headers, and run your FastAPI server efficiently. You’ll organize your API using FastAPI routers and modular project structure for maintainability.

Dive into databases using SQLModel, including asynchronous CRUD operations, dependency injection, database connection management with lifespan events, and advanced model and schema relationships. You’ll also learn database migrations using Alembic to manage production-ready databases.

Security is a core focus of this course. You will implement JWT authentication with access and refresh tokens, protect endpoints with HTTP Bearer Auth, handle token revocation using Redis, and apply role-based access control (RBAC) to manage user permissions efficiently. Additionally, you’ll build full user account functionality including email verification, password resets, and secure account creation.

Learn how to implement background tasks and asynchronous processing using FastAPI Background Tasks and Celery with Redis, along with monitoring Celery tasks using Flower. Build professional middleware, custom logging, and configure CORS and trusted hosts for robust applications.

You will also master API documentation with SwaggerUI and Redoc, ensuring your APIs are well-documented and developer-friendly. Testing is a key component: gain hands-on experience with unit and integration tests using Pytest, Unittest Mock, and document-driven testing with Schemathesis.

Finally, you’ll deploy your FastAPI application to production environments with PostgreSQL, Celery, Redis, and cloud platforms, creating a fully deployable, real-world application ready for users.

By the end of this course, you will have mastered the complete FastAPI workflow, from project setup to advanced authentication, database management, background processing, testing, and production deployment. These skills are in high demand and can help you advance your career, secure freelance projects, or build your own production-ready applications.

Topics and practical features covered in this course include:

FastAPI project setup and modular structure
Web server basics: path & query parameters, request bodies, headers
Running FastAPI CLI, choosing HTTP clients, and server management
CRUD REST API development with response models, validation, and exception handling
Organizing API paths with routers for scalable architecture
Databases with SQLModel: async setup, connection management, table creation, CRUD operations
Dependency injection for service classes and path handlers
User authentication models, database migrations with Alembic
User account creation: email, password, and secure endpoints
JWT authentication: access & refresh tokens, HTTP Bearer Auth, token renewal, and revocation
Role-Based Access Control (RBAC) and managing user roles
Advanced model and schema relationships (one-to-many, multiple relationships)
Error handling, custom API exceptions, and registering exception handlers
Middleware: custom logging, ASGI middleware, CORS configuration, trusted hosts
Email integration: FastAPI-Mail setup, sending emails, user account verification
Password reset flows and secure handling
Background tasks with FastAPI and Celery + Redis
Celery monitoring using Flower
API documentation with SwaggerUI and Redoc
API testing with Pytest, Unittest Mock, and Schemathesis
Deployment to production with PostgreSQL, Celery, Redis, and cloud platforms

All lectures are hands-on with full source code, and each topic is demonstrated step by step, ensuring you learn by building real-world applications. This course provides everything you need to become a confident, professional FastAPI developer.

Who this course is for:

Backend developers wanting to master FastAPI and build production-ready APIs.
Python programmers seeking advanced web development skills.
Beginners with basic Python knowledge aiming to learn modern API frameworks.
IT professionals looking to implement JWT authentication and RBAC.
Developers interested in async databases with SQLModel and dependency injection.
Anyone wanting to handle background tasks with Celery and Redis.
Programmers wanting to test APIs using Pytest, Unittest Mock, and Schemathesis.
Developers who want to deploy secure, scalable FastAPI applications to production.

FastAPI Complete Course: JWT, SQLModel, Celery & Deployment

What you'll learn

Explore related topics

Course content

Introduction & Project Setup4 lectures • 1hr 39min

Databases & SQLModel4 lectures • 3hr 5min

Authentication & User Management5 lectures • 1hr 57min

Databases Relationships & Advanced SQLModel2 lectures • 1hr 21min

Error Handling & Middleware2 lectures • 1hr 6min

Security Features & User Flows2 lectures • 1hr 36min

Background Tasks & Asynchronous Jobs1 lecture • 43min

Documentation & Testing2 lectures • 45min

Final Testing & Deployment2 lectures • 1hr 54min

FastAPI with MongoDB & Beanie (NoSQL Alternative)1 lecture • 1hr

Requirements

Description

Who this course is for: