event-driven-architect

Architect event-driven microservices with event sourcing, CQRS, and saga patterns.

7|2|Updated Nov 9, 2025
One-click install
npx skills add https://github.com/Dexploarer/hyper-forge --skill event-driven-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: event-driven-architect
Source: https://github.com/Dexploarer/hyper-forge/tree/main/.claude/skills/event-driven-architect
Command: npx skills add https://github.com/Dexploarer/hyper-forge --skill event-driven-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Design robust event-driven architectures for scalable, loosely coupled microservices, covering event sourcing, CQRS, and saga patterns.

Core Features & Use Cases

  • Event Sourcing: Store changes as events and reconstruct state by replay.
  • CQRS: Separate write and read models for scalability.
  • Saga Pattern: Manage distributed transactions across services.
  • Event Streaming: Process continuous event flows in real time.

Quick Start

Outline domain events, commands, and queries; choose a messaging backbone (Kafka/RabbitMQ); implement a basic event store with projections.

Frequently Asked Questions about event-driven-architect

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

FAQPage Schema
How do I design an event-driven architecture for microservices?

Event-driven architecture decouples microservices by using asynchronous messaging. Define domain events, select a message broker like Kafka or RabbitMQ, implement event sourcing to store state changes, and apply CQRS to separate read and write models for scalability and resilience.

What is event sourcing and how does it differ from traditional state storage?

Event sourcing stores all state changes as immutable events rather than overwriting current state. You reconstruct application state by replaying events, enabling complete audit trails, temporal queries, and recovery from any point in time without separate backup systems.

When should I use the Saga pattern for distributed transactions?

Use Saga patterns when coordinating transactions across multiple microservices without a centralized transaction manager. Sagas break distributed work into compensating steps, ensuring eventual consistency and handling failures gracefully in event-driven systems.

How do Kafka and RabbitMQ differ for event streaming in microservices?

Kafka excels at high-throughput event streaming with durable replay and real-time data pipelines; RabbitMQ offers flexible routing and lower latency for traditional messaging. Choose Kafka for event sourcing and analytics; RabbitMQ for transactional workflows and simpler topologies.

Can I implement CQRS with event sourcing?

Yes, CQRS and event sourcing complement each other. Events populate separate read models optimized for queries while commands drive event generation. This pattern scales read and write paths independently and enables real-time projections from event streams.

What prerequisites do I need before building an event-driven system?

Model your domain events and commands clearly, understand eventual consistency trade-offs, and have messaging infrastructure (Kafka or RabbitMQ) operational. Team familiarity with asynchronous patterns and monitoring distributed systems is essential.