FastAPI Production

Pydantic v2 — your contract layer

Async, properly

Dependency injection — FastAPI's killer feature

SQLAlchemy 2.0 async — the new normal

Error handling — proper HTTP semantics

JWT auth done right

Testing with pytest + httpx

Deploying to Fly.io / Vercel / Railway

🏆 Capstone — build a SaaS subscription API

Path parameters and types

Pydantic request bodies

Response models

Dependency injection

JWT auth

Async DB with SQLAlchemy 2.0

Background tasks

Testing with httpx ASGITransport

CORS middleware gotchas

Deploying with gunicorn + uvicorn

🎯 Review: FastAPI module 1 recap

WebSockets in FastAPI

Server-Sent Events (SSE) streaming

File uploads (single + multi)

Background workers (Celery / arq / RQ)

Caching responses with Redis

Rate limiting with slowapi

API versioning strategies

OpenAPI customization + Swagger UI tweaks

CORS deep-dive (allow_origin_regex)

Trusted host + HTTPS redirect middleware

Webhook receivers with signature verification

Idempotency keys (replay-safe POST)

Pagination: offset vs cursor

Search: filtering + sorting + faceting

Bulk operations (batch insert/update)

Long-polling vs WebSocket vs SSE

GraphQL with Strawberry on FastAPI

gRPC integration (when REST is wrong)

OpenTelemetry instrumentation

🏆 Capstone — production-ready SaaS API

🎯 Review: FastAPI module 2 recap

Microservices vs monolith — when to split

Service discovery in Kubernetes

API Gateway pattern

gRPC vs REST — when to switch

GraphQL with Strawberry

OAuth2 scopes — fine-grained authorization

Refresh token rotation

mTLS for service-to-service auth

HMAC webhook signature verification

Token bucket rate limiter

Sliding window log rate limiter

Circuit breaker pattern

Retries with exponential backoff + jitter

Bulkhead pattern — limit blast radius

Graceful shutdown + readiness probes

Connection pool sizing — DB and HTTP

DataLoader — eliminate the N+1 trap

Idempotency keys for mutating endpoints

API versioning + deprecation headers

🏆 Capstone — notifications microservice

🎯 Review: FastAPI module 3 recap

ASGI internals — scope, receive, send

Custom middleware — body-already-consumed

Background tasks — three tiers

Dependency injection — yield, sub-deps, scopes

SSE and streaming responses

WebSocket auth + reconnection

File uploads at scale — presigned URLs

SQLAlchemy 2.0 async — loading strategies

Async pitfalls — blocking the event loop

Pure-Python circuit breaker

Testing async — httpx ASGITransport

OpenAPI customization — tags, security, examples

SDK auto-generation from OpenAPI

CORS deep — preflight, credentials, regex

Settings + secrets with pydantic-settings

Structured logging + correlation IDs

Sentry, error budgets, sampling

Alembic with multi-tenant schemas

Health probes — shallow vs deep

🏆 Capstone — payments microservice end-to-end

🎯 Review: FastAPI module 4 recap

Pagination: offset/limit vs cursor

Rate limiting under load: Redis-backed token buckets

Response caching with Cache-Control + ETag

BackgroundTasks vs Celery vs ARQ

File uploads: streaming vs buffered

WebSockets: rooms with Redis Pub/Sub

Health checks: liveness vs readiness

OpenAPI customization

Connection pools: sizing

Structured logs with request_id (contextvars)

Sentry integration + sampling

OpenTelemetry for vendor-neutral tracing

Feature flags (GrowthBook / LaunchDarkly)

Multi-tenancy: row-level + Postgres RLS

API versioning: URL vs header

Pydantic v2 perf vs v1

Dependency scopes

CORS pitfalls

Deployment: gunicorn + uvicorn workers

🏆 Capstone: production-ready FastAPI checklist