Building Robust Systems That Tolerate Failures

"I only changed one line of code, so why did unrelated services stop working too?"

Every developer faces such overwhelming moments at least once. You know the logic seems fine, but a small change spreads like a butterfly effect, threatening the stability of the entire system. Many developers initially focus on these availability issues - that is, 'keeping the server from going down.' This course starts with this fundamental problem, teaching you how to diagnose the causes of failures and build a solid foundation for robust systems through essential patterns like server redundancy, retry mechanisms, and circuit breakers.

However, the concerns of modern system design don't end here. As systems grow in scale and complexity, we introduce event-driven architecture where we divide services into smaller units and connect them through messaging systems like Kafka. This is a powerful way to reduce dependencies between services and gain flexibility, but it also creates new types of problems.

Here we encounter a more cunning and difficult question.

"What if the order request message is lost due to a network error?"

"What if the payment completion message is sent multiple times and the customer gets charged twice?"

"The order processing succeeded, but if inventory processing fails, how do we reconcile the data?"

As systems become distributed in this way, we face a more sophisticated and challenging problem beyond simple server 'failures': data consistency. This course takes it one step further, directly addressing reliability issues in distributed environments. You'll learn techniques for operating Kafka reliably while preventing message loss and duplication, and deeply explore how to ensure data consistency between distributed services through advanced patterns such as transactional outbox, compensating transactions, and idempotency handling.

Through this course, you will gain a comprehensive perspective on design that goes beyond simply creating code that 'functions' to building systems that operate 'reliably' even in exceptional circumstances. From incident response to distributed data processing, embark on a journey to secure the true 'stability' that modern backend systems demand.

Features of this course

📌 Shifting Perspective on Failures: This lecture doesn't simply list techniques for resolving errors. It views failures as an unavoidable property of systems and explores design perspectives on how to maintain overall system stability when failures occur.

📌 Core Principles and Patterns for Stability: Starting with server redundancy and scalability concepts that form the foundation of robust systems, we focus on understanding and applying the operating principles of stability patterns frequently used in practice, such as Retry and Circuit Breaker.

📌 Balance of Theory and Practice: First understand why each concept is necessary, then immediately apply what you've learned to hands-on practice. Through the process of directly creating failure scenarios and solving them, the course is structured to help you develop real problem-solving skills.

Course Content Preview

You'll learn this content

Pre-enrollment Reference Information