Handling Compensation with Events
Implement compensation steps in a choreography saga by publishing specific rollback events to reverse previous actions.
Handling Compensation with Events is a free Microservices Communication Patterns (Saga, Circuit Breaker) lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Microservices Communication Patterns (Saga, Circuit Breaker) learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Why Compensation is Crucial
In choreography sagas, services react to events. But what happens when one of those services fails to complete its part of a distributed transaction?
We need a way to undo any actions that were successfully performed by previous services. This is where compensation comes in.
What is Compensation?
Compensation is the process of reversing previously completed operations within a distributed transaction. Think of it as a 'rollback' mechanism tailored for microservices.
It ensures that if any step in a multi-service business process fails, the system can return to a consistent state.
Compensation in Choreography
In a choreography saga, there's no central orchestrator. Services communicate directly via events. So, how do we trigger compensation?
- When a service fails to complete its task, it publishes a specific compensation event.
- Other services that have successfully completed their part listen for these compensation events.
- Upon receiving a compensation event, they execute their own rollback logic.
Designing Compensation Events
Compensation events must contain enough information for services to perform their rollback. Key details often include:
- The original saga ID or transaction ID.
- Details about the original action that needs to be reversed.
- Any data required to perform the reversal (e.g., amount to refund, item to unreserve).
Example: Order Processing Saga
Consider an online order process:
- Order Service: Creates order (publishes
OrderCreated) - Payment Service: Processes payment (publishes
PaymentProcessed) - Inventory Service: Reserves stock (publishes
InventoryReserved)
What if the Inventory Service fails to reserve stock?
Initiating the Rollback
If the Inventory Service fails to reserve stock, it should:
- Not publish
InventoryReserved. - Instead, publish a compensation event, like
InventoryReservationFailed.
This event signals to other services that the saga could not complete successfully and they need to undo their actions.
Payment Service's Compensation
The Payment Service is subscribed to events that indicate failures. When it receives InventoryReservationFailed, it knows it needs to act:
- It will initiate a refund for the payment it previously processed.
- After refunding, it might publish a new event, like
PaymentRefunded, to inform other interested services.
Order Service's Compensation
The Order Service, having created the initial order, also needs to react. It might listen for InventoryReservationFailed or PaymentRefunded.
- Upon receiving such an event, the Order Service updates the order's status to 'Cancelled' or 'Failed'.
- This ensures the user sees an accurate status for their order.
Implementing Compensation Logic
Each service must contain logic to handle both successful forward-progress events and specific compensation events. This often means having separate event handlers for each.
Here's a simplified example of how a Payment Service might listen for a compensation event and trigger a refund:
public class PaymentService {
public static void main(String[] args) {
System.out.println("Payment Service Started.");
// Simulate receiving an event from a message broker
String receivedEvent = "InventoryReservationFailed: Order123";
if (receivedEvent.startsWith("InventoryReservationFailed")) {
String orderId = receivedEvent.split(":")[1];
System.out.println("Received compensation event: " + receivedEvent);
System.out.println("Initiating refund for Order ID: " + orderId + "...");
// In a real system, call a payment gateway API to refund
boolean refundSuccess = processRefund(orderId);
if (refundSuccess) {
System.out.println("Refund processed successfully for " + orderId + ".");
// Publish 'PaymentRefunded' event for other services
System.out.println("Publishing PaymentRefunded event.");
} else {
System.out.println("Refund failed for " + orderId + ".");
// Handle refund failure (e.g., alert, manual intervention)
}
} else {
System.out.println("No compensation event received yet.");
}
System.out.println("Payment Service Shutting Down.");
}
private static boolean processRefund(String orderId) {
// Simulate external refund API call
return true; // Assume success for this example
}
}Quick Check: Compensation Purpose
In a choreography saga, if the 'Inventory Service' fails to reserve items after 'Payment Service' has processed a payment, what is the primary purpose of the 'Inventory Service' publishing an InventoryReservationFailed event?
Recap: Handling Compensation
You've learned how critical compensation is in choreography sagas to maintain data consistency in distributed systems. Key takeaways:
- Compensation reverses successful actions when a saga step fails.
- In choreography, services publish specific compensation events to initiate rollbacks.
- Each service must implement logic to listen for and react to these events, performing its own undo operations.
- Clear event design and robust handling are essential for resilient sagas.
Frequently asked questions
Is the “Handling Compensation with Events” lesson free?
Yes — the full text of “Handling Compensation with Events” is free to read here on the web, and the Microservices Communication Patterns (Saga, Circuit Breaker) course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Microservices Communication Patterns (Saga, Circuit Breaker) course, upgrade to CoddyKit PRO.
What will I learn in “Handling Compensation with Events”?
Implement compensation steps in a choreography saga by publishing specific rollback events to reverse previous actions. You practise Microservices Communication Patterns (Saga, Circuit Breaker) with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Microservices Communication Patterns (Saga, Circuit Breaker)?
No prior experience is required. Microservices Communication Patterns (Saga, Circuit Breaker) on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Handling Compensation with Events” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Microservices Communication Patterns (Saga, Circuit Breaker) lesson?
Yes. Every Microservices Communication Patterns (Saga, Circuit Breaker) lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Designing Event-Driven Sagas
- Event Bus and Message Brokers
- Handling Compensation with Events
- Building Idempotent Event Consumers