event-driven-patterns

Design asynchronous event-driven systems with Redpanda and Go patterns.

1|Updated Jun 20, 2026

Search Tags:#architecture #consistency #microservices #event-driven #saga #redpanda

Ready to run

npx skills add https://github.com/shafibabar/SDLC-Artifact-Factory --skill event-driven-patterns-shafibabar

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: event-driven-patterns
Source: https://github.com/shafibabar/SDLC-Artifact-Factory/tree/main/skills/event-driven-patterns
Command: npx skills add https://github.com/shafibabar/SDLC-Artifact-Factory --skill event-driven-patterns-shafibabar

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the complexity of designing asynchronous communication between services, preventing common pitfalls like distributed monoliths, untraceable event chains, and data inconsistency.

Core Features & Use Cases

Pattern Selection: Provides clear criteria for choosing between Choreography and Orchestration based on flow complexity and consistency needs.
Saga Management: Defines how to implement multi-step business processes with compensating transactions to ensure eventual consistency.
Resilience Engineering: Includes implementation strategies for Idempotent Consumers, Transactional Outbox, and Dead Letter Queues to handle failures gracefully.
Use Case: Use this Skill when designing a multi-service data ingestion pipeline to ensure that failures in downstream compliance checks can be safely compensated without manual intervention.

Quick Start

Use the event-driven-patterns skill to evaluate the proposed architecture for the new data ingestion flow and generate the required pattern decision table.

Frequently Asked Questions about event-driven-patterns

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

FAQPage Schema

How do I manage consistency across microservices using event-driven architecture?▼

Event-driven architecture manages microservices consistency by applying the Saga pattern with compensating transactions, ensuring eventual consistency across bounded contexts without distributed locks. This Skill provides criteria for selecting between choreography and orchestration based on flow complexity.

When do I need the Saga pattern for asynchronous microservices?▼

You need the Saga pattern for asynchronous microservices when coordinating multi-step business processes that require compensating transactions to maintain eventual consistency. It is essential when failures in downstream services must be safely rolled back without manual intervention.

How do I implement effectively-once processing in an event-driven system?▼

Effectively-once processing in an event-driven system is implemented using Idempotent Consumers and the Transactional Outbox pattern. This Skill provides implementation strategies to handle message redelivery gracefully while preserving transactional integrity.

Does this event-driven architecture guidance work with Redpanda and Go?▼

Yes, this event-driven architecture guidance is specifically designed for asynchronous systems using Redpanda and Go. It applies to distributed business processes, Saga coordination, and observable failure recovery within that technology stack.

What is the best way to handle failure recovery in distributed event chains?▼

The best way to handle failure recovery in distributed event chains is implementing Dead Letter Queues alongside the Transactional Outbox pattern. This ensures untraceable event chains and data inconsistencies are prevented through observable failure recovery mechanisms.

Why do my asynchronous microservices form a distributed monolith?▼

Asynchronous microservices form a distributed monolith when event chains become untraceable and tightly coupled without proper pattern selection. This Skill provides architectural criteria to choose between choreography and orchestration, preventing common pitfalls like data inconsistency.