system-design

Design system architectures with explicit trade-offs across APIs, data models, and scalability.

Updated Apr 8, 2026
One-click install
npx skills add https://github.com/sun2443/designer-skills --skill system-design-sun2443
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: system-design
Source: https://github.com/sun2443/designer-skills/tree/main/engineering/skills/system-design
Command: npx skills add https://github.com/sun2443/designer-skills --skill system-design-sun2443

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you turn ambiguous product needs into a concrete system architecture you can build, scale, and operate.

Core Features & Use Cases

  • Requirements gathering: Translate functional and non-functional needs into explicit constraints and success criteria, including scale, latency, availability, and cost.
  • High-level design: Produce a component diagram, data flow, API contracts, and storage choices that align with the requirements.
  • Deep technical architecture: Specify data models, API endpoint design (REST/GraphQL/gRPC), caching, queues/events, and robust error handling and retry logic.
  • Scale & reliability planning: Estimate load, choose scaling approach, define failover/redundancy, and outline monitoring/alerting.
  • Trade-off analysis: Make decision trade-offs explicit for complexity, cost, team familiarity, time to market, and maintainability; clearly identify what to revisit as the system grows.

Quick Start

Ask: “Design a system for a multi-tenant event tracking platform with near-real-time ingestion and strong reliability guarantees, and include an API contract, data model, caching strategy, and scaling trade-offs.”

Frequently Asked Questions about system-design

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

FAQPage Schema
How do I design a scalable system architecture from vague product requirements?

System architecture design translates functional and non-functional needs into explicit constraints, component diagrams, data flows, and API contracts. It structures scaling approaches and reliability planning while making trade-offs clear for complexity, cost, and maintainability.

What's the best way to document trade-offs in backend system design?

Document trade-offs in backend system design by making decisions explicit across complexity, cost, team familiarity, time to market, and maintainability. Structured trade-off documentation clearly identifies what architectural choices to revisit as the system grows.

How do I plan reliability and failover for a high-traffic API?

Reliability planning for high-traffic APIs involves defining failover and redundancy, estimating load, choosing scaling approaches, and outlining monitoring and alerting. It also requires specifying robust error handling and retry logic for backend workflows.

Can I use this approach for both early concept design and deep-dive implementation?

Yes, this approach applies across early concepts through deep-dive implementation planning. It covers service boundaries, high-level component design, detailed API endpoint specification, data modeling, and caching strategies for scalable backend workflows.

How to specify API contracts and data models for a multi-tenant platform?

Specify API contracts and data models for multi-tenant platforms by defining REST, GraphQL, or gRPC endpoints alongside structured data models. This includes designing caching, queues, events, and error handling logic aligned with scaling requirements.

When should I revisit architectural trade-offs as my system scales?

Revisit architectural trade-offs as your system scales when complexity, cost, or maintainability constraints shift. Structured trade-off analysis identifies specific growth points where service boundaries, data modeling, or caching strategies need re-evaluation.