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
Decision gist · record as of 2026-07-17
Event-Driven Architecture teaches you to design scalable microservices using asynchronous messaging and event-driven patterns. 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.
Use it when
- event-driven-architecture provides a message broker selection guide comparing Kafka, RabbitMQ, SQS/SNS, and NATS.
- event-driven-architecture covers building idempotent event consumers that safely handle duplicate messages.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
travisjneuman/.claude/event-driven-architecture · repository language: JavaScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently 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)
File tree — 1 file
skills/event-driven-architecture/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Design and implement event-driven microservice architectures”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master the core patterns for building distributed systems that scale independently. This skill covers service boundaries, asynchronous event communication, saga-based transactions with compensation logic, API gateway configuration, and health monitoring strategies. Includes anti-patterns to avoid and a practical checklist for implementation.
Enterprise Architecture Patterns teaches proven design approaches for building large-scale, distributed systems. Learn domain-driven design, event-sourcing, CQRS, saga patterns, API gateways, and service mesh strategies alongside core principles like separation of concerns, modularity, and consistency models.
This skill guides architects through building cloud-native microservices systems from the ground up. It covers domain-driven service decomposition, communication pattern selection, data ownership strategies, resilience implementation, and observability setup—with concrete code examples for correlation IDs, circuit breakers, sagas, and Kubernetes probes.
Master real-time data pipelines and event streaming architectures using modern message brokers and processors. This skill covers Kafka, Pulsar, Redpanda, Flink, and Spark across TypeScript, Python, Go, and Java, with patterns for producer/consumer coordination, delivery guarantees, event sourcing, and change data capture.
The QStash JavaScript SDK enables HTTP-based messaging and scheduling across serverless platforms. Publish messages to endpoints, create delayed or scheduled delivery, manage FIFO queues with flow control, and verify webhook signatures. Works with Next.js, Cloudflare Workers, Deno, Node.js, and other runtimes.
Implement event-driven architecture in Spring Boot 3.x using domain events, ApplicationEventPublisher, and Kafka for distributed messaging. This skill covers designing immutable domain events, publishing from aggregate roots, handling events transactionally with @TransactionalEventListener, configuring Kafka producers and consumers, and implementing the outbox pattern for guaranteed event delivery.
More skills microservices-architecture (MIT) · microservices-patterns (MIT)