event_driven

Design event-driven architectures with asynchronous messaging, schema governance, and failure handling.

Updated Jan 14, 2026
One-click install
npx skills add https://github.com/jvsandhu/agentic-skills --skill event-driven-jvsandhu
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: event_driven
Source: https://github.com/jvsandhu/agentic-skills/tree/main/skills/event_driven
Command: npx skills add https://github.com/jvsandhu/agentic-skills --skill event-driven-jvsandhu

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Building loosely coupled systems that react to business events is hard: teams struggle with hidden coupling between services, message failures, and poor observability across asynchronous flows. This Skill provides a structured methodology for designing event-driven architectures that scale and remain resilient. ## Core Features & Use Cases - Event Modeling Guidance: Define canonical event schemas, versioning strategies, and ownership for each event type. - Topology & Broker Selection: Choose between choreography and orchestration, and select brokers like Kafka, RabbitMQ, or SQS based on load and latency needs. - Failure Handling & Observability: Implement Dead-Letter Queues, idempotent consumers, distributed tracing with OpenTelemetry, and consumer lag monitoring. - Use Case: When building an e-commerce platform where inventory, billing, and shipping services must all react to an OrderCreated event, use this Skill to design the event schema, pick the broker, and set up retry and monitoring strategies. ## Quick Start Use the event_driven skill to design an event-driven architecture for my order processing system with Kafka, including event schemas, retry logic, and monitoring checkpoints.

Frequently Asked Questions about event_driven

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

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

Start by modeling canonical event schemas with a versioning strategy, then choose between choreography (pub/sub) and orchestration (saga orchestrator) per data flow. Select a broker like Kafka or RabbitMQ, and plan failure handling with Dead-Letter Queues and idempotent consumers.

Kafka vs RabbitMQ vs SQS for event-driven systems?

Select the broker based on load and latency needs: Kafka suits high-throughput event streaming with partitioning and retention control, RabbitMQ fits traditional message queuing, and SQS works for managed cloud queues. Configure ordering, partitions, and retention policies accordingly.

How do I handle duplicate events in event-driven systems?

Add a unique event_id to every event and build idempotent consumers that safely process the same event twice. Combine this with automated retry logic and Dead-Letter Queues so failed messages can be replayed without corrupting state.

When should I not use event-driven architecture?

Avoid it for simple request-response workflows where loose coupling adds no value, since it introduces operational complexity in tracing and debugging. Without strong observability like distributed tracing and consumer lag alerts, diagnosing stuck consumers becomes very difficult.

How do I monitor event-driven systems in production?

Instrument the full chain from producer through broker to consumer using OpenTelemetry distributed tracing. Track consumer lag, message throughput, schema validation failures, and Dead-Letter Queue depth with dashboards and alarms.