Python Full Stack Microservices with Gen AI

You can build responsive, semantic web interfaces and handle DOM events using modern ES6+ JavaScript and asynchronous fetch calls.

1. HTML5 structure and semantic markup90 min
   • semantic tags
   • accessibility roles
   • form validation attributes
2. CSS3, Flexbox and responsive design2 hrs
   • display: flex
   • media queries
   • CSS custom properties
3. Modern JavaScript (ES6+)2 hrs
   • arrow functions
   • destructuring
   • spread operators
4. The DOM, events and asynchronous JavaScript2 hrs
   • addEventListener
   • Promises
   • async/await syntax
5. Working with REST APIs from the browser90 min
   • fetch API
   • Response headers
   • JSON parsing

Hands-on project: Build a responsive dashboard layout with CSS Flexbox, dynamic DOM rendering, and client-side data fetching from a public REST API.

You can build type-safe, component-driven single-page applications using React hooks, React Router, and TypeScript interfaces.

1. React fundamentals: components and JSX2 hrs
   • functional components
   • JSX syntax rules
   • conditional rendering
2. Props, state and Hooks3 hrs
   • useState
   • useEffect
   • useRef lifecycle hooks
3. Routing and forms2 hrs
   • React Router v6
   • controlled inputs
   • form submission handlers
4. Calling backend APIs and managing state2 hrs
   • Axios interceptors
   • global state patterns
   • loading and error states
5. TypeScript with React and building a real frontend2 hrs
   • interface props
   • generic components
   • tsconfig strict mode

Hands-on project: Build a multi-page React application with TypeScript, custom hooks, form validation via Zod, and protected route wrappers.

You can write robust Python programs using object-oriented principles, type hints, decorators, generators, and asyncio event loops.

1. Python basics, data types and control flow2 hrs
   • dictionaries
   • list comprehensions
   • walrus operator
2. Functions, modules and comprehensions2 hrs
   • args and kwargs
   • lambda functions
   • package imports
3. Object-oriented programming in Python3 hrs
   • class inheritance
   • dunder methods
   • dataclasses
4. Decorators, generators and iterators2 hrs
   • functools.wraps
   • yield keyword
   • generator expressions
5. Synchronous versus asynchronous programming2 hrs
   • blocking I/O
   • event loop mechanics
   • async/await keywords
6. asyncio, async/await and coroutines2 hrs
   • asyncio.gather
   • asyncio.Task
   • httpx async client

Hands-on project: Write an asynchronous CLI utility that scrapes multiple remote endpoints concurrently using asyncio, httpx, and strict type hints.

You can design relational database schemas, execute complex SQL queries, and manage schema migrations with SQLAlchemy ORM and Alembic.

1. Relational databases and SQL2 hrs
   • JOIN operations
   • foreign keys
   • indexes and constraints
2. PostgreSQL and schema design2 hrs
   • UUID primary keys
   • JSONB data types
   • connection pooling
3. The SQLAlchemy ORM2 hrs
   • AsyncSession
   • declarative base
   • lazy vs eager loading
4. Models, relationships and queries2 hrs
   • relationship mapping
   • select statement builder
   • aggregation functions
5. Migrations with Alembic2 hrs
   • alembic init
   • autogenerate revisions
   • downgrade scripts

Hands-on project: Create a normalised PostgreSQL 16 database schema, define SQLAlchemy async models, and write migration scripts using Alembic.

You can build high-performance REST APIs using FastAPI, validate data with Pydantic, test endpoints with pytest, and secure them with JWT auth.

1. FastAPI and the ASGI model2 hrs
   • Uvicorn server
   • ASGI specification
   • app routing setup
2. Path operations, requests and responses2 hrs
   • path and query parameters
   • status codes
   • response models
3. Pydantic models and validation2 hrs
   • BaseModel fields
   • field validators
   • custom error messages
4. Dependency injection and project structure2 hrs
   • Depends() keyword
   • database session dependency
   • router modularisation
5. Automatic docs, testing with pytest and error handling3 hrs
   • Swagger UI /docs
   • TestClient
   • HTTPException handlers
6. OAuth2 with FastAPI and JWT-based authentication3 hrs
   • OAuth2PasswordBearer
   • python-jose tokens
   • passlib password hashing

Hands-on project: Build an asynchronous FastAPI backend featuring Pydantic request validation, dependency injection, OAuth2 JWT auth, and pytest test suites.

You can decouple monolithic systems into distributed microservices communicating via REST, Celery task queues, Redis, RabbitMQ, and Kafka.

1. Monolith versus microservices2 hrs
   • bounded contexts
   • database per service
   • network failure modes
2. Building FastAPI microservices2 hrs
   • service isolation
   • environment configuration
   • health check endpoints
3. Inter-service communication with REST and httpx2 hrs
   • httpx client timeouts
   • circuit breaker pattern
   • service discovery
4. Background tasks and Celery with Redis3 hrs
   • Celery worker setup
   • Redis message broker
   • task retry policies
5. Messaging with RabbitMQ and Kafka3 hrs
   • exchanges and queues
   • pub-sub patterns
   • Kafka consumer groups

Hands-on project: Split an API into two independent FastAPI microservices connected via RabbitMQ events and an asynchronous Celery background worker backed by Redis.

You can containerise Python applications with multi-stage Dockerfiles, orchestrate services with Docker Compose, and deploy to Kubernetes.

1. Containerising services with Docker2 hrs
   • Dockerfile best practices
   • multi-stage builds
   • alpine base images
2. Docker Compose for local microservices2 hrs
   • docker-compose.yml syntax
   • network bridges
   • volume persistence
3. Kubernetes fundamentals3 hrs
   • Deployments and Pods
   • Services and ClusterIP
   • ConfigMaps and Secrets
4. CI/CD basics with GitHub Actions2 hrs
   • workflow YAML files
   • automated test runners
   • container registry push

Hands-on project: Containerise a multi-service FastAPI application with a multi-stage Dockerfile, orchestrate containers via Docker Compose, and deploy to Minikube.

You can integrate OpenAI, Claude, and Gemini APIs into Python applications, implement prompt engineering strategies, and manage token limits.

1. What LLMs are and how they work2 hrs
   • transformer architecture
   • tokenisation
   • temperature and top_p
2. Prompt engineering for applications2 hrs
   • few-shot prompting
   • chain-of-thought
   • system prompt design
3. Calling LLM APIs (OpenAI, Claude, Gemini)2 hrs
   • SDK client setup
   • streaming responses
   • rate limit handling
4. Tokens, context windows and cost2 hrs
   • tiktoken library
   • cost calculation
   • context pruning

Hands-on project: Build a standalone Python script that interacts with LLM APIs using system prompts, structured JSON outputs, and token usage tracking.

You can build Retrieval-Augmented Generation (RAG) pipelines using LangChain, pgvector, and Chroma for semantic document search.

1. Introduction to LangChain and LlamaIndex2 hrs
   • LCEL syntax
   • document loaders
   • text splitters
2. Chains, prompts and memory2 hrs
   • ConversationBufferMemory
   • prompt templates
   • chain composition
3. Retrieval-Augmented Generation (RAG)3 hrs
   • retriever pipelines
   • context injection
   • source attribution
4. Vector databases (pgvector, Chroma, Pinecone)3 hrs
   • cosine similarity
   • pgvector extension
   • embedding dimensions

Hands-on project: Build an AI query service that ingests private documents, generates vector embeddings, stores them in pgvector, and answers queries via RAG.

You can build autonomous AI agents with function calling capabilities, integrated tool use, and deterministic output guardrails.

1. Building AI agents and tool use3 hrs
   • function calling schemas
   • tool execution loops
   • agent reasoning steps
2. Designing an AI-powered FastAPI microservice3 hrs
   • combining RAG with FastAPI
   • streaming SSE responses
   • input sanitisation
3. Guardrails and evaluation2 hrs
   • Pydantic structured output validation
   • hallucination checks
   • latency optimisation

Hands-on project: Build a FastAPI microservice where an autonomous AI agent uses custom backend tools to fetch database records and execute calculations.

You can test a Python service and its React front end at the layer that proves each behaviour.

1. Choosing the layer to test at90 min
   • Unit vs integration vs e2e
   • Cost per test
   • What only e2e proves
2. Testing FastAPI properly90 min
   • TestClient and dependency overrides
   • Testcontainers Postgres
   • Async test fixtures
3. End-to-end with Playwright90 min
   • Selectors that survive refactors
   • Auth state reuse
   • Trace on failure
4. Running it in CI90 min
   • GitHub Actions matrix
   • Service containers
   • Failing fast on flake

Hands-on project: Build a test suite for the capstone: pytest unit tests, FastAPI integration tests against a Testcontainers Postgres, a Playwright end-to-end test of the critical user journey, and a CI workflow that runs all three on every pull request.

You can see where an LLM-backed request spends its time and money, and reduce both.

1. Tracing a request through the stack90 min
   • OpenTelemetry spans
   • Context propagation
   • Span attributes worth keeping
2. Measuring LLM cost90 min
   • Prompt vs completion tokens
   • Cost per request
   • Context-window waste
3. Reducing latency and spend90 min
   • Streaming responses
   • Semantic and exact caching
   • Smaller model routing
4. Guardrails in production90 min
   • Timeouts and fallbacks
   • Rate limiting per user
   • Degrading without an outage

Hands-on project: Instrument the AI endpoint with OpenTelemetry spans around retrieval and generation, record token usage per request, add a semantic cache for repeated questions, and report the p95 latency and cost per thousand requests before and after.

You can plan, build, containerise, and deploy a production-grade, full-stack microservices application integrating React, FastAPI, and Generative AI.

1. System architecture and backlog planning3 hrs
   • bounded context mapping
   • API contract design
   • database schema planning
2. Building the React frontend and backend services5 hrs
   • integration wiring
   • JWT authentication flow
   • error boundary handling
3. Integrating asynchronous messaging and the AI feature5 hrs
   • Celery background tasks
   • RAG query endpoint
   • agent tool execution
4. Containerisation, CI/CD pipeline and cloud deployment5 hrs
   • Docker Compose orchestration
   • GitHub Actions deployment
   • production health checks
5. Portfolio polish, GitHub hygiene and mock interviews2 hrs
   • README documentation
   • system design interview prep
   • resume review

Hands-on project: Build and deploy a complete production-ready product featuring a React frontend, multiple FastAPI microservices, Postgres, RabbitMQ, and a LangChain RAG agent.