Intermediate Backend Development with FastAPI Course

Lesson 1 • Path and Query Parameters

Teaches extraction and validation of path and query parameters using Python type hints. Demonstrates automatic OpenAPI documentation generation.

Lesson 2 • First Complete API Endpoint

Integrates all foundational concepts into a single working endpoint with validation and documentation. Serves as a checkpoint before advancing to data modelling.

Lesson 3 • Core Request-Response Cycle

Explains how FastAPI processes HTTP requests through path operations and returns responses. Connects ASGI concepts to practical route definitions.

Lesson 4 • Installing and Configuring FastAPI

Sets up a virtual environment, installs FastAPI and Uvicorn, and verifies the installation. Provides the baseline environment for all subsequent chapters.

Lesson 1 • Nested Models and Complex Types

Builds hierarchical data structures using nested models, lists, and dicts. Prepares students for real-world payloads with complex shapes.

Lesson 2 • Pydantic Settings and Configuration

Uses pydantic-settings to manage environment variables and app configuration. Establishes a config pattern reused in database and security chapters.

Lesson 3 • Field Constraints and Validators

Applies Field() constraints and custom validators to enforce business rules. Demonstrates how validators integrate with FastAPI request bodies.

Lesson 4 • Pydantic BaseModel Essentials

Introduces BaseModel, field declarations, and automatic validation. Connects Pydantic's role to FastAPI's request parsing pipeline.

Lesson 1 • Middleware Concepts and Custom Middleware

Teaches request/response middleware for cross-cutting concerns like logging and timing. Connects middleware to FastAPI's ASGI stack.

Lesson 2 • APIRouter for Modular Routing

Splits routes into domain-specific routers and mounts them on the main app. Reduces coupling and improves code discoverability.

Lesson 3 • CORS and Trusted Host Configuration

Configures CORS and trusted host policies to secure browser-facing APIs. Demonstrates environment-specific policy settings.

Lesson 4 • Application Lifespan and Startup Events

Uses the lifespan context manager to initialise and tear down resources cleanly. Prepares students for database connection pooling in later chapters.

Lesson 1 • CRUD Operations with Async ORM

Implements create, read, update, and delete operations using async SQLAlchemy queries. Demonstrates repository pattern for clean separation of concerns.

Lesson 2 • Pagination and Filtering Patterns

Implements offset/cursor pagination and dynamic filtering for list endpoints. Connects query parameter models to SQLAlchemy query construction.

Lesson 3 • Database Migrations with Alembic

Manages schema evolution using Alembic migration scripts. Covers auto-generation, manual edits, and rollback strategies.

Lesson 4 • Defining ORM Models

Maps Python classes to database tables using SQLAlchemy's declarative syntax. Covers column types, constraints, and relationships.

Lesson 1 • JWT Token Generation and Validation

Creates and verifies JSON Web Tokens for stateless authentication. Covers token payload design, expiry, and signature verification.

Lesson 2 • Role-Based Access Control

Adds user roles and permission checks as reusable dependencies. Demonstrates how to enforce access policies without duplicating logic.

Lesson 3 • Password Hashing and User Registration

Hashes passwords with bcrypt and stores user credentials securely. Establishes the user model and registration endpoint used throughout this chapter.

Lesson 4 • OAuth2 Password Flow in FastAPI

Implements the OAuth2 password bearer flow using FastAPI's built-in security utilities. Connects token issuance to the login endpoint.

Lesson 1 • Database Testing with Transactions

Runs integration tests against a real database using transaction rollback for isolation. Ensures tests are repeatable without manual cleanup.

Lesson 2 • Mocking Dependencies and External Services

Overrides dependencies and mocks external calls to isolate unit tests. Prevents test pollution from databases and third-party APIs.

Lesson 3 • Testing Endpoints with TestClient

Uses FastAPI's TestClient to send HTTP requests and assert responses. Covers status codes, response bodies, and header assertions.

Lesson 4 • Pytest Setup for FastAPI

Configures pytest with fixtures, conftest files, and async support for FastAPI. Establishes the test infrastructure used in all subsequent test sections.

Lesson 1 • Response Caching with Redis

Implements response caching using Redis to reduce database load on hot endpoints. Covers cache invalidation strategies and TTL management.

Lesson 2 • Database Query Optimisation

Identifies and resolves N+1 query problems and slow queries in SQLAlchemy. Applies eager loading and query analysis to improve response times.

Lesson 3 • Integrating Celery for Async Task Queues

Connects FastAPI to Celery with a message broker for durable background processing. Covers task definition, dispatch, and result retrieval.

Lesson 4 • FastAPI Background Tasks

Offloads non-blocking work using FastAPI's BackgroundTasks. Covers use cases, limitations, and comparison with task queues.

Lesson 1 • REST API Design Best Practices

Applies resource naming, HTTP semantics, and idempotency principles to API design. Produces consistent, intuitive APIs that follow industry conventions.

Lesson 2 • Containerisation and Deployment

Packages the FastAPI app in a Docker container and deploys it with Gunicorn and Uvicorn workers. Covers health checks and graceful shutdown.

Lesson 3 • API Versioning Strategies

Compares URL path, header, and query-param versioning approaches. Implements a versioned router structure that supports parallel API versions.

Lesson 4 • OpenAPI Customisation and Documentation

Customises the auto-generated OpenAPI schema with metadata, examples, and tags. Produces developer-friendly documentation for API consumers.