Architecting Java Systems in the Cloud
Course Description
This course explores how to design and understand modern Java systems in cloud environments. Using the AcmeCorp Platform as a realistic microservices reference architecture, we examine architectural decisions around service boundaries, data access, and containerized deployments. You will instrument applications with Prometheus metrics and analyze system behavior through Grafana dashboards to identify issues such as inefficient queries and startup bottlenecks. We also explore the evolution of the JVM from Java 11 to 21+ and evaluate techniques like AppCDS, CRaC, and native images. Throughout the course, you will learn how to create reproducible benchmarks and reason about the interaction between architecture, observability, and the JVM.
Technologies Covered
About the Instructor
Sascha Möllering
Principal Specialist Solutions Architect @ AWS | Platform Engineering | Distributed Systems | AI-Native Software Development
View InstructorSign in required to enroll
Most companies reimburse for professional development
What you'll learn:
- Course Overview and Goals
- AcemCorp Platform Overview & Architecture
- Local Development and Docker Compose
- API Design, Gateway and Service Boundaries
- + 11 more modules
Course Curriculum (15 modules)
Course Overview and Goals
This episode introduces the overall purpose of the AcmeCorp Platform course and explains how it differs from traditional Java or cloud training. Instead of focusing on isolated frameworks or theoretical architecture patterns, the course centers on real-world system behavior, operational trade-offs, and production-oriented thinking. Viewers learn what the platform represents, who the course is designed for, and why understanding runtime behavior is more important than simply learning APIs or tools.
AcemCorp Platform Overview & Architecture
This episode establishes the AcmeCorp Platform as the reference system used throughout the course. It explains the architectural structure of the platform, introduces the individual services and their responsibilities, and walks through the overall request flow. The episode also explains why the platform intentionally uses a realistic but simplified business domain in order to focus attention on architecture, operations, and system behavior rather than business complexity.
Local Development and Docker Compose
This episode demonstrates how the AcmeCorp Platform is developed and executed locally using Docker Compose. It explains why local reproducibility is a critical architectural requirement and not merely a developer convenience. Viewers learn how service dependencies, startup ordering, health checks, and readiness signals work together, and how local environments can expose the same architectural realities that later appear in CI pipelines and production systems.
API Design, Gateway and Service Boundaries
This episode focuses on API exposure, service boundaries, and the role of the Gateway within distributed systems. It explains how clear boundaries reduce coupling, limit failure propagation, and support long-term API evolution. The episode also demonstrates how request routing, aggregation, and downstream communication work inside the AcmeCorp Platform, while highlighting how architectural mistakes at service boundaries often become the root cause of operational instability.
Observability: Metrics, Health, and Signals
This episode introduces observability as a foundational design capability rather than an operational afterthought. It explains the differences between health, readiness, and liveness, and demonstrates how Prometheus and Grafana are used to collect and visualize system signals. The episode emphasizes that metrics are meaningful only when interpreted in context, and that dashboards represent operational hypotheses rather than objective truth.
Performance Pitfalls: Hibernate N+1 Problem
This episode demonstrates one of the most common and dangerous performance problems in enterprise Java applications: the Hibernate N+1 query issue. It explains how ORM abstractions can hide severe inefficiencies and why performance problems often remain invisible until systems are under load. Through a practical example, viewers learn how inefficient query behavior emerges, how to identify it, and how to fix it through deliberate fetch strategies and measurement.
Java in Containers: AppCDS, Native Images, and CRaC
This episode explores JVM startup behavior in containerized environments and compares multiple approaches for reducing startup time and resource consumption. It explains how AppCDS optimizes class loading, how native images change the execution model entirely, and how CRaC shifts initialization cost through checkpoint and restore mechanisms. Rather than presenting a single best solution, the episode teaches viewers how to evaluate trade-offs based on operational requirements and deployment constraints.
JVM Performance Baselines: Java 11 → 17 → 21
This episode examines how JVM upgrades influence application behavior, startup performance, and memory efficiency. Using benchmark comparisons across Java 11, 17, and 21, it demonstrates that JVM upgrades are architectural decisions with operational consequences rather than simple dependency updates. The episode helps viewers understand how platform evolution impacts runtime characteristics and why staying on outdated JVM versions carries hidden costs.
Cloud Deployment Strategy (AWS)
This episode explains how infrastructure decisions should emerge from system understanding rather than from trends or tooling preferences. Using AWS as the deployment target, it introduces the AcmeCorp cloud reference architecture and demonstrates how frontend delivery, Kubernetes workloads, ingress, networking, and managed services are separated and integrated.
Secure Data Plane: Aurora PostgreSQL IAM Auth
This episode focuses on secure, production-grade database authentication using IAM-based access for Aurora PostgreSQL. It explains why password-based authentication creates operational risk and how identity-based approaches improve security and manageability. At the same time, the episode explores the practical runtime implications of IAM authentication, including token lifetimes, connection pooling behavior, and the interaction between Kubernetes identity mechanisms and managed database services.
Understanding JVM Performance Signals
This episode teaches viewers how to interpret JVM performance data correctly and how to reason about system behavior using runtime signals. It explains the relationships between startup behavior, throughput, latency, garbage collection, and memory allocation patterns. Rather than teaching benchmarking techniques directly, the episode develops performance literacy by helping viewers understand what performance metrics actually mean and which conclusions can or cannot be drawn from them.
Cutting Edge JVMs - Java 21 vs. Java 25
This episode evaluates modern JVM evolution through a comparison between Java 21 and Java 25. It explains how to assess new JVM releases pragmatically by balancing operational risk against potential performance improvements. Through benchmark analysis and operational validation, viewers learn how to approach bleeding-edge JVM adoption systematically instead of relying on hype or assumptions about performance gains.
Asynchronous Messaging with RabbitMQ
This episode introduces asynchronous communication patterns using RabbitMQ and explains the architectural trade-offs between synchronous and event-driven systems. It covers message delivery guarantees, retries, dead-letter queues, and idempotent consumer design. The episode demonstrates how messaging improves decoupling and resilience while simultaneously introducing new operational and failure-handling challenges that must be understood explicitly.
Benchmarking & Performance Methodology
This episode explains how to design trustworthy benchmarks and avoid misleading conclusions. It focuses on methodology rather than tooling, teaching viewers how to control variables, perform warmup phases, collect reproducible measurements, and interpret benchmark results honestly. Using branch-based benchmark comparisons and repeatable measurement workflows, the episode demonstrates how disciplined methodology is required to produce meaningful performance data.
Closing - What We Have Built and Where to Go Next
This final episode concludes the course by revisiting the key architectural, operational, and performance concepts explored throughout the series. It reinforces the idea that modern software engineering is fundamentally about understanding system behavior, trade-offs, and operational consequences rather than simply assembling technologies. The episode also summarizes how the AcmeCorp Platform can continue to serve as a reference system for experimentation, learning, and further exploration.