Advanced Backend Engineering

Building an API is one thing.

Building a backend system that remains correct, reliable, observable, and maintainable as traffic grows, dependencies fail, data changes concurrently, and multiple engineering teams work on it is a very different challenge.

Advanced Backend Engineering is designed for backend developers who already understand application development and want to learn how production-grade backend systems are engineered.

Instead of focusing primarily on framework syntax, this course focuses on the engineering decisions behind reliable systems.

You will learn how to reason about architecture, service boundaries, databases, caching, asynchronous communication, distributed transactions, concurrency, failure recovery, performance, observability, and production operations.

Using Java and Spring Boot as the primary implementation stack, you will progressively design and build a distributed commerce platform containing services such as Orders, Inventory, Payments, Catalog, and Notifications.

Along the way, you will work with technologies and concepts including:

• Java and Spring Boot
• PostgreSQL
• Redis
• Kafka
• Debezium and Change Data Capture
• Temporal
• Docker
• Kubernetes
• OpenTelemetry
• Prometheus
• Grafana

But the goal of the course is not simply to teach these technologies.

The goal is to teach you when to use them, why to use them, what problems they solve, and what new trade-offs they introduce.

You will explore real production engineering problems such as duplicate requests, concurrent updates, database contention, stale caches, failed dependencies, message redelivery, partial transactions, consumer lag, cascading failures, unsafe schema migrations, and production incidents.

By the end of the course, you should be able to approach backend systems not simply as an application developer, but as an engineer capable of owning systems in production.

What You Will Learn

By completing this course, you will learn how to:

• design backend architectures around real system requirements;
• identify appropriate service and domain boundaries;
• design APIs that remain safe under retries and concurrency;
• model relational data around access patterns;
• understand database transactions, isolation, locking, and contention;
• use caching effectively while managing consistency;
• build event-driven systems with Kafka;
• design idempotent producers and consumers;
• solve the database-and-message dual-write problem;
• implement transactional outbox and inbox patterns;
• use Change Data Capture with Debezium;
• design distributed transactions using sagas;
• understand orchestration and choreography;
• reason about race conditions and distributed coordination;
• implement retries, timeouts, circuit breakers, and backpressure;
• design systems for partial failure;
• build production observability using logs, metrics, and traces;
• define SLIs, SLOs, and error budgets;
• investigate latency and performance bottlenecks;
• estimate capacity and scale services;
• containerize and operate backend services with Kubernetes;
• perform safe database and API migrations;
• design zero-downtime deployment strategies;
• investigate and respond to production incidents;
• write technical RFCs and Architecture Decision Records;
• communicate architectural trade-offs clearly.

Who This Course Is For

This course is designed for:

• backend developers who already know how to build REST APIs;
• Java and Spring Boot developers moving beyond CRUD applications;
• engineers preparing for senior backend engineering responsibilities;
• engineers working with distributed systems;
• developers who want stronger system design skills;
• engineers who want to understand production reliability and operations;
• experienced developers preparing for backend system-design interviews.

This is not a beginner programming course.

Learners should already be comfortable writing backend applications.

Prerequisites

You should already understand:

• Java fundamentals;
• object-oriented programming;
• Spring Boot;
• REST APIs;
• HTTP fundamentals;
• relational databases;
• SQL;
• basic Git;
• basic Docker concepts.

Experience with PostgreSQL is recommended.

Kafka, Redis, Kubernetes, Temporal, Prometheus, and distributed systems knowledge are not required. They will be introduced as part of the course.