Phase 1 — Python Foundations (16 hours)

Session 1 (4h) – Python Fundamentals & Problem Solving

Focus: Syntax + real-world logic
Topics:

• Python basics: variables, functions, loops, conditionals

• Lists, dicts, sets, tuples

• Functions with type hints

• Reading/writing files, working with JSON

• Command-line arguments & user input
  Hands-on Project:
  🧠 “Task Tracker CLI” — A small console app that stores and lists user tasks from a JSON file.
  (Students immediately connect programming to a useful real-world tool.)

Session 2 (4h) – OOP, Design Thinking, and Clean Code

Focus: Build maintainable Python systems
Topics:

• Classes, methods, attributes, encapsulation

• Inheritance and polymorphism

• SOLID principles intro

• Dataclasses & typing

• Error handling and logging
  Hands-on Project:
  💡 “Library Management System” — Books, Members, and Loans classes with inheritance (e.g. EBook, PrintedBook).
  Includes saving/loading state from disk.

Session 3 (4h) – Async & Real Concurrency

Focus: Async mindset for modern backend
Topics:

• Sync vs async, I/O vs CPU-bound

• asyncio, coroutines, await, event loop

• Gathering multiple tasks concurrently

• Using aiohttp for async HTTP requests
  Hands-on Project:
  ⚡ “Image Metadata Fetcher” — Async app that fetches and saves metadata (e.g. title, size) for multiple image URLs concurrently.

Session 4 (4h) – Python Tooling & Software Practice

Focus: Structure, tooling, maintainability
Topics:

• Virtualenv, Poetry

• Logging, .env, and config files

• Folder structure for modular Python projects

• Git & GitHub basics
  Hands-on:
  🔧 Refactor previous async project into a modular package with logger, config, and services folders.

Phase 2 — FastAPI & Docker Foundation (12 hours)

Session 5 (4h) – HTTP & FastAPI Basics

Focus: Building REST APIs
Topics:

• HTTP overview (methods, headers, status codes)

• FastAPI, Uvicorn setup

• Path, query, and body parameters

• Pydantic models
  Hands-on:
  “User API” — Build simple CRUD for User (in-memory).

Session 6 (4h) – Docker & Local Environment

Focus: Professional local dev setup
Topics:

• Docker intro (images, containers, volumes)

• Docker Compose basics

• Running FastAPI in Docker

• Live reload in Docker environment
  Hands-on:
  Containerize User API with Docker Compose.
  Students run docker-compose up and see live service updates.

Session 7 (4h) – Project Bootstrap

Focus: Start the enterprise project
Topics:

• Create structured FastAPI project (core, api, models, services)

• Config management

• Add basic routes and health check

• Add logging to file
  Hands-on:
  Initialize Enterprise Project: “E-Commerce Backend”
  Docker Compose includes: fastapi + elasticsearch (for logs, placeholder setup)

Phase 3 — Databases & Persistence (8 hours)

Session 8 (4h) – SQL, NoSQL, and ORM

Focus: Data modeling and persistence
Topics:

• PostgreSQL intro + SQL basics (DDL, DML)

• NoSQL (MongoDB) concepts

• Async ORM (SQLModel)

• Database migrations with Alembic
  Hands-on:
  Add PostgreSQL to Docker Compose

• Create User, Role, Permission models

• Implement CRUD via SQLModel

Session 9 (4h) – Repository & Service Layers

Focus: Clean data access
Topics:

• Repository pattern

• Service layer logic

• DTOs, validation
  Hands-on:
  Implement “Permission Management Service”
  Students add repository + service layers for user permissions.
  Docker Compose now: fastapi, postgres, elasticsearch

Phase 4 — Caching & Authentication (8 hours)

Session 10 (4h) – Redis & Caching

Focus: Performance optimization
Topics:

• Caching patterns (read/write-through, TTL)

• Redis setup & integration
  Hands-on:
  Add Redis to Docker Compose
  Cache product listings and user sessions.

Session 11 (4h) – Authentication & OAuth

Focus: Secure backend
Topics:

• JWT and OAuth2

• Password hashing

• Role-based access control
  Hands-on:
  Implement Login & OAuth APIs

• Google login simulation

• Session caching in Redis

Phase 5 — Software Architecture & E-Commerce Design (8 hours)

Session 12 (4h) – Architecture Principles

Focus: Build scalable systems
Topics:

• Clean Architecture and DDD

• SOLID in real backend code

• Design patterns in FastAPI context

• Logging and tracing best practices
  Hands-on:
  Send logs to Elasticsearch from FastAPI using Logstash
  Add log stream to elasticsearch container.

Session 13 (4h) – E-commerce Domain

Focus: Practical design
Topics:

• Entities: Product, Category, Banner, Zone

• Business logic for pricing, inventory

• API versioning
  Hands-on:
  Implement Product, Category, and Banner APIs
  Integrate with Redis for product cache.
  Docker Compose now: fastapi, postgres, redis, elasticsearch

📨 Phase 6 — Event-Driven Design (4 hours)

Session 14 (4h) – RabbitMQ & Event Systems

Focus: Event-driven thinking
Topics:

• Message brokers & queues

• Publisher/subscriber pattern

• Async tasks with aio-pika or Celery
  Hands-on:
  Implement Gift Service
  On first login, send event to RabbitMQ → consumer listens and issues a “welcome gift.”
  Docker Compose adds: rabbitmq

Phase 7 — Scalability, Deployment & Reliability (8 hours)

Session 15 (4h) – Docker & Deployment

Focus: Production environment
Topics:

• Multi-container orchestration

• Health checks and dependencies

• Docker networks

• Nginx reverse proxy
  Hands-on:
  Full Docker Compose orchestration:
  fastapi, postgres, redis, rabbitmq, elasticsearch, logstash, nginx

Session 16 (4h) – Reliability, Maintainability & Scalability

Focus: Professional engineering mindset
Topics:

• Reliability: health checks, retries, timeouts, graceful shutdowns

• Maintainability: modularity, tests, refactoring

• Scalability: horizontal vs vertical, stateless design, caching, async

• Observability basics (metrics, tracing, alerts)

• Backend Engineer Checklist:

  • Code quality & linting

  • Tests & CI/CD

  • Logs & metrics

  • Versioning & migrations

  • Security & authentication

  • Documentation & maintainability
    Hands-on:
    Review & optimize e-commerce backend for production readiness.