streaming-event-architect

Design internal event streaming backbones with delivery semantics and partitioning.

2|Updated Jul 6, 2026
One-click install
npx skills add https://github.com/nguyenpv1980-wq/Project-Aegis --skill streaming-event-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: streaming-event-architect
Source: https://github.com/nguyenpv1980-wq/Project-Aegis/tree/main/.claude/skills/streaming-event-architect
Command: npx skills add https://github.com/nguyenpv1980-wq/Project-Aegis --skill streaming-event-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps design the internal event and streaming backbone between services so teams can avoid duplicate processing, out-of-order updates, dead-letter black holes, and unclear delivery guarantees.

Core Features & Use Cases

  • Flow Classification: Separates internal notifications, state-transfer events, and commands before choosing streams or queues.
  • Delivery Semantics: Defines honest at-least-once behavior with explicit idempotency, retry policy, dead-letter ownership, and replay procedures.
  • Ordering and Partitioning: Sets partition keys and ordering scope clearly, including skew and tenant hot-key risk.
  • CDC and Schema Rules: Designs change data capture ingestion, retention versus compaction, and schema compatibility rules for internal consumers.
  • Use Case: A platform team can use this Skill when rebuilding an event bus, fixing duplicate payment events, or adding CDC from a transactional database into internal streams.

Quick Start

Ask for an internal streaming design for your services, including flow classification, partition keys, delivery semantics, retry and DLQ handling, replay rules, and CDC ingestion if needed.

Frequently Asked Questions about streaming-event-architect

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

FAQPage Schema
How do I design an internal event streaming backbone to prevent duplicate processing and out-of-order updates?

Designing an internal event streaming backbone requires classifying flows, setting partition keys for ordering scope, and defining honest at-least-once delivery with explicit idempotent consumers. This separates commands, notifications, and state-transfer events before choosing streams or queues.

How do I handle dead-letter queue recovery and avoid message black holes in service-to-service event pipelines?

Dead-letter queue recovery in event pipelines requires explicit DLQ ownership, retry policies, and replay procedures. You must route failed messages to a designated dead-letter stream and define clear recovery steps to prevent message black holes during processing failures.

What is the best way to set up CDC pipelines feeding internal consumers from a transactional database?

Setting up CDC pipelines for internal consumers involves designing change data capture ingestion alongside retention and compaction rules. You must define schema compatibility rules to ensure internal consumers handle structural changes without breaking downstream event flows.

How do I fix partition skew and tenant hot-key risks in event streaming between services?

Fixing partition skew in event streaming requires setting partition keys with clear ordering scope and assessing tenant hot-key risks. You must evaluate backpressure handling and distribute keys evenly to prevent uneven load distribution across service partitions.

Does at-least-once delivery require idempotent consumers for reliable internal event flows?

At-least-once delivery in internal event flows requires idempotent consumers to handle duplicate messages safely. You must define explicit retry policies and replay procedures to ensure honest delivery guarantees without causing duplicate processing side effects.

When should I separate internal event contracts from external event contracts and audit trails?

Separating internal event contracts from external contracts and audit trails is necessary when designing service-to-service event flows. You must establish clear boundaries to prevent external dependencies from dictating internal streaming delivery semantics and partitioning rules.