Skip to content
Skills Library
DevOps & cloud · Testing

load-testing

/load-testing

Measures how a system behaves under load and finds where it breaks — throughput ceilings, latency under concurrency, and failure modes at saturation. Use this whenever the user mentions load testing, stress testing, benchmarking, capacity planning, an upcoming traffic spike, or asks how many users the system can handle. For making already-identified slowness faster, use performance-profiling.

Author
OKHP3 ↗
Repository
skillz ↗
Licence
MIT
Last repository change
25.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Measures how a system behaves under load and finds where it breaks — throughput ceilings, latency under concurrency, and failure modes at saturation. Use this whenever the user mentions load testing, stress testing, benchmarking, capacity planning, an upcoming traffic spike, or asks how many users the system can handle. For making already-identified slowness faster, use performance-profiling.

Original author description

Measures how a system behaves under load and finds where it breaks — throughput ceilings, latency under concurrency, and failure modes at saturation. Use this whenever the user mentions load testing, stress testing, benchmarking, capacity planning, an upcoming traffic spike, or asks how many users the system can handle. For making already-identified slowness faster, use performance-profiling.

How it works

  1. 1. Model realistic traffic, not a single endpoint
  2. 2. Test something that resembles production
  3. 3. Ramp, and watch for the knee
  4. 4. Measure the right things
  5. 5. Do not test in production carelessly
  6. Report
Original SKILL.md headings · 87 lines, 643 words
SKILL.md preview
---
name: load-testing
description: Measures how a system behaves under load and finds where it breaks — throughput ceilings, latency under concurrency, and failure modes at saturation. Use this whenever the user mentions load testing, stress testing, benchmarking, capacity planning, an upcoming traffic spike, or asks how many users the system can handle. For making already-identified slowness faster, use performance-profiling.
license: MIT
---

# Load testing

A load test answers one of two questions, and confusing them wastes the effort:

- **Can it handle X?:** a specific, known target. Verification.
- **Where does it break, and how?:** the ceiling and the failure mode. Discovery.

Discovery is usually more valuable. Knowing you handle 1,000 requests per second tells you less
than knowing that at 1,200 the connection pool exhausts and every request hangs for 30 seconds
rather than failing fast.

## 1. Model realistic traffic, not a single endpoint

Hammering one endpoint measures that endpoint. Real systems fail through interaction — a slow
report query saturating the pool that the login path needs.

Model:
- **The mix:** which endpoints, in what proportion, from real traffic data
- **The shape:** steady, spiky, or diurnal. A ramp reveals different problems than a sudden step
- **Think time:** real users pause. Zero think time produces an unrealistic connection pattern
- **The data distribution:** everyone hitting one hot row behaves nothing like a spread of keys.
  This is a very common cause of misleading results

**Done when:** the generated traffic resembles what production actually sees.

## 2. Test something that resembles production

A load test against a laptop tells you about the laptop.

Match, or document the difference: instance sizes, replica counts, database size and data
volume, network topology, and — critically — caches in a realistic state. A cold cache and a
fully warm one give completely different numbers, and neither may be the steady state.

**Done when:** you can state how the environment differs from production and how that skews the
result.

## 3. Ramp, and watch for the knee

Do not start at target load. Ramp, and watch for the point where the response curve bends.

Below saturation, latency stays roughly flat as throughput rises. At the knee, latency climbs
sharply while throughput stops rising. That point is your real capacity, and it is usually well
below the number where errors start.

Past the knee, watch what happens — this is the most valuable part of the exercise:
- Does it degrade gracefully or collapse?
- Does it shed load, queue indefinitely, or crash?
- **Does it recover when load drops?** A system that stays broken after the spike passes is a
  much worse problem than one that briefly fails.

**Done when:** you have located the knee and observed behaviour beyond it.

## 4. Measure the right things

- **Latency percentiles:** p50, p95, p99. Never the mean; under load, the mean is dominated by
  a tail that is where the real user pain lives
- **Throughput**, alongside latency. Either alone is misleading
- **Error rate by type:** timeouts, 5xx, and connection refusals mean different things
- **Saturation of each resource:** CPU, memory, connection pool, file descriptors, thread pool,
  disk and network I/O. **The bottleneck is nearly always one of these**, and identifying which
  is the whole point

Measure from the client side too. Server-side timings exclude queueing, and queueing is exactly
what happens under load.

**Done when:** you can name the resource that saturates first.

## 5. Do not test in production carelessly

If you must test against production, and there are good reasons to — take precautions: schedule
it, tell people, mark synthetic traffic so it can be excluded from metrics and billing, have a
kill switch, and start small.

Otherwise you are running an incident on purpose. See `incident-response` if it turns into one.

**Done when:** the test can be stopped instantly and its traffic is distinguishable.

## Report

Report the knee, the saturating resource, and the failure mode — those three are the output.
Include the environment's differences from production and the traffic model, because a number
without them is not comparable to anything.

Then say what capacity headroom this implies against current traffic. That is the question
whoever asked for the test actually has.

Versions

RepositoryScoreLicence
This page · OKHP3/skillz90MIT
claude-dev-suite/claude-dev-suite100MIT
SkillMedev/skills100MIT
ajyadav013/claude-kit100MIT
ajyadav013/claude-kit100MIT
rnavarych/alpha-engineer100MIT
VilnaCRM-Org/rust-service-template96CC0-1.0
Amey-Thakur/AI-SKILLS90MIT
arjunprabhulal/devops-skills90MIT

Database snapshot: 13.11.2026 · package version 96b29cb2bf99 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100ai-stress-test
    Test system behavior under extreme load to find breaking points, capacity limits, and failure modes. Covers stress, spike, and breakpoint testing with k6 (primary), JMeter, or Locust. Refuses unbounded concurrency and production saturation without explicit approval. Trigger for…
  • 100performance-testing
    Profiles application performance under load using k6, Artillery, or JMeter to measure latency, throughput, and error rates. Use when planning load tests, stress tests, soak tests, benchmarking APIs, or identifying performance bottlenecks.
  • 100performance-testing
    Use when measuring a system's non-functional properties — latency, throughput, error rate, resource utilization, saturation — by running it under controlled load and verifying against explicit SLO thresholds. Covers the five primitives (load profile, workload, latency metric,…
  • 100http-load-profiler
    Run stepped HTTP load tests with ab/wrk, ramping concurrency levels to collect p50/p90/p99 latency, detect performance inflection points, and recommend optimal concurrency. Triggered by requests like 'load test this URL', 'benchmark my API', 'find the max concurrency', or…
  • 100running-performance-tests
    Execute load testing, stress testing, and performance benchmarking. Use when performing specialized testing. Trigger with phrases like "run load tests", "test performance", or "benchmark the system".
  • 100test-load
    Design and run a k6 or Artillery load profile: throughput, latency percentiles, error rate, breaking point. Use when "load test this", "will it handle launch traffic", or "find the breaking point". Code-level resilience → audit-resilience.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.