System Design & Architecture Standards

Establishes architectural standards for designing scalable, reliable systems and distributed patterns.

Updated Mar 7, 2026
One-click install
npx skills add https://github.com/ntluong95/agent-skills-statistics --skill system-design-architecture-standards-ntluong95
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: System Design & Architecture Standards
Source: https://github.com/ntluong95/agent-skills-statistics/tree/main/.github/skills/common/system-design
Command: npx skills add https://github.com/ntluong95/agent-skills-statistics --skill system-design-architecture-standards-ntluong95

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides foundational principles and patterns for designing and building reliable, scalable, and maintainable software systems, addressing concerns from modularity to distributed systems.

Core Features & Use Cases

  • Architectural Principles: Enforces concepts like Separation of Concerns (SoC), Single Source of Truth (SSOT), Fail Fast, and Graceful Degradation.
  • Modularity & Coupling: Guides on achieving High Cohesion and Loose Coupling using interfaces and Dependency Injection (DI).
  • Distributed Systems Patterns: Covers CAP theorem trade-offs, Idempotency, Circuit Breakers, and Eventual Consistency.
  • Use Case: When designing a new microservice, consult this Skill to ensure adherence to best practices for scalability and fault tolerance.

Quick Start

Review the architectural principles for designing a new microservice.

Frequently Asked Questions about System Design & Architecture Standards

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

FAQPage Schema
What architectural principles should I follow to design a scalable microservice?

Design scalable microservices by applying Separation of Concerns, Single Source of Truth, Fail Fast, and Graceful Degradation principles to ensure robustness and maintainability.

How do I handle fault tolerance and reliability in distributed systems?

Handle fault tolerance in distributed systems by implementing patterns like Circuit Breakers, Idempotency, and Eventual Consistency to manage failures and ensure reliable operations.

What is the CAP theorem and how does it affect system design trade-offs?

The CAP theorem dictates that distributed systems can only guarantee two out of three properties: Consistency, Availability, and Partition tolerance, forcing trade-offs during system design.

When should I use event-driven architecture over layered architecture?

Use event-driven architecture for asynchronous, decoupled communication and high scalability, whereas layered architecture suits structured, maintainable applications with strict separation of concerns.

How do I achieve high cohesion and loose coupling in software modules?

Achieve high cohesion and loose coupling by utilizing interfaces and Dependency Injection (DI), which separates module construction from its usage and reduces direct dependencies.

Can I apply these system design standards to a monolithic application?

Yes, you can apply these system design standards to a monolithic application by enforcing modularity, statelessness, and Clean Architecture principles to improve structure and prepare for future scaling.