flow-architect

Design event-driven architectures using streaming platforms and design patterns.

Updated Feb 15, 2026
One-click install
npx skills add https://github.com/Wbunker/skills-repo --skill flow-architect-wbunker
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: flow-architect
Source: https://github.com/Wbunker/skills-repo/tree/main/flow-architect
Command: npx skills add https://github.com/Wbunker/skills-repo --skill flow-architect-wbunker

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you understand and design complex event-driven systems, moving beyond traditional request/response architectures to build scalable, real-time, and resilient applications.

Core Features & Use Cases

  • Event-Driven Design: Learn principles like loose coupling, temporal decoupling, and choreography.
  • Platform Selection: Understand the trade-offs between message brokers (RabbitMQ, ActiveMQ) and event streaming platforms (Kafka, Pulsar, Kinesis).
  • Pattern Implementation: Master patterns like Event Sourcing, CQRS, Sagas, Outbox, and Claim Check.
  • Use Case: Design an e-commerce order processing system that scales automatically, handles failures gracefully, and provides real-time inventory updates by leveraging event streaming and saga patterns.

Quick Start

Explain the core concepts of event-driven integration and why it matters for modern software architecture.

Frequently Asked Questions about flow-architect

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

FAQPage Schema
What is an event-driven architecture and when should I use it?

An event-driven architecture decouples services through asynchronous event streams, enabling temporal decoupling and loose coupling. Use it for scalable, real-time applications requiring resilient operations like e-commerce order processing or inventory updates.

How do I choose between Kafka and RabbitMQ for microservices messaging?

Choose event streaming platforms like Kafka, Pulsar, or Kinesis for high-throughput event streaming and temporal decoupling. Select message brokers like RabbitMQ, ActiveMQ, AMQP, or MQTT for traditional message routing and discrete task queues.

How do I implement the Saga pattern for distributed transactions?

Implement the Saga pattern using choreography to coordinate distributed transactions across microservices. This approach ensures graceful failure handling and scalable event-driven processing without relying on traditional two-phase commits.

Does this cover event sourcing and CQRS design patterns?

Yes, it covers implementing Event Sourcing, CQRS, Sagas, Outbox, and Claim Check patterns. These patterns help build scalable systems by separating read and write models and ensuring reliable state reconstruction.

What standards are needed for event-driven microservices discovery and security?

Implement CloudEvents and AsyncAPI standards for event taxonomy and communication. Combine these with proper discovery mechanisms and security protocols to ensure observable, resilient, and safe event streaming across serverless and edge environments.

How do I handle backpressure and observability in event streaming systems?

Manage backpressure and observability by applying operational principles specific to event-driven architectures. This ensures your streaming platforms handle variable throughput gracefully while maintaining real-time system monitoring and resilience.