feat: add modules 05/11/12, concept docs, and curriculum integration

- Module 05: Async Python (5 projects — asyncio, aiohttp, queues, async server)
- Module 11: Package Publishing (3 projects — pyproject.toml, build, TestPyPI)
- Module 12: Cloud Deployment (3 projects — Railway, Postgres, production checklist)
- Module infrastructure README with index of all 12 modules
- 8 new concept docs: imports, classes, async, HTTP, venvs, decorators, APIs, terminal
- Updated README.md with expansion modules section
- Updated PROGRESS.md with all 56 module project checkboxes
- Updated CLAUDE.md with module structure
- Updated projects/README.md and concepts/README.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: travisjneuman

CLAUDE.md

@@ -4,7 +4,7 @@
 
 ## What This Repo Is
 
-A comprehensive Python curriculum: zero tech experience to world-class full-stack mastery. Contains 50+ sequenced documents, 175+ hands-on projects across 12 levels, CI validation tooling, and a personalized study plan generator.
+A comprehensive Python curriculum: zero tech experience to world-class full-stack mastery. Contains 50+ sequenced documents, 175+ hands-on projects across 12 levels, 56 expansion module projects across 12 technology domains, CI validation tooling, and a personalized study plan generator.
 
 ## Learner Context
 
@@ -58,6 +58,24 @@ projects/ (hands-on practice):
   level-00-absolute-beginner/  → 15 exercises (no imports, no tests)
   level-0/ through level-10/   → 15 projects each (full structure)
   elite-track/                 → 10 advanced projects
+  modules/                     → 12 technology modules, 56 projects
+    01-web-scraping/           → requests, BeautifulSoup, CSV
+    02-cli-tools/              → click, typer, rich
+    03-rest-apis/              → requests, JSON, API clients
+    04-fastapi-web/            → FastAPI, Pydantic, JWT auth
+    05-async-python/           → asyncio, aiohttp, queues
+    06-databases-orm/          → SQLAlchemy, Alembic, sqlite3
+    07-data-analysis/          → pandas, matplotlib
+    08-testing-advanced/       → parametrize, mocking, hypothesis
+    09-docker-deployment/      → Docker, docker-compose, GitHub Actions
+    10-django-fullstack/       → Django, DRF, templates
+    11-package-publishing/     → pyproject.toml, build, TestPyPI
+    12-cloud-deploy/           → Railway, Postgres, production config
+
+concepts/ (reference docs):
+  Core: variables, loops, functions, collections, files, errors, types
+  Intermediate: imports, classes, decorators, virtual environments, terminal
+  Advanced: HTTP, APIs, async/await
 ```
 
 ## Session Workflow
@@ -73,10 +91,12 @@ When starting a learning session:
 - **level-00:** Single `exercise.py` + `TRY_THIS.md`, no tests, no imports
 - **level-0 through level-10:** Full structure (README, project.py, tests/, data/, notes.md)
 - **Elite track:** Advanced structure with architecture docs
+- **Expansion modules:** README, project.py (or app.py), requirements.txt, notes.md, tests/ where applicable
 
 ## Tech Stack
 
 - Python 3.11+
 - pytest (testing, from Level 0 onward)
 - Ruff (linting, from Level 0 onward)
 - Black (formatting, from Level 0 onward)
+- Expansion module libraries: requests, BeautifulSoup, click, typer, FastAPI, aiohttp, SQLAlchemy, pandas, matplotlib, Django, Docker

PROGRESS.md

@@ -138,3 +138,87 @@ Check off items as you complete them. This is your personal tracker.
 - [ ] Docs 36-45: Elite engineering track
 - [ ] Docs 46-50: Adaptive learning layer
 - [ ] Elite Track Projects (10 projects)
+
+---
+
+## Expansion Modules — Full-Stack Python
+
+### Module 01 — Web Scraping (after Level 2)
+- [ ] 01 Fetch a Webpage
+- [ ] 02 Parse HTML
+- [ ] 03 Extract Structured Data
+- [ ] 04 Multi-Page Scraper
+- [ ] 05 Save to CSV
+
+### Module 02 — CLI Tools (after Level 2)
+- [ ] 01 Click Basics
+- [ ] 02 Multi-Command CLI
+- [ ] 03 Interactive Prompts
+- [ ] 04 File Processor CLI
+- [ ] 05 Typer Migration
+
+### Module 03 — REST APIs: Consuming (after Level 2)
+- [ ] 01 First API Call
+- [ ] 02 Query Parameters
+- [ ] 03 POST and Auth
+- [ ] 04 Error Handling
+- [ ] 05 API Client Class
+
+### Module 04 — FastAPI Web Apps (after Level 3 + Module 03)
+- [ ] 01 Hello FastAPI
+- [ ] 02 CRUD API
+- [ ] 03 Database-Backed
+- [ ] 04 Authentication
+- [ ] 05 Full App
+
+### Module 05 — Async Python (after Level 3)
+- [ ] 01 Async Basics
+- [ ] 02 Concurrent Requests
+- [ ] 03 Async File Processing
+- [ ] 04 Producer-Consumer
+- [ ] 05 Async Web Server
+
+### Module 06 — Databases & ORM (after Level 3)
+- [ ] 01 SQLite Basics
+- [ ] 02 SQLAlchemy Models
+- [ ] 03 CRUD Operations
+- [ ] 04 Migrations with Alembic
+- [ ] 05 Query Optimization
+
+### Module 07 — Data Analysis (after Level 2)
+- [ ] 01 Pandas Basics
+- [ ] 02 Filtering and Grouping
+- [ ] 03 Data Cleaning
+- [ ] 04 Visualization
+- [ ] 05 Analysis Report
+
+### Module 08 — Advanced Testing (after Level 3)
+- [ ] 01 Parametrize
+- [ ] 02 Mocking
+- [ ] 03 Fixtures Advanced
+- [ ] 04 Property-Based Testing
+- [ ] 05 Integration Testing
+
+### Module 09 — Docker & Deployment (after Level 5)
+- [ ] 01 First Dockerfile
+- [ ] 02 Multi-Stage Build
+- [ ] 03 Docker Compose
+- [ ] 04 CI with GitHub Actions
+- [ ] 05 Production Config
+
+### Module 10 — Django Full-Stack (after Module 04 + Module 06)
+- [ ] 01 Django Setup
+- [ ] 02 Views and Templates
+- [ ] 03 Forms and Auth
+- [ ] 04 REST Framework
+- [ ] 05 Complete App
+
+### Module 11 — Package Publishing (after Level 3)
+- [ ] 01 Package Structure
+- [ ] 02 Build and Test
+- [ ] 03 Publish to PyPI
+
+### Module 12 — Cloud Deployment (after Module 04 + Module 09)
+- [ ] 01 Deploy to Railway
+- [ ] 02 Deploy with Database
+- [ ] 03 Production Checklist

README.md

@@ -1,13 +1,13 @@
-# Python SME Plan (Zero Experience -> Enterprise Python Builder)
+# Python Mastery Plan (Zero Experience -> World-Class Full-Stack Developer)
 Home: [README](./README.md)
 
 Last updated: **February 24, 2026**
 
-This repository is a complete beginner-to-advanced Python learning system designed for a real enterprise environment:
-- SolarWinds Orion
-- SolarWinds DPA
-- Custom MSSQL reporting backend
-- Browser-based dashboard delivery
+This repository is a complete beginner-to-expert Python learning system. It covers two tracks:
+
+**Enterprise Operations Track** — SolarWinds Orion, MSSQL, Excel automation, dashboards (the original core).
+
+**Full-Stack Expansion Modules** — Web scraping, CLI tools, REST APIs, FastAPI, async Python, databases/ORM, data analysis, advanced testing, Docker, Django, package publishing, and cloud deployment.
 
 The plan is hands-on first. You will learn by building, breaking, fixing, and explaining.
 
@@ -177,6 +177,21 @@ Exact click path if you follow `Next` in each file:
 - Elite extension projects live in [`./projects/elite-track`](./projects/elite-track) for top-tier architecture and systems depth.
 - Project index: [`./projects/README.md`](./projects/README.md)
 
+## Expansion modules (full-stack Python)
+12 technology modules with 56 hands-on projects covering the full Python ecosystem. Each module is self-contained with real libraries, not simulations.
+
+**After Level 2:** Web Scraping, CLI Tools, REST APIs, Data Analysis
+**After Level 3:** FastAPI, Async Python, Databases/ORM, Advanced Testing, Package Publishing
+**After Level 5:** Docker & Deployment, Django Full-Stack, Cloud Deployment
+
+Full module index: [`./projects/modules/README.md`](./projects/modules/README.md)
+
+## Concept reference docs
+Plain-language explanations of Python concepts at [`./concepts/README.md`](./concepts/README.md):
+- Core: variables, loops, functions, collections, files, errors, types
+- Intermediate: imports, classes, decorators, virtual environments, terminal
+- Advanced: HTTP, APIs, async/await
+
 ## Second-pass support packs
 - Screenshot checkpoints and study prompts:
   - [12_SCREENSHOT_CHECKPOINTS.md](./12_SCREENSHOT_CHECKPOINTS.md)

concepts/README.md

@@ -2,7 +2,8 @@
 
 Plain-language explanations of Python concepts. Use these when you need to understand something a project introduces.
 
-## Core Concepts
+## Core Concepts (start here)
+
 - [What is a Variable?](./what-is-a-variable.md)
 - [How Loops Work](./how-loops-work.md)
 - [Functions Explained](./functions-explained.md)
@@ -11,7 +12,22 @@ Plain-language explanations of Python concepts. Use these when you need to under
 - [Errors and Debugging](./errors-and-debugging.md)
 - [Types and Conversions](./types-and-conversions.md)
 
+## Intermediate Concepts (after Level 2)
+
+- [How Imports Work](./how-imports-work.md) — modules, packages, `__init__.py`
+- [Classes and Objects](./classes-and-objects.md) — OOP basics, `self`, inheritance
+- [Decorators Explained](./decorators-explained.md) — `@` syntax, wrapping functions
+- [Virtual Environments](./virtual-environments.md) — venv, pip, requirements.txt
+- [The Terminal — Going Deeper](./the-terminal-deeper.md) — pipes, redirects, env vars
+
+## Advanced Concepts (after Level 3)
+
+- [HTTP Explained](./http-explained.md) — requests, responses, status codes, headers
+- [API Basics](./api-basics.md) — REST, JSON, endpoints, authentication
+- [Async Explained](./async-explained.md) — async/await, event loops, concurrency
+
 ## How to use these
+
 - Read the concept page before or during a project
 - Each page has: explanation, code example, common mistakes
 - Come back to these whenever you forget how something works

concepts/api-basics.md

@@ -0,0 +1,119 @@
+# API Basics
+
+An **API** (Application Programming Interface) is a way for programs to talk to each other. When people say "API" in web development, they usually mean a web API — a server that accepts HTTP requests and returns data (usually JSON).
+
+## How APIs work
+
+```
+Your Python script          The API server
+       |                          |
+       |-- GET /posts ----------->|
+       |                          | (looks up posts in database)
+       |<-- 200 OK + JSON --------|
+       |                          |
+```
+
+Your script is the **client**. The API is the **server**. The conversation happens over HTTP.
+
+## REST — the most common API style
+
+REST (Representational State Transfer) is a set of conventions for designing APIs:
+
+| Action | HTTP Method | URL | Example |
+|--------|------------|-----|---------|
+| List all | GET | `/users` | Get all users |
+| Get one | GET | `/users/42` | Get user #42 |
+| Create | POST | `/users` | Create a new user |
+| Update | PUT | `/users/42` | Replace user #42 |
+| Delete | DELETE | `/users/42` | Delete user #42 |
+
+The URL identifies the **resource** (what you're working with). The HTTP method identifies the **action** (what you're doing to it).
+
+## Making API calls with Python
+
+```python
+import requests
+
+# GET — read data.
+response = requests.get("https://jsonplaceholder.typicode.com/posts/1")
+post = response.json()
+print(post["title"])
+
+# POST — create data.
+new_post = {"title": "My Post", "body": "Content here", "userId": 1}
+response = requests.post(
+    "https://jsonplaceholder.typicode.com/posts",
+    json=new_post,
+)
+print(response.status_code)    # 201 Created
+```
+
+## Building APIs with Python
+
+FastAPI lets you create APIs:
+
+```python
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/hello/{name}")
+def hello(name: str):
+    return {"message": f"Hello, {name}!"}
+```
+
+Run with `uvicorn app:app` and visit `http://localhost:8000/hello/Alice`.
+
+## Authentication
+
+Most APIs require you to prove who you are:
+
+**API Key** — a secret string you include in the request:
+```python
+response = requests.get(url, headers={"X-API-Key": "your-key-here"})
+```
+
+**Bearer Token (JWT)** — a token you get by logging in:
+```python
+response = requests.get(url, headers={"Authorization": "Bearer eyJ..."})
+```
+
+## Common public APIs for practice
+
+| API | URL | What it provides |
+|-----|-----|-----------------|
+| JSONPlaceholder | jsonplaceholder.typicode.com | Fake posts, users, comments |
+| Open Meteo | open-meteo.com | Weather data |
+| PokéAPI | pokeapi.co | Pokémon data |
+| REST Countries | restcountries.com | Country information |
+
+These are free, require no API key, and are safe to practice with.
+
+## Common mistakes
+
+**Not handling errors:**
+```python
+# Bad — crashes if the API is down.
+data = requests.get(url).json()
+
+# Good — check the response first.
+response = requests.get(url, timeout=10)
+response.raise_for_status()    # Raises an exception for 4xx/5xx
+data = response.json()
+```
+
+**Hardcoding API URLs:**
+```python
+# Bad
+requests.get("https://api.example.com/v2/users")
+
+# Good — use a variable or config.
+BASE_URL = "https://api.example.com/v2"
+requests.get(f"{BASE_URL}/users")
+```
+
+## Related exercises
+
+- [Module 03 — REST APIs: Consuming](../projects/modules/03-rest-apis/)
+- [Module 04 — FastAPI Web Apps](../projects/modules/04-fastapi-web/)
+- [concepts/http-explained.md](./http-explained.md)