architecture-patterns_skill

Overview

This skill captures a functionality-first architecture pattern library for designing APIs, services, data models, integrations, and observability. It enforces mapping user/admin/system flows to concrete components and decisions. The goal is pragmatic, traceable architecture that avoids premature optimization and over-engineering.

How this skill works

The skill guides architects to first document user, admin, and system flows, then map each flow step to components (frontend, API, services, repositories, external clients). It provides patterns for API design, integration resilience, observability, decision documentation, and a routing table to direct requests to the right design area. Outputs include endpoint contracts, component definitions, diagrams, and a prioritized implementation roadmap.

When to use it

• Designing a new feature or system where user value must drive architecture
• Refactoring an existing system to reduce complexity or clarify boundaries
• Defining APIs and data models that must match user flows
• Planning integrations with flaky or slow external services
• Preparing an implementation roadmap with clear trade-offs and decisions

Best practices

• Always map functionality flows before any architecture design
• Define service boundaries and API contracts contract-first
• Document decisions with options, trade-offs, and rationale
• Design observability per component: logs, metrics, tracing, alerts
• Prefer simplicity; avoid engineering for hypothetical scale

Example use cases

• Design REST endpoints and request/response schemas for a file upload flow
• Sketch container and component views (C4 Levels 1-3) for a microservice
• Choose an integration pattern (retry, circuit breaker, queue) for an external API
• Create a decision record comparing database partitioning options
• Produce a minimal implementation roadmap and identify potential bottlenecks