event-driven-architect

Design broker-agnostic event-driven architectures with Protobuf schemas and outbox patterns.

3|Updated Feb 26, 2026
One-click install
npx skills add https://github.com/ralvarezdev/ralvaskills --skill event-driven-architect-ralvarezdev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: event-driven-architect
Source: https://github.com/ralvarezdev/ralvaskills/tree/main/skills/messaging/event-driven-architect
Command: npx skills add https://github.com/ralvarezdev/ralvaskills --skill event-driven-architect-ralvarezdev

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Event-driven architectures can suffer from inconsistent event contracts, data loss, and difficult integration across services. This skill provides a blueprint for designing scalable, broker-agnostic event systems with a mandatory outbox, strict idempotency, and robust schema evolution.

Core Features & Use Cases

  • Protobuf-based event schemas with buf breaking discipline to prevent breaking changes.
  • Outbox pattern ensuring atomic writes of business data and event publication.
  • Clear topic naming, versioning, and per-key ordering across brokers (NATS, Kafka, RabbitMQ).
  • DLQs and observability patterns to monitor failures and retries.

Quick Start

Define your event contracts using protobuf per protobuf-architect rules, implement the outbox pattern, and choose a broker to begin.

Frequently Asked Questions about event-driven-architect

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

FAQPage Schema
How do I design an event-driven architecture that works across Kafka, NATS, and RabbitMQ?

Design broker-agnostic event-driven architectures by enforcing consistent topic naming, versioning, and per-key ordering rules. This approach ensures reliable delivery and integration across different brokers without coupling your services to a specific platform.

What is the outbox pattern and how does it prevent data loss in event-driven systems?

The outbox pattern ensures atomic writes of business data and event publication. By writing events to a database table in the same transaction as state changes, it guarantees consistent data integrity and reliable event delivery without lost messages.

How do I prevent breaking changes when evolving Protobuf event schemas?

Prevent breaking changes in Protobuf schemas by applying buf breaking discipline and additive versioning. This enforces strict schema evolution rules, ensuring consumers never break when producers update event contracts.

How do I handle failed events and retries in an event-driven architecture?

Handle failed events and retries using Dead Letter Queues (DLQs) alongside observability patterns. This monitors failure points, isolates poison messages, and provides visibility into retry states to maintain system reliability.

Do I need to implement idempotency for event consumers in distributed systems?

Yes, strict idempotency is required for event consumers to handle duplicate deliveries safely. By tracking processed event IDs, services prevent duplicate side effects and maintain data consistency across distributed contexts.

What is the best way to guarantee transactional consistency when emitting events from a microservice?

The best way to guarantee transactional consistency is implementing strict outbox transactional guarantees. This pattern binds event publication to business state changes within a single transaction, preventing inconsistent data and phantom events.