
Integration Architecture Designer
Design scalable integration architectures that connect your systems seamlessly
What You Can Do
You can rapidly design integration architectures that connect disparate systems, define communication patterns, and identify potential bottlenecks before implementation. The skill analyzes your existing systems, recommends appropriate integration patterns (API-first, event-driven, message queues), and produces architecture diagrams, component specifications, and migration roadmaps. You'll get actionable designs that minimize technical debt and ensure your integrations scale with your business.
Features
Evaluate your systems and recommend optimal integration patterns (REST APIs, GraphQL, event streaming, webhooks, RPC) based on latency, throughput, and reliability requirements.
Generate clear, standards-compliant architecture diagrams showing data flows, system boundaries, message brokers, and failure points using text-based formats.
Design schema transformations and field mappings between systems, identify type mismatches, and specify transformation rules in structured format.
Identify single points of failure, timeout scenarios, and error propagation paths. Recommend circuit breakers, retries, and dead-letter queues.
Estimate throughput, latency, and resource requirements based on traffic patterns. Identify scaling constraints and recommend caching, sharding, or async strategies.
Audit authentication flows, data encryption, network isolation, and compliance requirements (GDPR, HIPAA, SOC2). Recommend security hardening.
Break down integration work into phases, identify dependencies, estimate effort, and flag blockers. Specify technology choices with trade-offs.
Design cut-over strategies for replacing legacy systems, handling data reconciliation, and running parallel systems during transition periods.
Example Output
Example 1: REST API Architecture
Client → Load Balancer → API Gateway (auth, rate limit)
├── User Service (PostgreSQL)
├── Product Service (MongoDB)
└── Order Service (PostgreSQL)
└── Message Queue (RabbitMQ) → Notification Service
Schema mapping: Order.items[].product_id → Product.id (UUID)
Example 2: Event-Driven Architecture
Order Service publishes:
order.created → Kafka topic
├── Payment Service (consumes, processes, emits order.paid)
├── Inventory Service (consumes, decrements stock, emits stock.reserved)
└── Notification Service (consumes, sends confirmation email)
Failure handling: Payment service timeout → retry 3x with exponential backoff → DLQ
Example 3: Performance Model Peak load: 5,000 req/sec, p99 latency 200ms Database: PostgreSQL with read replica, connection pooling (100 connections) Cache: Redis 2GB, TTL 5min for product data → 80% hit rate Queue depth: SQS with 100MB/s throughput → process batch size 1000 messages
What's Included
- Architecture Diagrams: ASCII or Mermaid diagrams showing system components, data flows, message flows, and integration points with clear labeling.
- Pattern Recommendations: Detailed rationale for chosen patterns, including trade-offs between alternatives (REST vs GraphQL, sync vs async, centralized vs decentralized).
- API Specifications: OpenAPI/AsyncAPI specs defining endpoints, request/response schemas, error codes, rate limits, and authentication methods.
- Data Mapping Document: Field-by-field transformation rules between systems, type conversions, validation logic, and handling of missing/null values.
- Implementation Checklist: Step-by-step task list with phase dependencies, estimated effort per phase, and success criteria for each stage.
- Risk & Mitigation Plan: Identified risks (single point of failure, data consistency, vendor lock-in), severity levels, and mitigation strategies.
Who It's For
- Enterprise Architects
- Integration Engineers & Solutions Architects
- Technical Leads Planning System Migrations
- DevOps & Platform Engineers
- CTO/VPs of Engineering Evaluating Technical Strategies
Best For
- Designing multi-system integrations from scratch
- Migrating from monoliths to microservices
- Evaluating integration pattern trade-offs (sync vs async, API vs event-driven)
- Identifying scalability bottlenecks in existing architectures
- Planning API gateway, message broker, or event streaming deployments







