Python Web & Backend Engineering
Build production web backends and full-stack apps in Python: HTTP and ASGI foundations, REST APIs with FastAPI, databases and ORMs (SQLAlchemy, Django), authentication and security, async and real-ti…
Build production web backends and full-stack apps in Python: HTTP and ASGI foundations, REST APIs with FastAPI, databases and ORMs (SQLAlchemy, Django), authentication and security, async and real-time features, and shipping with Django, DRF, testing, and Docker. Covers the FastAPI/Django/Flask ecosystem end to end for Python backend and full-stack roles.
6 phases · 45 projects · v1.1.0
Target roles: Backend Engineer (Python), Full-Stack Engineer (Python), API Engineer, Software Engineer
Stack: Python 3.12, FastAPI, Flask, Django, Pydantic, SQLAlchemy, PostgreSQL, Docker, pytest
PHASE 1 · 7 projects
Web & HTTP Foundations
Understand HTTP, WSGI/ASGI, and serve requests with Flask and FastAPI.
01 · featured
HTTP Fundamentals & a No-Framework Server
Build a tiny HTTP server with no web framework to learn methods, status codes, headers, and the request/response cycle — plus WSGI vs ASGI.
Python 3.12 · http.server · WSGI
02
Your First Flask App
Build a small Flask web app with routes, request handling, and JSON responses — your first real (WSGI) web framework after the no-framework server.
Python 3.12 · Flask
03 · featured
Your First FastAPI App
Build a FastAPI app with type-hinted path operations, automatic validation, and auto-generated interactive docs — the modern async Python API framework.
Python 3.12 · FastAPI · uvicorn · pydantic
04
Routing, Parameters & Response Models
Master FastAPI's parameter system — path, query, and body params with validation constraints — and response_model for shaping and filtering output.
Python 3.12 · FastAPI · pydantic
05
Server-Side Rendering with Jinja2
Render HTML pages from templates with Jinja2: template inheritance, passing data, loops/conditionals, and why autoescaping protects against XSS.
Python 3.12 · FastAPI · Jinja2
06
Dynamic UIs with HTMX
Add interactivity to server-rendered pages using HTMX — swap HTML fragments returned by your backend on user actions, no JavaScript framework required.
Python 3.12 · FastAPI · Jinja2 · HTMX
07
Calling External APIs (httpx)
Make your backend an HTTP client: call third-party APIs with httpx (sync and async), handle timeouts, retries, and errors, and keep API keys server-side.
Python 3.12 · httpx · FastAPI
PHASE 2 · 8 projects
REST APIs & Validation
Design clean REST APIs with FastAPI and Pydantic — params, validation, errors, docs, pagination, uploads.
01 · featured
REST API Design
Design and build a clean CRUD REST API for a resource: correct HTTP verbs and status codes, consistent resource URLs, and predictable behavior.
Python 3.12 · FastAPI · pydantic
02
Deep Validation with Pydantic
Go beyond basic types: field constraints, custom validators, nested models, computed fields, and clear validation errors — making your API reject bad data at the edge.
Python 3.12 · FastAPI · pydantic
03
Error Handling & Contracts
Give your API one consistent error shape with custom exceptions and FastAPI exception handlers, so clients always get predictable, useful errors without leaking internals.
Python 3.12 · FastAPI
04
Dependency Injection
Use FastAPI's Depends to share logic across endpoints — DB sessions, current-user lookup, pagination params, config — keeping handlers clean and testable.
Python 3.12 · FastAPI
05
Pagination, Filtering & Sorting
Add scalable list endpoints: offset and cursor pagination, safe filtering and sorting, and metadata so clients can page through large datasets without dumping the whole table.
Python 3.12 · FastAPI
06
File Uploads
Accept file uploads safely in FastAPI: enforce type and size limits, store files, serve them back, and reject dangerous or oversized files.
Python 3.12 · FastAPI · python-multipart
07
API Versioning
Evolve an API without breaking existing clients: URL vs header versioning, organizing versioned routers, and a deprecation strategy.
Python 3.12 · FastAPI · APIRouter
08
OpenAPI & Docs Customization
Polish your API's auto-generated OpenAPI docs: tags, summaries, descriptions, examples, response documentation, and metadata — so the interactive docs are genuinely useful.
Python 3.12 · FastAPI · OpenAPI
PHASE 3 · 8 projects
Databases & ORMs
Model and query relational data with SQLAlchemy and Django ORM, with migrations and transactions.
01
SQLAlchemy Core & Connections
Connect to a database and run queries with SQLAlchemy Core: engine, connections, parameterized statements, and the connection lifecycle — the layer the ORM is built on.
Python 3.12 · SQLAlchemy · SQLite
02 · featured
SQLAlchemy ORM
Map Python classes to database tables with the SQLAlchemy ORM: declarative models, sessions, and full CRUD using objects instead of raw SQL.
Python 3.12 · SQLAlchemy · SQLite
03
Relationships & Joins
Model connections between tables — one-to-many and many-to-many — with foreign keys and SQLAlchemy relationships, and query across them with joins.
Python 3.12 · SQLAlchemy · SQLite
04 · featured
The N+1 Problem & Eager Loading
Diagnose and fix the N+1 query problem — the most common ORM performance bug — using eager loading (joinedload/selectinload) and query inspection.
Python 3.12 · SQLAlchemy · SQLite
05
Schema Migrations with Alembic
Manage database schema changes with Alembic: generate migrations from model changes, apply and roll them back, and keep environments in sync.
Python 3.12 · Alembic · SQLAlchemy
06
Transactions & Data Integrity
Make multi-step database operations all-or-nothing with transactions (commit/rollback), and use constraints and isolation to keep data consistent under concurrency.
Python 3.12 · SQLAlchemy · SQLite
07
The Django ORM
Use Django's batteries-included ORM: models, the QuerySet API, migrations, relationships, and the admin — contrasting it with SQLAlchemy.
Python 3.12 · Django
08
The Repository Pattern
Decouple business logic from data access with a repository layer, so your code depends on an interface (not the ORM) and is easy to test and swap.
Python 3.12 · SQLAlchemy
PHASE 4 · 7 projects
Authentication & Security
Secure an API: password hashing, JWT/OAuth, sessions, RBAC, CSRF/CORS, rate limiting.
01 · featured
Password Hashing
Store passwords safely: hash with a slow, salted algorithm (bcrypt/argon2), verify on login, and learn why you must never store or encrypt plaintext passwords.
Python 3.12 · passlib · bcrypt
02 · featured
JWT Authentication
Implement token-based auth in FastAPI: issue a signed JWT on login, protect routes by verifying it, and understand what a JWT is, what it isn't, and where to store it.
Python 3.12 · FastAPI · PyJWT
03
OAuth2 & Social Login
Let users log in with a third-party provider (a hyperscaler/GitHub) via the OAuth2 authorization-code flow, learning what OAuth delegates and why you never handle the user's provider password.
Python 3.12 · FastAPI · Authlib
04
Sessions & Cookies
Implement classic server-side session auth with secure cookies: create a session on login, store it server-side, and set cookies with the right security flags.
Python 3.12 · FastAPI
05
Authorization & RBAC
Control what authenticated users can do with role-based access control: assign roles, restrict endpoints by role, deny by default, and keep checks where they can't be bypassed.
Python 3.12 · FastAPI
06
CSRF, CORS & Web Security
Defend against cross-site attacks: configure CORS correctly, protect against CSRF, and apply key web-security headers and input-handling habits.
Python 3.12 · FastAPI
07
Rate Limiting
Protect endpoints from abuse with per-client rate limiting: implement a limiter, return 429 with the right headers, and understand fixed-window vs token-bucket and why in-memory limits fail at scale.
Python 3.12 · FastAPI · Redis
PHASE 5 · 7 projects
Async & Real-Time
Build async endpoints, WebSockets, SSE, background jobs (Celery), and caching.
01
Async Endpoints & Async Databases
Write truly async FastAPI endpoints with an async database driver, learning when async helps, the danger of blocking calls in async code, and async sessions.
Python 3.12 · FastAPI · SQLAlchemy async · asyncpg
02 · featured
WebSockets
Build real-time, bidirectional communication with WebSockets in FastAPI: a chat/broadcast server that pushes messages to connected clients instantly.
Python 3.12 · FastAPI · WebSockets
03
Server-Sent Events (SSE)
Stream one-way real-time updates from server to client with Server-Sent Events — simpler than WebSockets for live feeds, notifications, and progress updates.
Python 3.12 · FastAPI · SSE
04
Background Tasks
Do slow work after responding using FastAPI BackgroundTasks — send emails, write logs, process data without making the client wait — and learn its limits.
Python 3.12 · FastAPI
05 · featured
Distributed Jobs with Celery & Redis
Run durable, scalable background jobs with Celery and a Redis broker: enqueue tasks, process them in separate workers, track status, and handle retries and failures.
Python 3.12 · Celery · Redis · FastAPI
06
Caching with Redis
Speed up expensive reads by caching results in Redis: cache-aside pattern, TTLs, and correct invalidation on writes — the classic performance win with the classic hard problem.
Python 3.12 · FastAPI · Redis
07
Streaming Responses
Stream large or generated responses instead of building them fully in memory: StreamingResponse for big files/exports and chunked generation, keeping memory flat.
Python 3.12 · FastAPI
PHASE 6 · 8 projects
Frameworks, Testing & Deployment
Ship with Django/DRF, GraphQL, automated tests, and a deployed, containerized service.
01 · featured
A Full Django App
Build a complete Django app end to end: models, migrations, views, URL routing, templates, and forms — using Django's integrated, convention-driven stack.
Python 3.12 · Django
02
Django REST Framework
Build a REST API the Django way with DRF: serializers, viewsets, routers, and the browsable API — getting full CRUD endpoints with minimal code.
Python 3.12 · Django · Django REST Framework
03
GraphQL with Strawberry
Build a GraphQL API with Strawberry: define a schema with types, queries, and mutations, and learn how GraphQL differs from REST — and its tradeoffs like the N+1 problem.
Python 3.12 · Strawberry · FastAPI
04 · featured
Testing Web APIs
Write automated tests for a FastAPI app with TestClient and pytest: test endpoints end-to-end, cover success and failure paths, and override dependencies to isolate the unit under test.
Python 3.12 · FastAPI · pytest
05
Database Testing
Test code that uses a database against a real test database with fixtures and per-test isolation (transaction rollback), so tests are realistic yet fast and independent.
Python 3.12 · FastAPI · SQLAlchemy · pytest
06 · featured
Containerize & Serve in Production
Package a FastAPI app in Docker and run it with a production ASGI server (uvicorn workers / gunicorn), with multiple workers, health checks, and reverse-proxy awareness.
Python 3.12 · FastAPI · Docker · gunicorn · uvicorn
07
Logging, Config & Observability
Make a web app operable: structured request logging, environment-based settings (Pydantic Settings), and basic observability so you can debug production from logs.
Python 3.12 · FastAPI · pydantic-settings
08 · featured
Deploying to Production
Deploy your containerized app to a reachable URL with a hosted database, production config, and a deploy checklist — the last mile that makes your work real.
Python 3.12 · FastAPI · Docker · cloud
Next step
Request Python Web & Backend Engineering
An advisor reviews the fit and confirms terms in writing. A request is not an acceptance and nothing is charged until you agree.