skills.rest
Tirael
TiraelCOMMUNITY
Explore all skills by this author →
GitHub

integration-patterns

Define and enforce integration contracts with versioning and transactional outbox patterns.

Updated Feb 4, 2026
Search Tags:#integration#patterns#modules#idempotency#contracts#outbox#bounded-contexts
One-click install
npx skills add https://github.com/Tirael/cursor-template --skill integration-patterns-tirael
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: integration-patterns
Source: https://github.com/Tirael/cursor-template/tree/main/.cursor/skills/integration-patterns
Command: npx skills add https://github.com/Tirael/cursor-template --skill integration-patterns-tirael

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Inter-module coordination across bounded contexts requires clear contracts, versioning, and reliable message handling to prevent drift and integration bugs.

Core Features & Use Cases

  • Define contracts between services and boundaries
  • Choose appropriate sync (e.g., gRPC) vs async (e.g., Kafka)
  • Support transactional outbox patterns and versioning

Quick Start

Map module interactions and establish initial contracts for the current architecture.

Frequently Asked Questions about integration-patterns

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

FAQPage Schema
What is a transactional outbox pattern for microservices?▼

A transactional outbox pattern ensures reliable data integrity by saving messages to a database within the same transaction as business data, preventing drift and coordination bugs across module boundaries.

How do I define contracts between bounded contexts?▼

Define contracts between bounded contexts by mapping module interactions and establishing strict message versioning rules to prevent drift and resolve inter-module coordination issues reliably.

When do I need idempotent handlers for integration patterns?▼

You need idempotent handlers when applying integration patterns across sync and async scenarios, ensuring reliable communication and data integrity by safely processing duplicate messages without adverse side effects.

What is the best way to choose between sync and async communication across module boundaries?▼

Choosing between sync and async communication across module boundaries requires evaluating your architecture, applying contracts, and supporting transactional outbox patterns to maintain reliable integration and data integrity.

How do I prevent integration bugs when versioning messages across bounded contexts?▼

Prevent integration bugs when versioning messages by defining clear contracts and enforcing integration patterns across module boundaries, ensuring reliable communication and strict data integrity during updates.

Does this Skill support both gRPC and Kafka for inter-module communication?▼

Yes, this Skill applies to both sync and async scenarios, supporting communication across module boundaries by defining contracts and versioning messages to ensure reliable integration.

Related Skills

Explore More Software Engineering Skills→
techygargtechygarg
176

architecture-compass

Scan repository structure and dependencies to document current architecture, gaps, and recommended direction.

Community
Advanced
HZeroxiumHZeroxium

java-outbox-idempotency

Implement transactional outbox patterns with idempotent consumers for Java microservices.

Community
Advanced
mikeyobrienmikeyobrien
369

sms

Read and send SMS messages on Android using Termux and Termux:API.

Community
Advanced
NickCrewNickCrew
29

cqrs-event-sourcing

Apply CQRS and Event Sourcing patterns for scalable auditing and event replay.

Community
Advanced