event-driven-architecture
Master asynchronous system design through message brokers, event sourcing, and distributed transaction patterns. This skill covers Kafka, RabbitMQ, SQS/SNS integration alongside CQRS, saga orchestration, idempotency strategies, and failure handling with dead letter queues—everything needed to build resilient, decoupled microservice architectures.
Event-Driven Architecture teaches you to design scalable microservices using asynchronous messaging and event-driven patterns.
AI-generated summary based on this skill's SKILL.md
Install
travisjneuman/.claude/event-driven-architecture · repository language: JavaScript
git clone https://github.com/travisjneuman/.claude
cp -r .claude/skills/event-driven-architecture ~/.claude/skills/event-driven-architecturenpx skillfed install travisjneuman/.claude/event-driven-architectureFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do I design event-driven microservices?
event-driven-architecture teaches you to design event-driven microservices by decoupling services through asynchronous messaging. You'll learn to identify domain events, choose appropriate message brokers (Kafka, RabbitMQ, SQS), and structure consumers to react to events reliably. The skill covers event sourcing and CQRS patterns to maintain consistency across distributed systems while enabling independent service scaling.
What's the difference between Kafka, RabbitMQ, and SQS?
event-driven-architecture provides a message broker selection guide comparing Kafka, RabbitMQ, SQS/SNS, and NATS. Kafka excels at event streaming and replay; RabbitMQ offers flexible routing and traditional queuing; SQS provides managed AWS integration. The skill helps you evaluate trade-offs in throughput, durability, ordering guarantees, and operational complexity to pick the right broker for your architecture.
How do I handle duplicate messages in event consumers?
event-driven-architecture covers building idempotent event consumers that safely handle duplicate messages. You'll learn to design consumers with idempotency keys, implement deduplication logic, and use database constraints to ensure exactly-once semantics. The skill also teaches consumer group management and offset handling to prevent reprocessing while maintaining reliability across retries and failures.
What is the saga pattern for distributed transactions?
event-driven-architecture explains saga patterns for implementing distributed transactions and long-running workflows across microservices. You'll learn orchestration and choreography approaches, how to coordinate state changes via events, and recovery strategies when steps fail. Sagas replace traditional ACID transactions, enabling eventual consistency while maintaining workflow integrity in event-driven systems.
How do I set up dead letter queues with monitoring?
event-driven-architecture covers setting up dead letter queues (DLQs) with monitoring and replay tooling to handle failed messages. You'll learn to configure DLQ routing, implement alerting on poison messages, and build replay mechanisms to reprocess failures. The skill includes best practices for investigating root causes, preventing cascading failures, and maintaining system observability in production.
What is the transactional outbox pattern?
event-driven-architecture teaches the transactional outbox pattern to reliably publish events without losing messages during failures. You'll learn to write domain events to an outbox table within the same transaction as your business logic, then use a separate process to publish them to your message broker. This pattern ensures exactly-once delivery semantics and decouples event publishing from service logic.
SKILL.md
rendered from the published skill — quoted content, verbatim
Event-Driven Architecture
Overview
This skill covers designing and implementing event-driven systems that decouple services through asynchronous message passing. It addresses message broker selection and integration (Kafka, RabbitMQ, SQS/SNS, NATS), event sourcing and CQRS patterns, saga orchestration for distributed transactions, dead letter queues for failure handling, idempotency patterns, event schema evolution, the transactional outbox pattern, and consumer group management.
Use this skill when building microservice architectures, implementing distributed workflows, decoupling services for independent deployment, handling eventual consistency, or replacing synchronous service-to-service calls with asynchronous events.
Core Principles
- Events are facts, commands are requests - Events describe something that happened (
OrderPlaced,PaymentReceived). Commands request an action
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 1 file
skills/event-driven-architecture/SKILL.md