Learn By Doing
This intensive two-day course teaches your team how to design and build event-driven systems. Rather than just theory, participants work through practical exercises and real-world scenarios. By the end of the course, your team will have a solid foundation for making architectural decisions about event-driven systems.
Course Content
Day 1: Foundations and Design
- EDA Basics Core principles of event-driven architecture and when asynchronous communication is the right choice.
- Core Roles Responsibilities and boundaries of producers, consumers, and the infrastructure in between.
- Event Design How to design meaningful events, including payload structure, metadata, and schema evolution.
- Messaging Model Topics, partitions, ordering, delivery guarantees, and how they affect system behavior.
- Streaming Platforms Conceptual overview of Kafka-style event streaming and common development workflows.
- Hands-on Exercise Designing an event-driven system.
Day 2: Reliability and Collaboration
- Reliable Consumption Techniques for idempotency, deduplication, and safe reprocessing of events.
- Failure Handling Error scenarios, retries, dead letters, and recovery strategies in real systems.
- Service Collaboration Choreography versus orchestration, including trade-offs and decision criteria.
- Observability Making event-driven systems understandable through logging, metrics, and tracing.
- Operational Reality Pitfalls, anti-patterns, and lessons learned from production systems.
- Event Sourcing Storing state as a sequence of events, benefits, and trade-offs.
- Advanced Patterns Optional deep dives.
Who Is This For?
This course is designed for software developers and architects who:
- Are building or planning to build distributed systems
- Want to understand event-driven architecture beyond surface-level knowledge
- Need to make informed decisions about when to use (and not use) event-driven patterns
- Have experience with traditional request-response architectures and want to expand their toolkit
Participants must be comfortable with at least one programming language and should have experience building backend systems. The training uses Apache Kafka and either the Java or Go programming language. Other technology stacks can be accommodated upon request.
Format & Logistics
In-Person
Delivered on-site at your location. In-person training enables better interaction, pair programming exercises, and team discussions.
Team Size
Ideal group size is 6-10 participants. This allows for meaningful discussions while ensuring everyone gets hands-on attention.
Duration
Two full days, typically 9:00-17:00 with breaks. Can be adjusted to accommodate your team's schedule.
Materials
Participants receive course materials, exercise code, and reference documentation to take back to their projects.
About the Instructor
I've been designing and building event-driven systems for over a decade, across industries including fintech, e-commerce, and logistics. I maintain the Awesome Event-Driven Architecture resource list and regularly speak at conferences on distributed systems topics.
Bring This Training to Your Team
Interested in scheduling a training session? Let's discuss your team's needs, experience level, and preferred dates.
Inquire About Training