event-driven-architecture

Provides guidance for implementing scalable event-driven systems with Docker and Kubernetes.

Updated Dec 13, 2025
One-click install
npx skills add https://github.com/Azeem-2/HackthonII --skill event-driven-architecture-azeem-2
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: event-driven-architecture
Source: https://github.com/Azeem-2/HackthonII/tree/main/.claude/skills/event-driven-architecture
Command: npx skills add https://github.com/Azeem-2/HackthonII --skill event-driven-architecture-azeem-2

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides reusable patterns and guidance for building modern event-driven architectures. It covers multi-broker support, framework-agnostic design, and resilient patterns (sagas, CQRS, event sourcing) to help teams build scalable microservices.

Core Features & Use Cases

  • Framework-agnostic event patterns: versioned events, generic event store, and broker abstraction to swap Kafka, Redis, or cloud brokers without code changes.
  • Resilience patterns: sagas with compensation, retry, and observability hooks for distributed transactions.
  • CQRS and read-model projection: command and query buses, event projections, and read-model maintenance via event streams.
  • Dapr integration and Kubernetes deployment guidance: state store, pub/sub, service invocation, bindings, and sample manifests for cloud-native deployments.

Quick Start

Use the event-driven-architecture skill to bootstrap a demo that emits and consumes domain events across a producer/consumer to illustrate sagas and read-model updates.

Frequently Asked Questions about event-driven-architecture

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

FAQPage Schema
How do I implement sagas with compensation for distributed transactions in microservices?▼

Implement sagas with compensation using this skill's resilient patterns for distributed transactions. It provides retry mechanisms and observability hooks to maintain data consistency across microservices without two-phase commits.

Can I swap Kafka for Redis or cloud brokers without changing my event-driven code?▼

Yes, you can swap Kafka for Redis or cloud brokers without code changes. The skill provides a broker abstraction layer that decouples your event-driven microservices from specific message broker implementations.

How do I maintain read models and projections using CQRS and event sourcing?▼

Maintain read models using CQRS and event sourcing by utilizing the skill's command and query buses. It handles event projections to automatically update read-models via continuous event streams.

Does this skill support Dapr integration for Kubernetes deployments?▼

Yes, it supports Dapr integration for Kubernetes deployments. The skill provides guidance on utilizing Dapr's state store, pub/sub, and service invocation bindings, including sample manifests for cloud-native deployment.

What is the best way to handle schema evolution for versioned events in distributed systems?▼

Handle schema evolution for versioned events using the skill's framework-agnostic event patterns. It supports versioning and a generic event store to ensure backward compatibility as your event-driven architecture scales.

When should I not use event-driven architecture for my microservices?▼

Avoid event-driven architecture when strict real-time consistency is required over eventual consistency. If your system cannot tolerate saga compensation latency or complex event schema evolution, synchronous patterns may be better.