Backend Engineering for College Students with AI

By the end, you can

1. Solve coding interview problems with a clear pattern, and explain your approach out loud
2. Build a Django backend with a REST API, sign-in and a PostgreSQL database, and deploy it
3. Put Nginx in front of your app, balance load across servers and serve it over HTTPS
4. Use Redis for caching and queues, and MongoDB where documents fit better than tables
5. Package any app with Docker and run it on Kubernetes so it scales when traffic grows
6. Design a secure, cost-aware architecture on AWS and pass the Solutions Architect exam
7. Walk an interviewer through a system design, from the numbers to the trade-offs
8. Build and deploy an AI agent that answers from your own documents
9. Leave with a deployed capstone and a GitHub portfolio that a recruiter can open and run

What you get

• Live classesTaught live on a schedule, with time to ask questions as they come up. Every class is recorded, so a missed session is never lost.
• Reading materialsRunnable, chapter-by-chapter notes with real outputs, in the portal. Read at your own pace and come back to revise any time.
• Guided system designs50 step-by-step guided designs in the system design playground, on top of 70 chapters of concepts, so you practise the way interviews are asked.
• Topic-wise guided labsA step-by-step hands-on lab for every topic, with hints when you get stuck, so you learn by building and not just by watching.
• Chapter-wise quiz and flash cardsA short quiz after every chapter and spaced flash cards, so what you read actually sticks.
• Weekly assessmentsA short timed test every week on what was taught, scored on the portal, so gaps show up while there is still time to fix them.
• AssignmentsHands-on assignments to build and submit, with feedback, so you finish with real work to show.

Your path, stage by stage

9 stages, in the order you learn them. Each one has a clear goal and ends with something you build and keep. Every topic runs on your own machine first.

1. 1Work like an engineer
2. 2Think in problems
3. 3Build backends
4. 4Make it fast
5. 5Ship it
6. 6Run it on AWS
7. 7Design systems
8. 8Add AI
9. 9Get hired

1. 01

   Stage 1 of 9

   Work like an engineer

   Get comfortable in the terminal, write Python and keep every change in Git.

   You buildA command-line expense tracker on your own GitHub

   Linux and the Command Line11 topics

   11 sessions · the terminal every engineer works in, every day.

   Getting around

   • First steps in the terminal
   • Files and directories
   • Working with files
   • Reading and editing files

   Getting work done

   • Pipes and text processing
   • Finding things
   • Users and permissions
   • Processes and services
   • Packages and the network

   Automating

   • Shell scripting
   • Troubleshooting a broken machine

   Git and GitHub12 topics

   12 sessions · save, share and undo your work the way teams do.

   Your own repository

   • Meet Git
   • Your first repository
   • Looking back at history
   • Undoing things

   Branches and teams

   • Branches
   • Merging and conflicts
   • Remotes and GitHub
   • Collaborating with pull requests

   Working like a team

   • Power tools
   • Git workflows
   • Workflows, hands-on
   • Rescue and good habits

   Python Fundamentals12 topics

   12 sessions · from your first print() to a finished small project.

   Basics

   • The print() function
   • Variables, constants and data types
   • A variable is a name, not a box
   • Operators, conditions and input()
   • Functions

   Collections and slicing

   • Indexing and slicing
   • Lists (the delivery man's busy day)
   • Tuples (the magic photo album)
   • Dictionaries (Annachi Kadai)
   • Sets (the rose garden and the botanical garden)

   Going further

   • Generators (the lazy workers of Python)
   • Project (the number guessing game)
2. 02

   Stage 2 of 9

   Think in problems

   Learn the groundwork of data structures, then the patterns behind most coding problems.

   You buildA pattern notebook with problems solved for every pattern

   DSA Foundations23 topics

   The groundwork, cost of code, arrays, hashing, lists, recursion, trees and graphs.

   Thinking about cost

   • What an algorithm is and how to compare two of them
   • Time complexity and Big-O, O(1), O(log n), O(n), O(n log n), O(n²)
   • Space complexity and the time-space trade-off
   • Best, average and worst case, amortised cost

   Arrays and strings

   • Arrays in memory, insertion and deletion cost
   • Strings (immutability, traversal and common operations)
   • 2D arrays and matrices

   Hashing

   • Hash maps and hash sets, collisions, load factor
   • Counting, grouping and de-duplicating with a map

   Linked lists, stacks and queues

   • Singly and doubly linked lists, insert, delete and traverse
   • Stack (push, pop, balanced brackets)
   • Queue and deque, circular queue

   Recursion and sorting

   • Recursion, base case and the call stack
   • Bubble, selection and insertion sort
   • Merge sort and quick sort, stability
   • Binary search and its variants

   Trees, heaps and graphs

   • Binary trees (preorder, inorder, postorder, level order)
   • Binary search trees (search, insert, delete)
   • Heaps and priority queues
   • Graphs (adjacency list and matrix, BFS and DFS basics)

   Problem-solving habits

   • Reading the question, constraints and examples
   • Dry-running on paper, edge cases and test cases
   • Explaining your approach while you code

   DSA Patterns23 topics

   23 sessions · the patterns behind most coding problems, each with a template.

   Pointers, windows and hashing

   • Two Pointers
   • Sliding Window
   • Fast and Slow Pointers
   • Reversing a Linked List
   • Binary Search
   • Prefix Sum
   • Hash Map

   Stacks, intervals, sorting and grids

   • Monotonic Stack
   • Overlapping Intervals
   • Cyclic Sort
   • Matrix Manipulation

   Trees, graphs and search

   • Breadth-First Search (BFS)
   • Depth-First Search (DFS)
   • Trees
   • Graphs

   Choosing and optimising

   • Backtracking
   • Greedy
   • Dynamic Programming

   Heaps, bits and design

   • Bitwise XOR
   • Top K Elements
   • K-way Merge
   • Two Heaps
   • Design Data Structures
3. 03

   Stage 3 of 9

   Build backends

   Learn how the web and databases work, then build a Django API on PostgreSQL.

   You buildA library API with accounts, borrowing limits, fines and tests

   How the Internet Works13 topics

   What really happens between typing a URL and seeing the page.

   How the internet works

   • Packets, routing, IP addresses (IPv4 vs IPv6)
   • Role of ISPs
   • Latency, bandwidth and throughput

   Domain Name System (DNS)

   • Domain resolution process
   • A, AAAA, CNAME, MX, TXT records
   • DNS caching and propagation

   HTTP & HTTPS

   • Request/response cycle
   • GET, POST, PUT, PATCH, DELETE
   • Status codes and their categories
   • HTTPS and the TLS/SSL handshake

   Client-server architecture

   • Frontend vs backend responsibilities
   • APIs and how they communicate

   Tools & testing basics

   • curl, Bruno and browser dev tools

   PostgreSQL29 topics

   Tables, queries, design, speed and safety, the database most backends run on.

   Databases and the relational model

   • Why we need a database
   • Database and DBMS
   • The relational model

   Querying

   • Querying data with SELECT
   • Filtering rows with WHERE

   Design and joins

   • Entity relationship diagrams
   • Joins
   • Joins on an e-commerce database

   More querying

   • Sorting, LIMIT and OFFSET, DISTINCT
   • Aggregation (COUNT, SUM, AVG, GROUP BY and HAVING)
   • Subqueries and correlated subqueries
   • CTEs and recursive CTEs
   • Window functions (ROW_NUMBER, RANK, LAG, LEAD and running totals)
   • Set operations (UNION, INTERSECT, EXCEPT)

   Changing data

   • INSERT, UPDATE, DELETE and upserts with ON CONFLICT
   • RETURNING, bulk loading with COPY

   Schema design

   • Normalisation (1NF, 2NF, 3NF and when to denormalise)
   • Primary keys, foreign keys, unique and check constraints
   • Data types (text, numeric, dates, JSONB, arrays, UUID)
   • Views and materialised views

   Performance

   • How Postgres runs a query (the planner)
   • B-tree, hash, GIN and partial indexes
   • Reading EXPLAIN and EXPLAIN ANALYZE
   • Fixing slow queries, the N+1 problem

   Safety and operations

   • Transactions, COMMIT and ROLLBACK, ACID
   • Isolation levels, locks and deadlocks
   • Roles, privileges and row-level security
   • Backups with pg_dump and restore, migrations
   • Connection pooling and basic monitoring

   Django and Django REST Framework34 topics

   34 sessions · from your first project to a deployed backend with an API.

   The web, projects, URLs, views and templates

   • How the web works and where Django fits
   • Your first project
   • Project anatomy (settings and apps)
   • URLs (routing a path to a view)
   • Views (request in, response out)
   • Templates (HTML with holes)
   • Template inheritance and static files

   Models and the ORM

   • Models (tables as Python classes)
   • Migrations (evolving the database)
   • QuerySets (asking the database questions)
   • Lookups, Q objects and F expressions
   • Relationships (ForeignKey, ManyToMany, OneToOne)
   • Aggregation and annotation
   • Query performance (the N+1 problem)

   Admin, forms and views

   • The admin, a ready-made back office
   • Forms (taking user input safely)
   • ModelForms (forms built from models)
   • Class-based views
   • Sessions, cookies and messages
   • File uploads

   Authentication and security

   • Authentication (sign up, log in, log out)
   • Permissions (who may do what)
   • Security essentials

   APIs with Django REST Framework

   • A JSON API, by hand
   • Django REST Framework (serializers)
   • DRF viewsets, routers, authentication and permissions

   Middleware, signals, managers and commands

   • Middleware (code that wraps every request)
   • Signals (reacting to events)
   • Custom managers and QuerySets
   • Management commands

   Testing, caching, deployment and capstone

   • Testing Django applications
   • Caching
   • Deployment
   • Capstone (one evening at Parotta Cafe)
4. 04

   Stage 4 of 9

   Make it fast

   Add caching, queues and a document store where tables are not the right fit.

   You buildA leaderboard and a job queue on Redis, and a chat history on MongoDB

   Redis19 topics

   19 sessions · caching, counters, queues and streams, with outputs from real runs.

   Foundations

   • What Redis Is and Why It Is Fast
   • Keys, Strings and Expiry
   • Hashes, Lists, Sets and Sorted Sets

   Caching

   • The Cache-Aside Pattern
   • Memory Limits and Eviction
   • Keeping the Cache Correct
   • When Caches Fail (Stampede, Penetration, Avalanche)

   Counters, queues and durability

   • Atomic Counters and Rate Limiting
   • A Job Queue with Lists
   • Durability (RDB and AOF)
   • Reliable Queues (Processing Lists and Acks)
   • Delayed Jobs, Retries and Dead Letters
   • Pub/Sub (Broadcast, and Why It Is Not a Queue)
   • A Real Queue Library (RQ)

   Streams

   • Streams Basics (XADD, IDs, XRANGE and XREAD)
   • Consumer Groups (XREADGROUP, XACK and the Pending List)
   • Failure Recovery in Streams
   • Stream Retention and Scaling

   Capstone

   • Capstone (Cache, Queue and Stream Together)

   MongoDB19 topics

   19 sessions · documents, indexes, aggregation and running it in production.

   Basics

   • What MongoDB Is
   • Create and Read
   • Query Operators
   • Updates and Deletes

   Schema design

   • Embed or Reference?
   • Schema Validation
   • Schema Design Patterns

   Indexes and tuning

   • Indexes
   • Compound Indexes
   • explain() and Tuning
   • Special Indexes

   Aggregation and transactions

   • The Aggregation Pipeline
   • Joins, Facets and Saved Reports
   • Transactions

   Replication, sharding and operations

   • Replica Sets
   • Change Streams
   • Sharding
   • Security and Backup

   Capstone

   • Capstone (The Shop)
5. 05

   Stage 5 of 9

   Ship it

   Put your app behind Nginx, package it with Docker and run it on Kubernetes.

   You buildYour API running on a cluster, with load balancing and HTTPS

   Nginx, Reverse Proxy and Load Balancing14 topics

   14 sessions · serve, proxy, balance and secure apps, all in a lab on your laptop.

   Serving sites

   • What a web server is
   • Install and first run
   • Serving a website
   • Reading the config
   • Location blocks
   • Redirects and error pages
   • Many sites on one server

   In front of your apps

   • Reverse proxy
   • Load balancing (round robin, least connections, health checks)
   • Logs and troubleshooting

   Production

   • HTTPS with certificates
   • Speed with compression and caching
   • Security and rate limiting
   • Capstone, the whole setup in Docker

   Docker Essentials14 topics

   Package any app into an image and run a full stack with Compose.

   Docker foundations

   • Introduction to Docker and Its Need
   • Core Linux Prerequisites (Processes, PIDs, Mounts, Signals)
   • File Permissions, Bind Mounts & Docker Architecture
   • Your First Docker Commands (Hands-On)
   • IP Addressing & Subnetting, Simply
   • Docker Networking (Bridge, Host, None & Overlay)
   • Master the Dockerfile from Scratch
   • Image Optimization, Multi-Stage Builds & Container Lifecycle
   • Volumes & Persistence (Writable Layer, Volumes, Bind Mounts and tmpfs)

   Compose, security and observability

   • Docker Compose (FastAPI + PostgreSQL + Redis + Celery)
   • Advanced Compose (Healthchecks, Dependencies, Secrets, Profiles & Limits)
   • Container Security (Rootless, Capabilities, seccomp, AppArmor & Read-only Filesystems)
   • Container Observability (Prometheus, Grafana & cAdvisor)
   • Mini-project Lab (Build & Secure a Production Docker Stack)

   Kubernetes Essentials20 topics

   Run containers on a cluster that heals itself and scales with traffic.

   Kubernetes basics

   • Why Kubernetes? Container Sprawl and the Goals of a Control Plane
   • Kubernetes Architecture (API Server, etcd, Scheduler, Controller Manager, kubelet)
   • Installing Kubernetes (Minikube, kind, K3s, kubeadm and Managed Clusters)
   • The Kubernetes API & kubectl (Declarative YAML, Labels & Selectors)
   • Pods (The Pause Container and the Sidecar, Ambassador, Adapter Patterns)

   Workloads

   • Deployments (replicas, rolling updates and rollbacks)
   • ReplicaSets, Jobs and CronJobs
   • StatefulSets and DaemonSets

   Networking

   • Services (ClusterIP, NodePort and LoadBalancer)
   • DNS inside the cluster
   • Ingress and ingress controllers, TLS

   Configuration and storage

   • ConfigMaps and Secrets
   • Volumes, PersistentVolumes and PersistentVolumeClaims

   Running reliably

   • Resource requests and limits
   • Liveness, readiness and startup probes
   • Autoscaling with the HPA
   • Namespaces, RBAC and network policies

   Packaging and delivery

   • Helm charts and values
   • Deploying a full stack (API, database, cache and ingress)
   • Troubleshooting (logs, describe, events and exec)
6. 06

   Stage 6 of 9

   Run it on AWS

   Design secure, scalable and cost-aware systems on AWS and prepare for the exam.

   You buildA three-tier app on AWS with a locked-down database and a recovery plan

   Core, IAM and load balancing5 topics

   Accounts, identity and spreading traffic across servers.

   • Introduction to AWS (Cloud, Global Infrastructure & IAM)
   • IAM Deep Dive (Users, Groups, Roles & Policies)
   • Load Balancing Explained, HAProxy Demo (Local Setup)
   • Elastic Load Balancer (ELB), Distributing Traffic in AWS
   • EC2 Networking, Storage & Access Management (Part 1)

   VPC and networking8 topics

   Private networks, subnets, gateways, firewalls and DNS.

   • Public & Private Subnets with EC2 and Docker
   • NAT Gateway
   • VPC Peering
   • Transit Gateway
   • VPC Endpoints & PrivateLink
   • AWS WAF (Web Application Firewall)
   • VPC Flow Logs & How DNS Works
   • Amazon Route 53

   Storage, APIs and delivery6 topics

   Object storage, APIs and delivering content fast worldwide.

   • Amazon S3 Part 1 (Buckets, Objects, Storage Classes & CLI)
   • Amazon API Gateway (REST APIs, HTTP APIs, Lambda & Security)
   • Build a Courses API in the AWS console
   • API Gateway advanced (REST APIs, mapping, keys, WebSocket, custom domain and Pulumi)
   • Amazon S3 Part 2 (Replication, Object Lock, Events, Static Sites & Performance)
   • Amazon CloudFront and Global Accelerator

   Serverless and decoupling3 topics

   Code without servers, and services that talk through queues and events.

   • AWS Lambda (Serverless Compute)
   • Decoupling with SQS and SNS
   • EventBridge and Step Functions

   Scaling and databases4 topics

   Scaling compute and choosing the right managed database.

   • EC2 Pricing Models and Auto Scaling
   • Relational Databases (Amazon RDS and Aurora)
   • Amazon DynamoDB
   • ElastiCache and Caching Strategies

   Operations, containers and storage4 topics

   Watching, auditing and running containers and disks.

   • Monitoring and Auditing (CloudWatch, CloudTrail and AWS Config)
   • Containers on AWS (ECR, ECS, Fargate, EKS and App Runner)
   • Block and File Storage (EBS, EFS, FSx and Instance Store)
   • Hybrid Cloud (VPN, Direct Connect, Storage Gateway, DataSync and Snow Family)

   Governance and security3 topics

   Many accounts, encryption, secrets and threat detection.

   • Multi-Account Governance (Organizations, SCPs, Control Tower and Cost Management)
   • Encryption and Secrets (KMS, Secrets Manager, Parameter Store, ACM and CloudHSM)
   • Threat Detection and Protection (GuardDuty, Inspector, Macie, Shield and Security Hub)

   Data, IaC and migration4 topics

   Streaming, analytics, infrastructure as code and migration.

   • Streaming Data (Kinesis Data Streams, Firehose, Managed Flink and MSK)
   • Analytics (S3 Data Lake, Athena, Glue, Redshift, OpenSearch, EMR and QuickSight)
   • Infrastructure as Code and Operations (CloudFormation, CDK, Elastic Beanstalk and Systems Manager)
   • Migration and Backup (DMS, MGN, AWS Backup and Batch)

   Resilience, AI services and exam3 topics

   Recovery plans, AI services and the SAA-C03 exam.

   • Disaster Recovery and High Availability
   • AI and Machine Learning Services on AWS
   • Well-Architected Framework and SAA-C03 Exam Strategy
7. 07

   Stage 7 of 9

   Design systems

   Write classes that are easy to change, then design systems for millions of users.

   You buildFifty guided designs and a design review of your own app

   Low-Level Design and Design Patterns24 topics

   Classes, interfaces and the 18 patterns behind code that is easy to change.

   Principles

   • Object-oriented design and UML
   • SOLID principles
   • Composition over inheritance

   Creational patterns

   • Singleton
   • Factory Method
   • Abstract Factory
   • Builder
   • Prototype

   Structural patterns

   • Adapter
   • Decorator
   • Facade
   • Proxy
   • Composite
   • Bridge
   • Flyweight

   Behavioural patterns

   • Strategy
   • Observer
   • Command
   • State
   • Template Method
   • Chain of Responsibility

   Practice

   • Design a parking lot
   • Design an elevator system
   • Design an LRU and LFU cache

   System Design Concepts70 topics

   70 chapters · the building blocks every large system is made of.

   Framework and foundations

   • The interview framework
   • Back-of-envelope estimation
   • APIs, data model and choosing a database
   • Scalability
   • Availability
   • Reliability
   • Single point of failure (SPOF)
   • Failover
   • Fault tolerance
   • Latency, throughput and bandwidth
   • Consistent hashing
   • CAP theorem

   Networking

   • The OSI model
   • IP addresses
   • TCP vs UDP
   • Checksums
   • DNS (Domain Name System)
   • Proxy vs reverse proxy
   • HTTP and HTTPS
   • Load balancing

   APIs

   • What is an API?
   • REST vs GraphQL
   • API gateway
   • API design
   • WebSockets
   • Webhooks
   • Idempotency
   • Rate limiting

   Databases

   • ACID transactions
   • SQL vs NoSQL
   • Database indexes
   • Database sharding
   • Data replication
   • Database scaling
   • Types of databases
   • Bloom filters
   • Database architectures
   • Generating unique short IDs

   Caching and delivery

   • Caching 101
   • Caching strategies
   • Cache eviction policies
   • Distributed caching
   • Content Delivery Network (CDN)

   Messaging and distributed systems

   • Message queues
   • Publish/subscribe (pub/sub)
   • Change data capture (CDC)
   • Heartbeats
   • Service discovery
   • Consensus algorithms
   • Distributed locking
   • Gossip protocol
   • Circuit breaker
   • Disaster recovery
   • Distributed tracing

   Architecture styles

   • Client-server architecture
   • Microservices architecture
   • Serverless architecture
   • Event-driven architecture
   • Peer-to-peer (P2P) architecture

   Trade-offs

   • Top system design trade-offs
   • Vertical vs horizontal scaling
   • Concurrency vs parallelism
   • Long polling vs WebSockets
   • Batch vs stream processing
   • Stateful vs stateless architecture
   • Strong vs eventual consistency
   • Read-through vs write-through cache
   • Push vs pull architecture
   • REST vs RPC
   • Synchronous vs asynchronous communication

   System Design, 50 Guided Designs50 topics

   50 designs, each worked step by step, from a URL shortener to a stock exchange.

   Designs 1 to 10

   • Design a URL shortener (TinyURL)
   • Design autocomplete for a search engine
   • Design a load balancer
   • Design a content delivery network (CDN)
   • Design a parking garage (object-oriented design)
   • Design a vending machine (state machine)
   • Design a distributed key-value store
   • Design a distributed cache
   • Design an authentication system
   • Design UPI (Unified Payments Interface)

   Designs 11 to 20

   • Design a Rate Limiter
   • Design a News Feed
   • Design a Chat App (WhatsApp)
   • Design a Notification Service
   • Design a Video Streaming Service (YouTube)
   • Design a Ride-Hailing Service (Uber)
   • Design a File Sync Service (Dropbox)
   • Design a Web Crawler
   • Design a Text Search Engine (Elasticsearch)
   • Design a Distributed Message Queue (Kafka)

   Designs 21 to 30

   • Design a Distributed Job Scheduler
   • Design a Unique ID Generator (Snowflake)
   • Design a Ticket Booking System (BookMyShow)
   • Design an E-commerce Cart and Checkout
   • Design a Hotel Booking System (Airbnb)
   • Design a Food Delivery App (Swiggy)
   • Design a Metrics Monitoring and Alerting System
   • Design a Log Aggregation System
   • Design a Distributed File System (GFS/HDFS)
   • Design an Object Storage Service (S3)

   Designs 31 to 40

   • Design a Social Graph (Friends and Suggestions)
   • Design a Real-Time Leaderboard
   • Design a Collaborative Document Editor (Google Docs)
   • Design Pastebin
   • Design a Digital Wallet
   • Design an Ad Click Aggregation System
   • Design a Feature Flag and Config Service
   • Design a Nearby Places Search (Yelp)
   • Design Trending Topics (Top-K)
   • Design a Video Conferencing Service (Zoom)

   Designs 41 to 50

   • Design an Elevator System
   • Design an ATM
   • Design an Expense Sharing App (Splitwise)
   • Design a Chess Game
   • Design an LRU Cache
   • Design a Logging Library
   • Design a Meeting Room Booking System
   • Design a Library Management System
   • Design Snake and Ladder
   • Design a Stock Exchange Order Matching Engine
8. 08

   Stage 8 of 9

   Add AI

   Use LLMs well, understand how models learn, then build RAG and AI agents.

   You buildAn AI agent that answers from your own documents, deployed

   Prompt Engineering14 topics

   14 chapters · get reliable, structured answers from an LLM.

   Writing good prompts

   • The anatomy of a prompt
   • Be specific
   • Give context
   • Assign a role
   • Control the format
   • Show examples (few-shot)
   • Constraints and positive framing

   Structure and reasoning

   • Think step by step
   • Delimiters and structure
   • Iterate and chain prompts
   • Ground the answer
   • System prompts and templates

   Evaluating and practice

   • Evaluate your prompts
   • Capstone (fix five bad prompts)

   Machine Learning Essentials23 topics

   23 sessions · how models learn, in plain words, with code.

   Toolkit and maths

   • What Is Machine Learning?
   • The Toolkit (NumPy and pandas)
   • Maths I (Vectors and Matrices)
   • Maths II (Statistics and Probability)
   • Maths III (Derivatives and Gradients)

   Regression and honest validation

   • Linear Regression
   • Gradient Descent
   • Many Features (Scaling, Categories and Curves)
   • Overfitting and Honest Validation
   • Regularization (Ridge and Lasso)

   Classification

   • Logistic Regression
   • Judging a Classifier (Precision, Recall, ROC and AUC)
   • k-Nearest Neighbours
   • Naive Bayes

   Trees, ensembles and SVMs

   • Decision Trees
   • Ensembles (Random Forests and Gradient Boosting)
   • Support Vector Machines

   Unsupervised learning

   • Clustering (Finding Groups Without Labels)
   • PCA (Squeezing Many Features Into a Few)

   Features, neural networks and shipping

   • Features and Pipelines
   • Neural Networks
   • Tuning, Saving and Shipping a Model

   Capstone

   • Capstone (Will This Subscriber Churn?)

   RAG (Retrieval-Augmented Generation)20 topics

   20 sessions · answer from your own documents, from first pipeline to production.

   Foundations

   • Why RAG?
   • Chunking (Cutting Documents Into Pieces)
   • Embeddings (Turning Meaning Into Numbers)
   • Vector Search and Vector Databases
   • Your First RAG Pipeline
   • Prompting for RAG

   Better retrieval

   • Hybrid Search (Meaning Plus Exact Words)
   • Metadata Filtering
   • Re-ranking
   • Query Rewriting (Fix the Question Before Searching)
   • Parent-Child Retrieval (Search Small, Read Big)
   • Context Compression

   Conversation and freshness

   • Conversational RAG
   • Fresh Data and Caching
   • Agentic RAG and Multi-Step Questions

   Quality and safety

   • Evaluating RAG
   • Catching Hallucinations
   • Guardrails and Security

   Serving and capstone

   • Serving RAG (Speed, Streaming and Cost)
   • Capstone (The Finished Pipeline)

   40 Days of Agentic AI47 topics

   47 sessions · build, test, secure and serve AI agents, with working code each day.

   LLMs, tools and RAG

   • LLMs and Key Terminology
   • Prompt Engineering
   • Tool Calling
   • Retrieval-Augmented Generation (RAG)

   Async, validation and memory

   • Async Python for AI Apps
   • Data Validation with Pydantic
   • Memory for Agents

   Tools, MCP and chains

   • Custom Tools, API & Database Tools, and MCP
   • LCEL (Chains, Parallel Steps and Passthrough)

   Human in the loop and context

   • Human in the Loop (Approve Before the Agent Acts)
   • Conversation Management & the Context Window
   • Personalisation Architectures for AI Agents

   RAG for agents

   • RAG as an Agent Tool
   • Advanced RAG
   • RAG Evaluation

   MCP in depth

   • MCP Fundamentals (Hosts, Clients, Servers, Primitives and Transports)
   • Building Custom MCP Servers and Clients (FastMCP), and Deploying One Remotely

   Agent loops and reliable design

   • Agent Fundamentals (Planning, Reasoning and Reflection)
   • Autonomous Agent Loops (ReAct Built from Scratch)
   • Failure Recovery and Human Feedback in Agents
   • Reliable Agent Design Patterns

   Platforms, memory and multi-agent systems

   • n8n AI Agent Workflows and RAGFlow (Code vs Visual vs Platform)
   • Memory Taxonomy and Mem0; Plan-and-Execute, ReWOO, Reflexion; Self-RAG, CRAG, Adaptive RAG
   • Multi-Agent Systems, Supervisor, Hierarchical, Network and Swarm; the A2A Protocol; AutoGen and CrewAI
   • Computer Use and Browser Agents (Playwright, Sandboxes and Safety)

   Evaluation, guardrails and cost

   • Agent Evaluation and Observability (Golden Sets, Judges and Traces)
   • Guardrails, Safety and Cost (PII, Injection, Budgets and Caching)

   LangGraph

   • LangGraph Fundamentals (State, Nodes and Edges)
   • Building Agents in LangGraph (Summarizer, Map-Reduce and Router)
   • LangGraph Persistence (Checkpoints, Human Approval and Safe Retries)

   Serving LLMs in production

   • Building an LLM Inference Microservice
   • Inside LLM Inference (Prefill, Decode, the KV Cache and PagedAttention)
   • Serving Engines and Batching (vLLM, Continuous Batching, Prefix Caching and Speculative Decoding)
   • Smaller and Faster Models (Quantization, Distillation, LoRA and QLoRA)
   • Decoding Controls (Temperature, Top-p, Repetition and Structured Output)
   • Scaling on Kubernetes (HPA, Cold Starts, Fair Limits and Safe Rollouts)
   • Latency, Cost and Monitoring (TTFT, TPOT, Percentiles and What to Log)

   Production RAG and fine-tuning

   • Ingesting Hard Documents (Scans, Charts and Tables That Span Pages)
   • Keeping RAG Fresh and Safe (Versions, Deletion, Tenants and Multi-Document Questions)
   • Hallucinations and Faithfulness (Causes, Guards and Measurement)
   • Machine Learning Essentials for AI Engineers (Imbalance, F1, Thresholds, Leakage and Drift)
   • Fine-tuning vs RAG, and Embeddings vs Cross-Encoders

   Putting it together and interviews

   • Wiring RAG, Tools and Memory into One Agent
   • Testing, Debugging and Versioning Agent Behaviour
   • Interview Round (Explaining Your Project, Its Architecture and Its Trade-offs)
   • Interview Round (Designing Agent Systems, Explaining Cost and Risk)

   Capstone

   • Capstone (Architect, Build and Deploy a Production Agentic AI System)
9. 09

   Stage 9 of 9

   Get hired

   Prepare your resume and practise every interview round with feedback.

   You buildA resume that passes the first screen, and mock interviews with written feedback

   Interview Preparation21 topics

   Coding rounds, design rounds, your resume and the conversation after the offer.

   Ready now

   • The coding round loop
   • The hashing pattern
   • The monotonic stack
   • Your resume and your two-minute story

   Core CS for interviews

   • Databases (SQL questions, indexes, transactions, normalisation)
   • Operating systems (processes, threads, memory, deadlocks)
   • Computer networks (TCP, HTTP, DNS, what happens when you type a URL)
   • OOP and SOLID (the questions interviewers ask)

   Backend and projects

   • Explaining your Django project end to end
   • Questions on REST APIs, auth, caching and databases
   • Debugging and reading code questions

   Behavioural and HR

   • Tell me about yourself, strengths and weaknesses
   • STAR stories (conflict, failure, leadership)
   • Questions to ask the interviewer

   Practice and mocks

   • Weekly timed coding contests
   • Mock coding interviews with written feedback
   • Mock system design interview
   • Mock HR round

   Getting hired

   • Resume review for freshers, GitHub and LinkedIn
   • Campus placement process and online assessments
   • Offer, negotiation and the first 90 days