What does a backend engineering course from first principles cover?

It covers HTTP, routing, REST APIs, authentication, validation, Postgres, caching, queues, search, observability, security, scaling, and concurrency.

How does this course explain the difference between authentication and authorization?

Authentication verifies who a user is; authorization determines what that authenticated user is allowed to access or do.

Why are caching and background jobs important in backend systems?

Caching reduces repeated expensive work, while background jobs move slow tasks such as email sending or file processing out of the request path.

Free Course Image Backend Engineering from First Principles (HTTP, REST APIs, Postgres, Caching, Security, Scaling)

Free online course Backend Engineering from First Principles (HTTP, REST APIs, Postgres, Caching, Security, Scaling)

Duration of the online course: 25 hours and 13 minutes

New

Become job-ready in backend engineering: master HTTP, REST APIs, Postgres, caching, security and scaling in a free online course with exercises.

In this free course, learn about

Backend engineering roadmap and first-principles mindset for navigating unfamiliar codebases
Backend fundamentals: why backends exist, request flow, and typical AWS components like load balancers/reverse proxies
Core HTTP concepts: statelessness implications, request/response lifecycle, and headers/status codes basics
Routing: how HTTP servers match requests to handlers and organize endpoints
Serialization/deserialization: moving data between client/server safely (e.g., JSON) and handling types/formats
AuthN vs AuthZ: identity verification vs permission checks; where each fits in backend systems
Validation and transformation: when to validate input, sanitize, and normalize data in an API pipeline
Backend architecture: controllers, services, repositories, middleware, and request context responsibilities
REST API design: resource modeling, idempotency, HTTP methods (e.g., POST non-idempotent), and conventions
Postgres fundamentals: persistence on disk/SSD, querying basics, and why storage choice matters
Performance tools: caching, task queues/background jobs, and full-text search (Elasticsearch vs SQL ILIKE)
Reliability/ops: global error handling, config management, logging/metrics/tracing, and observability pillars
Production readiness: graceful shutdown (SIGTERM), security basics, scaling, p99 latency, and stateless scaling
Concurrency: why servers must handle many simultaneous requests efficiently

About the free online course

Strong backend systems rarely come from copying patterns blindly. They come from understanding first principles: how requests move across the internet, how servers interpret them, how data is stored and retrieved, and what breaks in production. This free online course is designed to help you build that foundation so you can read unfamiliar codebases with confidence, make better design decisions, and debug issues faster when the real world gets messy.

You will start where every backend journey truly begins: HTTP. By learning why HTTP is stateless, how routing works, and how data is serialized and deserialized between client and server, you gain a clear mental model of what happens between a request and a response. From there, you will connect essential application concepts such as validation and transformation, authentication versus authorization, and the responsibilities of controllers, services, repositories, middleware, and request context. Instead of memorizing frameworks, you will learn what these pieces are trying to achieve and how they fit together.

As you progress, you will strengthen your ability to design clean REST APIs, choose appropriate HTTP methods, and implement behavior that stays predictable as systems evolve. You will also build practical database understanding with Postgres, including how and why traditional storage persists data, and how backend performance can collapse when queries and indexing are treated as an afterthought.

Modern backends rely on more than a database. You will explore caching, background jobs and task queues for responsiveness, and fast search with Elasticsearch when naïve SQL patterns stop scaling. The course also emphasizes production readiness: fault tolerance through consistent error handling, configuration discipline across environments, logging/monitoring/observability, and graceful shutdown so deployments do not drop work in flight.

Finally, you will move into the topics that separate functional apps from reliable platforms: security fundamentals, scaling strategies, performance engineering metrics that reflect real user experience, the importance of stateless design for horizontal scaling, and why concurrency is essential for most API servers. With video lessons plus exercises, you will develop the practical intuition needed to build backends that are easier to operate, safer to expose, and ready to grow.

Course content

Video class: 1. Roadmap for backend from first principles 31m
Video class: 2. Walk the path of a true backend engineer 03m
Exercise: What is the main goal of the first phase of this backend engineering course?
Video class: 3. What is a Backend, how do they work and why do we need them? 19m
Exercise: In a typical AWS deployment, what component forwards requests from a public domain to the Node server running on a localhost port (e.g., 3001)?
Video class: 4. Benefits of learning backend engineering from first principles 10m
Exercise: What is the main benefit of learning backend engineering from first principles when joining an unfamiliar backend codebase?

Video class: 5. Understanding HTTP for backend engineers, where it all starts 1h18m
Exercise: What is the key implication of HTTP being stateless?
Video class: 6. What is Routing in Backend? How Requests Find Their Way Home 24m
Exercise: Which statement best describes the role of routing in an HTTP server?
Video class: 7. Serialization and Deserialization for backend engineers 21m
Exercise: What is the main purpose of serialization and deserialization in client–server communication?
Video class: 8. Authentication and authorization for backend engineers 1h35m
Exercise: What is the key difference between authentication and authorization?
Video class: 9. Validations and transformations for backend engineers 42m
Exercise: When should validations and transformations be applied in an API request lifecycle?
Video class: 10. What are controllers, services, repositories, middlewares and request context? 59m
Exercise: In a typical handler–service–repository architecture, which layer should construct the database query (filters/sort) and execute the DB operation?

Video class: 11. Complete REST API Design 2h03m
Exercise: Which HTTP method is generally non-idempotent because repeating the same request can create multiple new resources?
Video class: 12. Mastering Databases with Postgres 2h45m
Exercise: Which storage type is typically used by traditional databases (e.g., Postgres) for persistence in backend systems, and why?

Video class: 13. Caching, the secret behind it all 1h04m
Video class: 14. Task queues and background jobs 55m
Exercise: Which scenario best illustrates why a background job improves backend responsiveness?
Video class: 15. Full text search using Elasticsearch for blazingly fast search 32m
Exercise: Why does a SQL search using ILIKE '%term%' often become slow as the dataset grows to millions of rows?

Video class: 16. Error Handling and Building Fault Tolerant Systems 1h09m
Exercise: What is a key benefit of implementing a global error-handling middleware in a backend API?
Video class: 17. Production-grade Configuration Management 36m
Exercise: Which practice best helps prevent configuration chaos in a distributed backend system?
Video class: 18. Logging, Monitoring and Observability 39m
Exercise: Which set correctly represents the three pillars of observability?
Video class: 19. Graceful Shutdown 35m
Exercise: Which signal is the polite way for an operating system or process manager to request a backend to shut down gracefully?

Video class: 20. Backend Security: Everything You Need to Know 2h50m
Video class: 21.1. Backend Scaling and Performance Engineering: Part-1 1h47m
Exercise: Which latency metric is most useful for understanding the worst user experience in a backend system?
Video class: 21.2. Backend Scaling and Performance Engineering: Part-2 2h18m
Exercise: Why is statelessness a key requirement for horizontal scaling?
Video class: 22. Concurrency 1h28m
Exercise: Why is concurrency essential for most backend API servers?

Learn aboutPostgreSQL

Explore free online PostgreSQL courses designed to help beginners and developers master databases, SQL queries, data modeling, administration, performance tuning, and security. Learn PostgreSQL at your own pace with practical lessons, flexible study options, and an included certificate to showcase your skills and advance your database career.