event-driven-architecture

Design event-driven architectures with Kafka, RabbitMQ, and SQS/SNS patterns.

88|22|Updated Dec 17, 2025
One-click install
npx skills add https://github.com/travisjneuman/.claude --skill event-driven-architecture-travisjneuman
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: event-driven-architecture
Source: https://github.com/travisjneuman/.claude/tree/main/skills/event-driven-architecture
Command: npx skills add https://github.com/travisjneuman/.claude --skill event-driven-architecture-travisjneuman

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill addresses the complexities of building and maintaining event-driven systems, ensuring reliable asynchronous communication, data consistency, and fault tolerance.

Core Features & Use Cases

  • Message Broker Integration: Connects with Kafka, RabbitMQ, SQS/SNS, and NATS.
  • Pattern Implementation: Supports event sourcing, CQRS, saga patterns, transactional outbox, and idempotency.
  • Failure Handling: Manages dead-letter queues and provides strategies for message replay.
  • Use Case: When building a microservices architecture, use this Skill to implement a reliable order processing system where each step (payment, inventory, shipping) communicates via events, with automatic rollback if any step fails.

Quick Start

Use the event-driven-architecture skill to implement the transactional outbox pattern for publishing an 'OrderPlaced' event after creating an order in the database.

Frequently Asked Questions about event-driven-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is the transactional outbox pattern and when do I need it for event-driven architecture?

The transactional outbox pattern ensures reliable event publishing by saving events to a database table within the same transaction as business data changes. You need it to guarantee atomic state updates and event emission in distributed systems without dual-write inconsistencies.

How do I handle distributed transactions and rollback in a microservices architecture?

Use the saga pattern to manage distributed transactions in microservices by coordinating a sequence of local transactions. If any step fails, compensating events trigger automatic rollback across services, maintaining data consistency without distributed locks.

How do I implement idempotency and dead-letter queues for message processing reliability?

Implement idempotency by tracking processed message identifiers to prevent duplicate side effects. Route unrecoverable failed messages to dead-letter queues for isolation and later replay, ensuring fault tolerance and reliable asynchronous processing.

Can I use this approach with Kafka, RabbitMQ, and SQS/SNS message brokers?

Yes, event-driven architecture design supports integration with Kafka, RabbitMQ, and SQS/SNS message brokers. You can apply patterns like event sourcing, CQRS, and transactional outbox across these platforms to build decoupled, scalable asynchronous systems.

What is the best way to implement CQRS and event sourcing for scalable async systems?

The best way to implement CQRS and event sourcing is to separate write models that append state changes as events from read models built from those events. This decouples processing and enables robust, scalable asynchronous systems with reliable data replay.