skills.rest
innexar-plat
innexar-platCOMMUNITY
Explore all skills by this author →
GitHub

software-architecture-design

Design system-level architectures for scaling, decomposition, and resilience.

Updated Apr 10, 2026
Search Tags:#architecture#scalability#microservices#adr#migration#resilience#system-design
One-click install
npx skills add https://github.com/innexar-plat/Master-Coat-Solutions --skill software-architecture-design-innexar-plat
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: software-architecture-design
Source: https://github.com/innexar-plat/Master-Coat-Solutions/tree/main/.github/skills/software-architecture-design
Command: npx skills add https://github.com/innexar-plat/Master-Coat-Solutions --skill software-architecture-design-innexar-plat

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

Helps teams make high-impact, system-level architecture decisions so organizations can scale, decompose monoliths, and operate distributed systems reliably without overbuilding prematurely.

Core Features & Use Cases

  • Pattern selection & tradeoffs: Compare modular monoliths, microservices, event-driven and serverless approaches with clear guidance on when to pick each.
  • Scalability & resilience design: Recommend concrete technologies (e.g., Kubernetes + Istio/Linkerd, Kafka/Redpanda, PostgreSQL with read replicas and sharding, Redis caching, Temporal.io for orchestration) and patterns like caching, circuit breakers, bulkheads, and CQRS where appropriate.
  • Migration and modernization: Provide strangler-fig migration plans, shadow traffic and canary strategies, CDC-based data migration, and feature-flag rollouts to safely extract services from a monolith.
  • Operational alignment & deliverables: Define ownership models, CODEOWNERS/deployment boundaries, SLO/SLA metrics, runbooks, and ADRs so teams can measure success (deploy frequency, MTTR, error budget usage).
  • Real-world example: Plan a phased extraction of an orders domain from a monolith using feature flags, shadow traffic, and an event-driven integration layer to minimize user impact.

Quick Start

Design two candidate architectures (modular monolith vs microservices) for a greenfield e-commerce platform with 10k RPS, strict payment consistency, and a 12-person engineering team.

Frequently Asked Questions about software-architecture-design

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

FAQPage Schema
How do I design a scalable system architecture for a greenfield platform with high RPS?▼

When migrating a monolith to microservices, apply the strangler-fig pattern and use feature flags, shadow traffic, and CDC-based data migration to safely extract services. The skill delivers operational runbooks and phased extraction plans to minimize user impact during decomposition.

What is the best way to improve resilience and define SLOs for distributed systems?▼

Improving resilience and defining SLOs involves implementing patterns like circuit breakers, bulkheads, and CQRS, alongside setting error budgets and MTTR metrics. The skill recommends specific orchestration tools like Temporal.io and defines operational alignment models for multi-team environments.

How do I define service boundaries and ownership models when decomposing a monolith?▼

Defining service boundaries and ownership models requires establishing CODEOWNERS, deployment boundaries, and ADRs to measure deploy frequency and team autonomy. The skill provides concrete ownership structures and success metrics tailored for multi-team environments.

When should I choose an event-driven architecture over a modular monolith?▼

Choosing an event-driven architecture over a modular monolith depends on your scaling requirements and strict consistency needs like payment processing. The skill compares these approaches with clear guidance on when to pick each based on team size and operational complexity.

Can I use this to plan a migration with canary deployments and shadow traffic?▼

Yes, you can plan a migration using canary deployments and shadow traffic to safely extract domains from a monolith. The skill provides migration runbooks featuring feature-flag rollouts and event-driven integration layers to minimize user impact during phased extractions.

Related Skills

Explore More Software Engineering Skills→
OzeroHAXOzeroHAX
32

coder-system-design-perf-patterns

Select system-level performance patterns for latency, throughput, or cost constraints.

Community
Advanced
muunkkymuunkky

adr-reviewer

Review Architecture Decision Records for reasoning gaps and hidden assumptions.

Community
Advanced
TehminanazTehminanaz
1

kafka-kraft-strimzi

Deploy and tune Kafka in KRaft mode with Strimzi on resource-constrained Kubernetes clusters.

Community
Advanced
Vivekmano27Vivekmano27

system-architect

Design system architectures with Mermaid diagrams and ADR documentation.

Community
Advanced