Backend Engineering

Chapter 0 · Python from scratch, learned by building small projects.

Introduction to Python

• What is Python and its key features
• Installing Python and setting up the environment
• Running scripts, the REPL, your first program

Python basics

• Variables and data types, type conversion
• Input/output and formatting
• Comments and code readability

Operators and control flow

• Arithmetic, comparison, logical, assignment, membership and identity operators
• if / elif / else, nested conditions, match statement

Loops

• for and while loops
• break, continue and pass
• Iterating over lists, strings and ranges

Data structures

• Lists: creating, slicing, common methods
• Tuples: immutability and unpacking
• Dictionaries: key-value pairs
• Sets: unique elements and set operations

Functions

• Parameters, return values, default and keyword arguments
• *args and **kwargs
• Scope: local, global, nonlocal

Strings, modules and files

• String indexing, slicing, methods and f-strings
• Importing and writing modules, __name__ == "__main__"
• Reading and writing text files, file paths, handling exceptions

Exceptions and OOP

• try, except, finally, raising and custom exceptions
• Classes and objects, constructors, inheritance, method overriding

Tooling and practice

• Virtual environments and pip
• PEP 8, list and dictionary comprehensions

Projects

• Number guessing game
• Calculator application (and as a game)
• Command line todo application
• Hangman
• Caesar Cipher encryption and decryption tool
• Pomodoro timer
• Key-value storage system
• Grocery list

Chapter 1

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

Chapter 2

• Functions, classes, modules
• Decorators, context managers
• Virtual environments and dependency management (pip, venv, pip-tools)

Chapter 3

Introduction

• What is Django, MVT architecture
• Comparison with Flask and FastAPI

Project setup

• Creating a Django project and app
• Project structure walkthrough

URL routing & views

• Function-based and class-based views
• URL patterns and parameters

Templates

• Django template language (DTL)
• Template inheritance

Static & media files

• Configuring static and media files
• Serving in development and production

Forms & validation

• Django forms vs ModelForms
• Form validation and error handling

User authentication

• Django's built-in auth system
• Login, logout, password reset

Chapter 4

PostgreSQL fundamentals

• Installing PostgreSQL
• Basic SQL commands (CRUD)
• Primary keys, foreign keys, indexes

Django ORM

• Models and migrations
• QuerySets: filter, exclude, annotate, aggregate
• Relationships: one-to-one, one-to-many, many-to-many

Advanced ORM usage

• Raw SQL queries
• Database transactions

Performance optimization

• Indexing strategies
• Query optimization

Chapter 5

• Middleware deep dive
• Signals and their use cases
• Context processors
• Custom management commands
• Working with environment variables

Chapter 6

• Setting up DRF
• Serializers (basic, nested, ModelSerializer)
• ViewSets and Routers
• Authentication and permissions
• Pagination, filtering and ordering

Chapter 7

• Settings for production
• Serving static files with WhiteNoise
• Using Gunicorn & Nginx
• Database migrations in production
• Environment variable management

Chapter 8

• Plan, design and build a backend for a real-world app
• Examples: blog platform, task manager, inventory system
• Integrating PostgreSQL, DRF and authentication
• Deployment to a cloud platform (for example DigitalOcean or AWS)

Core problem-solving, time-space trade-offs and algorithmic mastery.

• Introduction to DSA — Big-O notation, time and space complexity, asymptotic analysis
• Arrays & Strings — prefix sum, sliding window, two pointers, Kadane's algorithm
• Linked Lists — single, double, circular, Floyd's cycle, reversal
• Stacks & Queues — stack via array/linked list, queue, deque, monotonic stack, expression evaluation
• Recursion & Backtracking — N-Queens, Sudoku solver, subset generation, permutations
• Searching Algorithms — linear, binary and ternary search, binary search on answer
• Sorting Algorithms — merge sort, quick sort, heap sort, counting sort
• Hashing & Hashmaps — collision handling, hash functions, LRU cache
• Trees — traversals, BST, heap, trie, segment tree
• Graphs — BFS, DFS, Dijkstra, Bellman-Ford, Kruskal, Prim, topological sort
• Dynamic Programming — Fibonacci, LIS, knapsack, matrix chain multiplication
• Greedy Algorithms — activity selection, Huffman encoding, Kruskal's MST
• Bit Manipulation — XOR patterns, subset generation, masking
• Divide & Conquer — merge sort, binary search, Karatsuba multiplication
• Practice Problems & Mock Interviews — mixed-level real-world problems on LeetCode, HackerRank and Codeforces

Object-oriented design, design patterns and class modelling.

• OOP Principles — encapsulation, inheritance, abstraction, polymorphism, UML diagrams, interfaces, composition vs inheritance
• SOLID Principles — SRP, OCP, LSP, ISP, DIP
• Creational Design Patterns — Singleton, Factory, Builder, Prototype
• Structural Design Patterns — Adapter, Decorator, Facade, Composite, Proxy
• Behavioral Design Patterns — Strategy, Observer, Command, State, Template
• Case Studies in LLD — Parking Lot, Tic-Tac-Toe, Elevator, Movie Ticket Booking
• Design Principles Recap — class diagram reviews and refactoring examples

System architecture, scalability, reliability and distributed systems.

• Introduction to System Design — functional vs non-functional requirements, load metrics
• Scalability Fundamentals — vertical and horizontal scaling, sharding, partitioning
• Load Balancing — round robin, consistent hashing, sticky sessions
• Caching — Redis, Memcached, write-through vs write-back
• Database Design — SQL vs NoSQL, ER modelling, indexing, normalization
• Messaging & Queues — RabbitMQ, Kafka, pub/sub, event-driven architecture
• API Design & Rate Limiting — REST, gRPC, rate limiting, throttling, pagination
• Distributed System Concepts — CAP theorem, consensus (Paxos, Raft)
• Monitoring & Logging — Prometheus, Grafana, ELK stack
• Designing Real Systems — URL shortener, WhatsApp, Twitter feed, Uber, YouTube, Netflix
• Security & Fault Tolerance — authentication, authorization, rate limiting, circuit breakers
• System Design Mock Interviews — whiteboard design and trade-off discussions