Backend Engineering

By the end, you can

1. Work in Linux and Git every day without looking anything up
2. Design a PostgreSQL database and write the queries a real app needs
3. Build a Django REST API with sign-in, permissions and tests
4. Make slow pages fast with Redis caching, rate limits and background jobs
5. Deploy your app behind Nginx with HTTPS, in Docker, on every push
6. Solve coding interview problems with a clear pattern
7. Design a system end to end and defend each choice in a review or an interview

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

8 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. 2Understand the web
3. 3Store data properly
4. 4Build the backend
5. 5Make it fast
6. 6Ship it to a server
7. 7Solve problems like an engineer
8. 8Design systems at scale

1. 01

   Stage 1 of 8

   Work like an engineer

   Get comfortable in the terminal, write Python with confidence 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 8

   Understand the web

   Follow one request from the browser to a server and back, through DNS, TCP and HTTP.

   You buildA real request traced end to end with curl and dig

   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
3. 03

   Stage 3 of 8

   Store data properly

   Design tables, write the queries a real app needs and keep the data correct.

   You buildThe database for a library app, with joins, indexes and transactions

   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
4. 04

   Stage 4 of 8

   Build the backend

   Turn that database into a working app and a REST API with sign-in and permissions.

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

   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)
5. 05

   Stage 5 of 8

   Make it fast

   Find the slow paths and fix them with caching, rate limits and background jobs.

   You buildRedis caching, a rate limiter and a job queue on your library API

   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)
6. 06

   Stage 6 of 8

   Ship it to a server

   Run your app the way companies do, behind Nginx, inside Docker, deployed by a pipeline.

   You buildYour API live over HTTPS, deployed on every push

   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)

   CI/CD with GitHub Actions15 topics

   15 sessions · build, test and deploy on every push with GitHub Actions.

   Pipelines

   • Your first workflow
   • Workflow anatomy
   • Continuous integration
   • Jobs, artifacts and failure
   • Secrets and environments

   Shipping

   • Building Docker images
   • Reusable workflows
   • Securing the pipeline
   • Deploy over SSH
   • Deploy to Kubernetes
   • Infrastructure with Terraform

   Running it

   • Releases and promotion
   • Verify and observe
   • Operations
   • Capstone
7. 07

   Stage 7 of 8

   Solve problems like an engineer

   Break coding problems down with patterns, and write classes that are easy to change.

   You buildA pattern notebook, then an LRU cache and a parking lot designed from scratch

   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

   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
8. 08

   Stage 8 of 8

   Design systems at scale

   Design for millions of users and explain every trade-off out loud.

   You buildA design review of your own app at a hundred times the traffic

   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