Backend Developer Course

Lesson 1 • Core Programming Concepts Review

Reviews variables, control flow, functions, and data structures critical for backend logic. Bridges any gaps before language-specific backend work begins.

Lesson 2 • Backend vs. Frontend Roles

Defines backend responsibilities versus frontend concerns and explains how APIs bridge them. Clarifies the backend developer's scope of ownership.

Lesson 3 • How the Web Works

Covers HTTP, DNS, and client-server communication as the backbone of backend work. Establishes vocabulary used throughout the course.

Lesson 1 • File System and I/O Operations

Covers reading, writing, and streaming files on the server. Prepares students for log handling, config loading, and file-based data tasks.

Lesson 2 • Asynchronous Programming Patterns

Teaches callbacks, promises, and async/await for non-blocking I/O operations. Directly enables efficient database and network calls in later chapters.

Lesson 3 • Choosing and Using a Backend Language

Compares backend language ecosystems and establishes proficiency in one primary language. Grounds all subsequent coding exercises in a consistent runtime.

Lesson 4 • Testing and Debugging Server Code

Introduces unit testing, logging, and debugger tools for server-side code. Establishes quality habits that carry through all remaining chapters.

Lesson 1 • API Documentation with OpenAPI

Generates and maintains OpenAPI specifications to document endpoints, schemas, and examples. Produces living documentation that supports frontend and QA teams.

Lesson 2 • Input Validation and Sanitization

Validates and sanitises all incoming data before processing to prevent bad data and injection risks. Directly protects the data layer introduced in the next chapter.

Lesson 3 • REST Principles and API Design

Explains REST constraints, resource modelling, and URI design conventions. Sets the design standard applied in every subsequent API-building exercise.

Lesson 4 • Framework-Based Routing and Middleware

Uses a backend framework to define routes and compose middleware for cross-cutting concerns. Reduces boilerplate and enforces consistent request handling.

Lesson 1 • Relational Database Fundamentals

Covers tables, keys, relationships, and normalisation as the basis for structured data storage. Provides the schema design skills used in all SQL exercises.

Lesson 2 • SQL Querying and Manipulation

Teaches SELECT, INSERT, UPDATE, DELETE, and JOIN operations for data retrieval and mutation. Enables direct database interaction before introducing ORM abstractions.

Lesson 3 • Database Performance Basics

Covers query analysis, index optimisation, and connection pooling to prevent common bottlenecks. Directly improves the API's data layer performance.

Lesson 4 • NoSQL Databases and Use Cases

Introduces document, key-value, and time-series stores and explains when to choose them over SQL. Expands the student's data storage toolkit for varied requirements.

Lesson 1 • Role-Based Access Control

Designs and enforces role and permission systems to restrict resource access by user type. Adds authorisation middleware to the existing API routes.

Lesson 2 • Authentication Concepts and Flows

Distinguishes authentication from authorisation and maps common flows like session and token-based auth. Frames all implementation choices made in this chapter.

Lesson 3 • Securing APIs Against Common Attacks

Addresses brute-force, CSRF, and injection attacks with concrete mitigation techniques. Hardens the API before it moves towards deployment in later chapters.

Lesson 4 • Password Security and Storage

Covers hashing algorithms, salting, and secure credential storage to protect user passwords. Prevents the most common credential-related vulnerabilities.

Lesson 1 • API Gateway and Load Balancing

Explains how API gateways and load balancers distribute traffic and centralise cross-cutting concerns. Prepares students for the deployment chapter ahead.

Lesson 2 • Layered and Modular Architecture

Organises code into presentation, business logic, and data layers to separate concerns. Refactoring the existing project reinforces the pattern immediately.

Lesson 3 • Message Queues and Event-Driven Design

Introduces asynchronous messaging with queues and event buses to decouple services. Enables background job processing and reliable inter-service communication.

Lesson 4 • Microservices vs. Monolith Trade-offs

Compares monolithic and microservice architectures across complexity, scalability, and team size dimensions. Guides students in choosing the right approach for a given context.

Lesson 1 • Cloud Deployment Fundamentals

Deploys containerised services to a cloud provider using managed compute and networking primitives. Gives students hands-on experience with real infrastructure.

Lesson 2 • Containerisation with Docker

Builds Docker images, writes Dockerfiles, and manages multi-container apps with Compose. Creates reproducible environments that eliminate configuration drift.

Lesson 3 • Infrastructure as Code Basics

Defines cloud infrastructure declaratively using IaC tools to enable repeatable provisioning. Reduces manual configuration errors in multi-environment deployments.

Lesson 4 • CI/CD Pipeline Construction

Automates build, test, and deploy stages using a CI/CD platform triggered by code commits. Enforces quality gates before any code reaches production.

Lesson 1 • Load Testing and Capacity Planning

Runs load tests to measure throughput, latency, and error rates under simulated traffic. Produces data needed for informed capacity and cost decisions.

Lesson 2 • Resilience Patterns

Implements circuit breakers, retries, and timeouts to prevent cascading failures across services. Strengthens the reliability of the microservice patterns from chapter six.

Lesson 3 • Horizontal and Vertical Scaling

Compares scaling strategies and implements stateless service design to enable horizontal growth. Directly applies to the cloud deployment configured in chapter seven.

Lesson 4 • Profiling and Bottleneck Identification

Uses profiling tools to locate CPU, memory, and I/O bottlenecks in running applications. Grounds all optimisation work in measured evidence rather than guesswork.