event-driven-architecture

Design event-driven architectures with event sourcing, CQRS, and outbox patterns.

1|Updated Mar 6, 2026
One-click install
npx skills add https://github.com/chavangorakh1999/sde-skills --skill event-driven-architecture-chavangorakh1999
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: event-driven-architecture
Source: https://github.com/chavangorakh1999/sde-skills/tree/main/sde-architecture/skills/event-driven-architecture
Command: npx skills add https://github.com/chavangorakh1999/sde-skills --skill event-driven-architecture-chavangorakh1999

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill helps you design and implement robust, scalable event-driven architectures (EDA), addressing challenges in system decoupling, data consistency, and reliable event processing.

Core Features & Use Cases

  • Pattern Selection: Guides you in choosing the right EDA pattern (Simple Async, Event Sourcing, CQRS, Outbox).
  • Implementation Examples: Provides code snippets for publishing/consuming events, implementing the outbox pattern, event sourcing aggregates, and CQRS read models.
  • Schema Versioning: Details strategies for managing event schema evolution without breaking consumers.
  • Use Case: When designing a new e-commerce platform, use this Skill to understand how to implement order processing using event sourcing and CQRS for scalable read operations, ensuring data consistency through the outbox pattern.

Quick Start

Explain the trade-offs between event sourcing and simple async messaging for a new order processing system.

Frequently Asked Questions about event-driven-architecture

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

FAQPage Schema
What is the difference between event sourcing and simple async messaging for system design?

Event sourcing stores state changes as a sequence of immutable events, while simple async messaging decouples services via transient messages without persisting historical state. This Skill guides pattern selection by comparing their trade-offs for scalable system design.

How do I implement the outbox pattern for reliable event publishing in JavaScript?

Implementing the outbox pattern in JavaScript involves writing events to a local database table within the same transaction as state changes, ensuring reliable event publishing. This Skill provides code snippets for the outbox pattern to guarantee data consistency across decoupled services.

When should I use CQRS with event-driven architecture?

Use CQRS in event-driven architecture when you need scalable read operations separate from write logic. This Skill demonstrates implementing CQRS read models alongside event sourcing aggregates to optimize query performance and manage complex domain state reconstruction.

How do I manage event schema versioning without breaking consumers?

Managing event schema versioning requires strategies to evolve event structures without disrupting existing consumers. This Skill details schema versioning techniques to ensure backward compatibility and reliable event processing across decoupled services.

What are the limitations of using event-driven architecture for data consistency?

Event-driven architecture faces limitations in maintaining immediate data consistency across decoupled services due to eventual consistency models. This Skill addresses these challenges by providing patterns like the outbox pattern to ensure reliable state synchronization.