scaling-evolution

Diagnose system bottlenecks and determine the next incremental scaling step.

42|2|Updated Jun 1, 2026
One-click install
npx skills add https://github.com/proyecto26/system-design-skills --skill scaling-evolution-proyecto26
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: scaling-evolution
Source: https://github.com/proyecto26/system-design-skills/tree/main/skills/scaling-evolution
Command: npx skills add https://github.com/proyecto26/system-design-skills --skill scaling-evolution-proyecto26

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill prevents the common pitfalls of over-engineering or guessing during system design by providing a structured, data-driven path to scale systems based on actual bottlenecks rather than memorized diagrams.

Core Features & Use Cases

  • Bottleneck Diagnosis: Identifies whether a system is compute, storage, or network-bound to ensure the correct scaling action is taken.
  • Incremental Scaling Ladder: Provides a sequence of nine rungs (from single server to sharding) to guide growth only when numbers justify it.
  • Use Case: When a user asks how to scale a service from 1,000 to 1,000,000 users, this skill helps determine the specific next steps—such as adding a cache or moving to a stateless web tier—without prematurely implementing complex sharding or multi-region architectures.

Quick Start

Use the scaling-evolution skill to diagnose the current bottleneck and determine the next scaling step for the system design.

Frequently Asked Questions about scaling-evolution

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

FAQPage Schema
How do I scale a software architecture without over-engineering the system design?

To scale software architecture without over-engineering, use a systematic framework that maps performance metrics to specific scaling rungs, ensuring incremental changes are justified by actual bottlenecks rather than premature complexity.

What is the best way to diagnose whether a system is compute, storage, or network-bound?

Diagnosing system bottlenecks involves a structured evaluation that identifies whether the architecture is compute, storage, or network-bound, ensuring the correct scaling action is taken to resolve the specific performance limitation.

How do I determine the next scaling step when moving from 1,000 to 1,000,000 users?

Determining the next scaling step for user growth involves following an incremental scaling ladder of nine rungs, adding resources like caches or stateless web tiers only when performance numbers justify the architectural change.

When should I implement database sharding in my infrastructure?

Database sharding should be implemented only after lower scaling rungs are exhausted and performance metrics justify it, avoiding premature architectural complexity by resolving earlier compute, storage, or network bottlenecks first.

Does systematic scaling work for iterative design sessions where load increases gradually?

Systematic scaling is designed specifically for iterative design sessions, applying evidence-based engineering to map incremental load increases to justified architectural changes and specific failure modes.

Why does guessing scaling steps lead to failure in system design?

Guessing scaling steps leads to failure because it bypasses evidence-based engineering, risking premature implementation of complex architectures like multi-region setups without resolving the actual system bottleneck.