WebDevPort
All courses
Web Development · 16-module mastery track

Backend Development Mastery

Build scalable, production-grade server architectures, APIs, and cloud backends. Progress from runtime fundamentals to a deployed, observable capstone service.

Syllabus progress— of 16 modules completed
Create account to start learning

Course roadmap

16 modules, from foundations to production

Review the learning objectives, practical milestones, and complete lessons for the full backend track.

16 modules
  1. 01

    Introduction to Backend Development & Client-Server Architecture

    Trace a browser request from DNS resolution through application services and storage, then build a minimal Node.js HTTP server.

    Topics

    • · Client-server responsibilities and request lifecycle
    • · DNS resolution, records, caching, and TLS handshakes
    • · Stateless services, stateful workflows, and session boundaries
    • · Web server, application logic, database, and cache
    • + 2 more topics

    Practical milestone

    Run a local health-check server, add a second route, and document the request/response path.

    Learning objectives
    • · Trace a domain lookup and HTTPS request from browser to origin.
    • · Distinguish stateless request handling from stateful user workflows.
    • · Explain how web servers, application code, databases, and caches cooperate.
    • · Build and test a small HTTP server using only Node.js built-ins.
    Starter lesson availableSign up to access
  2. 02

    Command Line Interface (CLI) & Linux Fundamentals

    Navigate Linux filesystems, inspect processes, manage permissions, and compose reliable command-line workflows for server development.

    Topics

    • · Shell, terminal, paths, and filesystem navigation
    • · Files, directories, pipes, redirection, and exit codes
    • · Users, groups, permissions, ownership, and umask
    • · Processes, signals, ports, services, and resource inspection
    • + 2 more topics

    Practical milestone

    Create a shell-based deployment checklist that checks runtime version, port availability, and service health.

    Learning objectives
    • · Navigate and inspect a Linux environment without a graphical interface.
    • · Use pipes and exit codes to build repeatable workflows.
    • · Diagnose a running process and interpret filesystem permissions.
    • · Connect to a remote host using SSH keys without exposing credentials.
    Starter lesson availableSign up to access
  3. 03

    Version Control with Git and GitHub

    Apply collaborative Git workflows to backend changes, migrations, configuration, and release branches.

    Topics

    • · Repository snapshots, commits, branches, and remotes
    • · Atomic commits and backend-friendly change boundaries
    • · Pull requests, reviews, and protected branches
    • · Merge conflict resolution for code and migrations
    • + 2 more topics

    Practical milestone

    Submit a simulated API change as a reviewed pull request with tests and a migration note.

    Learning objectives
    • · Create reviewable commits and feature branches.
    • · Use pull requests to review API and schema changes.
    • · Resolve conflicts while preserving migration order and intent.
    • · Recover safely using revert and reflog instead of risky shared-history rewrites.
    Starter lesson availableSign up to access
  4. 04

    Core Programming Language with Node.js & TypeScript

    Build a foundation in Node.js runtime APIs and TypeScript types for maintainable server-side applications.

    Topics

    • · Node.js runtime, modules, package scripts, and LTS selection
    • · TypeScript types, narrowing, generics, and strict configuration
    • · ES modules, imports, exports, and module boundaries
    • · Environment configuration and typed application settings
    • + 2 more topics

    Practical milestone

    Create a typed command-line service that validates configuration and emits structured output.

    Learning objectives
    • · Explain the relationship between Node.js, V8, and runtime APIs.
    • · Use TypeScript to model inputs, outputs, and domain states.
    • · Separate pure domain logic from runtime and I/O concerns.
    • · Configure a strict project and test its core behavior.
    Starter lesson availableSign up to access
  5. 05

    Data Structures and Algorithms for Problem Solving

    Choose practical data structures and analyze algorithms that shape API latency, memory use, and throughput.

    Topics

    • · Big-O time and space analysis for service code
    • · Arrays, maps, sets, queues, and object lookup trade-offs
    • · Stacks, linked structures, trees, and graph representations
    • · Sorting, searching, hashing, and collision intuition
    • + 2 more topics

    Practical milestone

    Implement and benchmark a deduplicating batch processor against representative data sizes.

    Learning objectives
    • · Estimate time and memory complexity for common backend operations.
    • · Select structures that fit lookup, ordering, and queueing needs.
    • · Recognize algorithmic bottlenecks in request handlers.
    • · Use measured workloads to justify optimization.
    Starter lesson availableSign up to access
  6. 06

    Asynchronous Programming & Event Loop Concepts

    Understand JavaScript concurrency, event-loop phases, promises, streams, and backpressure in Node.js services.

    Topics

    • · Call stack, task queues, microtasks, and event-loop phases
    • · Promises, async/await, and error propagation
    • · Concurrency versus parallelism and bounded work
    • · Timers, I/O callbacks, and blocking operations
    • + 2 more topics

    Practical milestone

    Build a bounded concurrent fetch queue with cancellation and per-task error reporting.

    Learning objectives
    • · Explain why asynchronous I/O does not make CPU-bound work parallel.
    • · Compose promises with predictable error handling.
    • · Limit concurrent work to protect external dependencies.
    • · Identify blocking operations and handle stream backpressure.
    Starter lesson availableSign up to access
  7. 07

    HTTP/HTTPS Protocol, Requests, and Responses

    Read HTTP messages precisely and apply methods, status codes, headers, caching, cookies, TLS, and content negotiation.

    Topics

    • · HTTP request and response message structure
    • · Methods, safe/idempotent semantics, and status code families
    • · Headers, content types, compression, and negotiation
    • · TLS certificates, HTTPS, and proxy boundaries
    • + 2 more topics

    Practical milestone

    Use an HTTP client to inspect a local API and write a protocol-focused test matrix.

    Learning objectives
    • · Choose methods and status codes that match API semantics.
    • · Inspect headers and explain browser/proxy caching behavior.
    • · Describe what TLS protects and where termination occurs.
    • · Design safe limits for request bodies and connection timeouts.
    Starter lesson availableSign up to access
  8. 08

    RESTful APIs & API Design Principles

    Design consistent resource APIs with validation, pagination, filtering, versioning, and clear error contracts.

    Topics

    • · Resources, representations, and URI design
    • · CRUD semantics and idempotent operations
    • · Validation, pagination, filtering, and sorting
    • · Consistent error envelopes and problem details
    • + 2 more topics

    Practical milestone

    Design an inventory API with a written OpenAPI contract and tests for success and error cases.

    Learning objectives
    • · Model resources and actions with coherent HTTP semantics.
    • · Specify pagination and validation contracts for clients.
    • · Design backwards-compatible API changes.
    • · Document and test an API contract.
    Starter lesson availableSign up to access
  9. 09

    Relational Databases & SQL with PostgreSQL

    Model relational data and write safe, performant SQL using constraints, indexes, transactions, and migrations.

    Topics

    • · Tables, keys, relationships, and normalization
    • · SELECT, joins, aggregates, and parameterized queries
    • · Constraints, indexes, and query planning basics
    • · Transactions, isolation, and concurrency conflicts
    • + 2 more topics

    Practical milestone

    Design a relational schema for the capstone and implement an indexed migration plus transactional workflow.

    Learning objectives
    • · Translate domain relationships into relational schemas.
    • · Write parameterized queries with appropriate joins.
    • · Use constraints and transactions to preserve invariants.
    • · Read query plans and reason about indexes and migrations.
    Starter lesson availableSign up to access
  10. 10

    NoSQL Databases with Redis & Document Stores

    Compare key-value and document models, structure data around access patterns, and manage expiration and consistency trade-offs.

    Topics

    • · Relational versus document and key-value modeling
    • · MongoDB documents, indexes, and atomic updates
    • · Redis strings, hashes, sets, lists, and sorted sets
    • · TTL, eviction policies, and cache invalidation
    • + 2 more topics

    Practical milestone

    Add a Redis cache-aside layer with TTL and measure its hit rate without changing database correctness.

    Learning objectives
    • · Choose a data model based on query and consistency needs.
    • · Use Redis primitives without treating cache as durable truth.
    • · Design document indexes for concrete access patterns.
    • · Explain expiration, eviction, and persistence trade-offs.
    Starter lesson availableSign up to access
  11. 11

    Backend Frameworks with Express.js & NestJS

    Build modular HTTP services and compare Express middleware composition with NestJS dependency-injected modules.

    Topics

    • · Express application lifecycle and middleware order
    • · Routing, controllers, and service boundaries
    • · NestJS modules, providers, controllers, and dependency injection
    • · Request-scoped context and middleware/interceptor/guard roles
    • + 2 more topics

    Practical milestone

    Implement one feature in Express and map its components to an equivalent NestJS module design.

    Learning objectives
    • · Build maintainable request pipelines with explicit middleware order.
    • · Separate transport handlers from business logic.
    • · Explain NestJS modules and dependency injection.
    • · Test routes and services without coupling every test to the network.
    Starter lesson availableSign up to access
  12. 12

    Authentication & Authorization: JWT, OAuth 2.0, Sessions

    Secure identity flows using session cookies, signed tokens, OAuth concepts, authorization checks, and safe credential handling.

    Topics

    • · Authentication versus authorization
    • · Password hashing, account recovery, and MFA concepts
    • · Server-side sessions and secure cookie attributes
    • · JWT structure, validation, rotation, and revocation limits
    • + 2 more topics

    Practical milestone

    Add authenticated ownership checks to a resource API and test both allowed and denied access.

    Learning objectives
    • · Choose sessions or tokens based on system requirements.
    • · Explain OAuth authorization code flow and PKCE.
    • · Enforce authorization at the resource boundary.
    • · Protect credentials, cookies, and token lifecycles.
    Starter lesson availableSign up to access
  13. 13

    Error Handling, Logging, and Input Validation with Zod

    Build a consistent validation and error boundary with structured logs, request IDs, and operationally useful diagnostics.

    Topics

    • · Trust boundaries and schema validation with Zod
    • · Typed parsing and validation issue responses
    • · Centralized error middleware and safe error exposure
    • · Structured logs, levels, correlation IDs, and redaction
    • + 2 more topics

    Practical milestone

    Add Zod request schemas and a redacted structured error logger to the capstone API.

    Learning objectives
    • · Validate untrusted input at API boundaries.
    • · Return stable errors without leaking stack traces or secrets.
    • · Correlate requests across logs using a request identifier.
    • · Write tests that exercise malformed and exceptional cases.
    Starter lesson availableSign up to access
  14. 14

    Caching, Message Queues & Background Workers: Redis & BullMQ

    Move long-running work out of request paths and design reliable jobs with retries, idempotency, and observable queue states.

    Topics

    • · Cache-aside, write-through, and invalidation patterns
    • · Queue producers, workers, and job lifecycle
    • · Retries, exponential backoff, dead-letter handling
    • · Idempotency keys and duplicate delivery
    • + 2 more topics

    Practical milestone

    Process a capstone notification through BullMQ with idempotent retries and a failure dashboard.

    Learning objectives
    • · Identify work that should run asynchronously.
    • · Design jobs that are safe to retry and deduplicate.
    • · Configure bounded worker concurrency and rate limits.
    • · Observe, recover, and alert on stuck or failing jobs.
    Starter lesson availableSign up to access
  15. 15

    Containerization with Docker & CI/CD Pipelines

    Package services reproducibly and automate quality checks, image creation, and controlled delivery pipelines.

    Topics

    • · Images, containers, layers, and Dockerfile fundamentals
    • · Multi-stage builds and minimal runtime images
    • · Compose for local app/database dependencies
    • · Non-root runtime, health checks, and secret boundaries
    • + 2 more topics

    Practical milestone

    Containerize the capstone and publish a CI pipeline that tests and builds an immutable image.

    Learning objectives
    • · Build a reproducible container for a Node.js service.
    • · Separate build dependencies from runtime artifacts.
    • · Run local service dependencies with Compose.
    • · Design a pipeline with tests, image checks, and deployment gates.
    Starter lesson availableSign up to access
  16. 16

    Cloud Deployment, Security Best Practices & Capstone Project

    Ship a production-minded backend with secure configuration, observability, backups, and an operational deployment plan.

    Topics

    • · Cloud compute, networking, DNS, and TLS deployment choices
    • · Secrets management and environment separation
    • · Secure headers, CORS, rate limits, and abuse controls
    • · Database migrations, backups, and recovery objectives
    • + 2 more topics

    Practical milestone

    Deploy the capstone API with database, cache, worker, CI/CD, monitoring, and a tested recovery runbook.

    Learning objectives
    • · Select a deployment model for a documented workload.
    • · Apply least privilege and protect production secrets.
    • · Plan backups, health checks, and incident response.
    • · Present a complete API, data, security, and operations design.
    Starter lesson availableSign up to access

Checking account…