Scalability Fields

Within ArchRepo you can record multiple scalability mechanisms. You can link to these from different core building block elements (e.g. Apps, Data Stores, APIs, etc.)

When adding a Scalability Mechanism, these are the fields you can complete.

1. Description

• What it’s for: A high-level overview of the system’s scalability characteristics and goals.

• What to include:

  • Describe how scalability is critical to the system’s success.
  • Identify what the system should handle as it grows (e.g., more users, transactions, data volume).

• Example: "This API is optimized for high scalability to handle up to 1 million requests per minute with load balancing and auto-scaling mechanisms in place."

2. Scaling Type

• What it’s for: Specifies the type of scalability strategy being used.
• Options to include:
  • Horizontal: Adding more units or systems (e.g., additional servers, containers).
  • Vertical: Increasing the capability of existing components (e.g., adding more CPU or memory).
  • Hybrid: A combination of both horizontal and vertical scaling.

3. Scaling Mechanisms

• What it’s for: Defines the tools and processes used to scale the system.

• What to include:

  • Specify mechanisms such as:

  • Auto-scaling (cloud features like AWS, GCP, Azure Auto-scaling Groups).

  • Load balancers.

  • Serverless architectures.

  • Manual scaling strategies.

  • Mention how each mechanism works in your system design.

• Example: "Scaling is managed using AWS Auto-scaling Groups for EC2 instances and an Application Load Balancer to evenly distribute system requests."

4. Maximum Capacity

• What it’s for: Specifies the system’s hard limit for scaling.

• What to include:

  • Define the maximum metrics the system can handle, such as:

  • Number of concurrent users.

  • Transactions per second (TPS).

  • Volume of data processed.

  • This could tie to scalability testing reports or capacity limits of infrastructure.

• Example: "The system can handle up to 100,000 concurrent users with a peak throughput of 10,000 TPS based on current configuration."

5. Current Utilization

• What it’s for: Indicates the current usage levels as a percentage relative to maximum capacity.

• What to include:

  • Provide the current system utilization metrics.
  • Use clear performance KPIs, such as CPU usage, memory usage, or TPS.

• Example: "The current system utilization is at 65% of max capacity during normal business hours, with CPU utilization generally at 75%."

6. Auto Scaling Enabled

• What it’s for: States whether is configured to adjust resources automatically. auto-scaling

7. Scaling Triggers

• What it’s for: Describes the events or thresholds that initiate scaling.

• What to include:

  • Summarize triggers such as:
  • Resource thresholds (e.g., CPU > 70%, memory > 80%).
  • Traffic-related conditions (e.g., TPS, user sessions).
  • Time-based triggers.

• Example: "Scaling is triggered when CPU usage exceeds 75% for a 5-minute interval or when TPS exceeds 1,000 for more than 3 minutes."

8. Scaling Latency

• What it’s for: Defines the time it takes for scaling to be applied once triggered.

• What to include:

  • Estimate how quickly resources can be provisioned.
  • Note any existing delays in infrastructure or dependencies.

• Example: "Scaling typically takes 2–3 minutes for new instances to be initialized and traffic to be routed."

9. Scaling Limitations

• What it’s for: Identifies constraints that might prevent the system from scaling easily.

• What to include:

  • Specify limitations such as:
  • Hardware bottlenecks (e.g., single-threaded components).
  • Software constraints (e.g., non-distributed databases).
  • External factors (e.g., API rate limits by third parties).

• Example: "Scaling is limited by the write throughput of the database, which currently caps at 5,000 writes per second."

10. Cost Implications

• What it’s for: Describes the cost behavior as the system scales.

• What to include:

  • Explain whether costs scale:

  • Linearly (e.g., adding nodes increases costs in proportion).

  • Exponentially (e.g., increased data usage resulting in higher database costs).

  • Note significant cost drivers or optimizations.

• Example: "Costs scale linearly as compute resources and storage grow, with the largest cost being additional EC2 instances and database replica nodes."

11. Tools Used

• What it’s for: Lists tools or frameworks that help manage scalability.

• What to include:

  • Mention tools such as Kubernetes, Docker, AWS/GCP/Azure cloud features, or third-party scaling solutions.

• Example: "Scalability is managed through Kubernetes, backed by AWS EKS, and integrated with AWS CloudWatch for monitoring auto-scaling."

12. Testing Strategy

• What it’s for: Details how scalability is tested to ensure the system can handle growth.

• What to include:

  • Explain testing approaches like:

  • Load testing (e.g., Locust, JMeter).

  • Stress testing (e.g., simulating peak loads).

  • Failover testing.

  • Include testing frequency and review methods.

• Example: "Load tests are conducted quarterly to simulate traffic at 150% of expected production levels using Locust testing tools."

13. Elasticity

• What it’s for: Specifies if the system can scale down resources during low usage periods.
• What to include:
  • Boolean answer (“yes” or “no”).

14. Geographical Scaling

• What it’s for: Indicates if the system supports scaling across multiple regions.

• What to include:

  • Explain the geographical scaling approach:

  • Single-region scaling.

  • Multi-region deployments.

  • Mention how data synchronization or load balancing works between regions.

• Example: "The application scales across geographical regions using AWS Route 53 for DNS routing and CloudFront for distributed content delivery."

15. Bottlenecks

• What it’s for: Lists identified bottlenecks that prevent scalability.

• What to include:

  • Clearly identify scaling challenges (e.g., resource contention, technical debt, external APIs).
  • Suggest possible mitigations if documented.

• Example: "Current bottlenecks include limited database write throughput and synchronous dependencies on third-party APIs, which delay response times during high traffic."

General Guidance

• Be detailed yet concise when describing scalability attributes.
• Use measurable metrics (e.g., thresholds, capacity limits).
• Tie scalability strategies to business outcomes, highlighting cost, performance, or user experience improvements.