Backend Engineering for College Students

12 sessions, ready · Python from the first print() to a finished 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

In preparation, topic-wise plan · the groundwork before the patterns.

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

23 sessions, ready · the patterns behind most coding-interview problems, each with a template and practice problems.

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

34 sessions, ready · 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 free 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

8 sessions ready, the rest in preparation · databases, SQL and relational design.

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

19 sessions, ready · cache, queue and stream, 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

19 sessions, ready · documents, indexes, aggregation and 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

4 sessions ready, more in preparation · coding rounds, resume and the rest of the loop.

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

19 chapters ready, the rest of Kubernetes in preparation · containers and clusters, hands-on.

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 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

40 sessions, ready · design secure, scalable and cost-aware solutions on AWS, with exam strategy.

Core, IAM and load balancing

• 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 networking

• 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 delivery

• 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 decoupling

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

Scaling and databases

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

Operations, containers and storage

• 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 security

• 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 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 exam

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

70 chapters, ready · the building blocks every design 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

50 designs, ready · each worked step by step in the system design playground, from a URL shortener to a stock exchange.

Designs 1-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-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-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-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-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

14 chapters, ready · get reliable 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

23 sessions, ready · the ideas behind AI, 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?

20 sessions, ready · 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

47 sessions, ready · build, evaluate, secure and serve AI agents, with working code for every session.

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