Backend Engineer Course

Lesson 1 • Backend vs. Frontend Roles

Defines responsibilities of backend engineers versus frontend and full-stack roles. Frames the scope of backend work within a product team.

Lesson 2 • Development Environment Setup

Configures a professional local environment including shell, version control, and runtime tools. Ensures every student starts from a consistent, productive baseline.

Lesson 3 • How the Web Works

Covers HTTP request-response cycles, DNS resolution, and TCP/IP basics. Establishes the communication layer every backend service depends on.

Lesson 4 • Command-Line Proficiency

Develops fluency with file system navigation, process management, and scripting. Underpins every deployment and debugging task covered later.

Lesson 1 • Testing and Code Quality

Introduces unit testing, integration testing, linting, and code review practices. Establishes quality habits applied to every project in the course.

Lesson 2 • Object-Oriented Design Patterns

Applies classes, inheritance, interfaces, and composition to backend service design. Connects language features to real architectural decisions.

Lesson 3 • Asynchronous and Concurrent Programming

Explains event loops, threads, async/await, and concurrency primitives. Directly enables building non-blocking I/O-heavy backend services.

Lesson 4 • Core Language Constructs

Reviews data types, control flow, functions, and error handling as applied to backend tasks. Provides the syntax foundation for all subsequent coding exercises.

Lesson 1 • Indexing and Performance Tuning

Explains B-tree and hash indexes, covering indexes, and slow-query analysis. Directly improves database performance in high-traffic backend services.

Lesson 2 • Relational Database Fundamentals

Teaches tables, primary keys, foreign keys, and normalization up to third normal form. Establishes the relational model as the default starting point for data storage.

Lesson 3 • Schema Migrations and Versioning

Teaches migration scripts, rollback strategies, and zero-downtime schema changes. Connects database evolution to continuous deployment pipelines.

Lesson 4 • NoSQL Databases and Use Cases

Introduces document, key-value, column-family, and graph stores with trade-off analysis. Equips students to select the right storage engine for varied workloads.

Lesson 1 • API Documentation and Testing

Generates OpenAPI specs, writes contract tests, and uses API testing tools. Ensures APIs are discoverable, reliable, and easy to integrate.

Lesson 2 • REST Principles and Resource Design

Covers REST constraints, resource naming, HTTP verbs, and idempotency. Establishes the design vocabulary used throughout API development.

Lesson 3 • Request Handling and Routing

Implements route definitions, path parameters, query strings, and request parsing. Connects URL design to controller logic in a web framework.

Lesson 4 • API Versioning and Deprecation

Compares URL, header, and content-type versioning strategies with deprecation workflows. Enables backward-compatible API evolution in production.

Lesson 1 • Security Hardening for Auth Systems

Addresses CSRF, XSS, token leakage, and secure cookie configuration. Closes common attack vectors in authentication and session management.

Lesson 2 • Role-Based and Attribute-Based Access

Designs RBAC and ABAC models, permission checks, and policy enforcement points. Connects access control logic to middleware and service layers.

Lesson 3 • OAuth 2.0 and OpenID Connect

Implements authorization code, client credentials, and implicit flows with PKCE. Enables third-party login and delegated authorization in real applications.

Lesson 4 • JSON Web Tokens

Covers JWT structure, signing algorithms, expiry, and refresh token patterns. Connects stateless authentication to scalable API design.

Lesson 1 • Monoliths vs. Microservices

Compares monolithic, modular monolith, and microservice architectures with trade-offs. Frames when decomposition adds value versus complexity.

Lesson 2 • Asynchronous Communication Patterns

Designs event-driven systems using message queues, pub/sub, and event sourcing. Decouples services and improves fault tolerance in distributed systems.

Lesson 3 • Scalability Patterns

Covers horizontal scaling, load balancing, stateless services, and database read replicas. Connects architecture decisions to traffic growth scenarios.

Lesson 4 • Caching Strategies

Implements cache-aside, write-through, and read-through patterns with eviction policies. Reduces database load and improves response latency across services.

Lesson 1 • Container Orchestration Basics

Introduces Kubernetes pods, deployments, services, and config maps. Connects container packaging to production-grade orchestration and scaling.

Lesson 2 • Containerization with Docker

Builds Docker images, writes Dockerfiles, and manages containers and volumes. Establishes the packaging standard for all deployment workflows.

Lesson 3 • Deployment Strategies

Compares blue-green, canary, and feature-flag deployments with rollback procedures. Minimizes downtime and risk when releasing backend changes to production.

Lesson 4 • Infrastructure as Code

Provisions cloud resources using declarative configuration files and state management. Enables reproducible, version-controlled infrastructure alongside application code.

Lesson 1 • Performance Profiling and Tuning

Uses CPU and memory profilers, flame graphs, and load testing to find bottlenecks. Translates profiling data into targeted backend optimizations.

Lesson 2 • Logging Best Practices

Implements structured logging, log levels, correlation IDs, and centralized log aggregation. Provides the audit trail needed for debugging and compliance.

Lesson 3 • Distributed Tracing

Propagates trace context across services using spans and trace IDs. Enables root-cause analysis of latency and errors in distributed systems.

Lesson 4 • Incident Response and Postmortems

Structures on-call runbooks, incident severity levels, and blameless postmortem processes. Builds a culture of continuous reliability improvement.