Load Testing
Load testing sends controlled, repeatable demand to a system and measures how it behaves. You use it to check expected traffic, find capacity limits, and expose performance failures before real users do.
itObservability and performance | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic - Load Testing
Load Testing is the subject of this course. Load testing answers a practical question: what happens when many users or requests reach a system at once? You create controlled demand, observe the system, and compare the results with an explicit goal.
The useful unit of work is a closed loop: clarify the goal and boundaries, gather the inputs the practice requires, make the decision or change, record evidence, and return with owners for the next cycle. Skipping any link leaves teams busy without durable results.
Tooling supports the loop; it does not replace it. Choose tools after the boundary and evidence model are clear. Comparing products without that model produces feature matrices that do not change how the work runs.
Common failure modes include undefined ownership, metrics that count activity instead of outcomes, and irreversible steps taken without a review path. Treat those as design defects in the practice, not as individual heroics to compensate later.
Operators should be able to explain which signals would change a decision this week. If no signal can change the plan, the practice has become ritual. Keep the feedback path short enough that evidence still influences the next cycle.
Name the owners for each stage of the loop before the work scales. Unowned stages become permanent exceptions. Record decisions with enough context that a future operator can tell why a tradeoff was accepted. Prefer fewer, sharper metrics that change behavior over broad dashboards that only describe activity after the fact.
Read the Intro for the core model. Use the Cheatsheet when you need the operating map. Updates tracks official guidance when this course configures an update source; otherwise the practice is settled without a live feed.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://grafana.com/docs/k6/latest/testing-guides/api-load-testing/
Supports
- Test goals determine load profiles
- Expected-traffic and unusual-traffic objectives
- Smoke, average-load, stress, and spike purposes
- Realistic scenarios before workload configuration
- https://grafana.com/docs/k6/latest/examples/get-started-with-k6/test-for-performance/
Supports
- Smoke testing before larger execution
- Scenarios as workload schedulers
- Ramp, hold, and ramp-down structure
- Checks and thresholds in a performance test
- https://grafana.com/docs/k6/latest/using-k6/scenarios/concepts/open-vs-closed/
Supports
- Closed-model iteration scheduling
- Open-model arrival scheduling
- Response-time coupling and coordinated omission risk
- https://grafana.com/docs/k6/latest/using-k6/metrics/
Supports
- Counter, gauge, rate, and trend metric types
- Requests, errors, and duration as starting metrics
- Percentiles in latency summaries
- https://grafana.com/docs/k6/latest/using-k6/metrics/reference/
Supports
- Active and maximum virtual-user metrics
- Dropped iterations
- HTTP request duration, failure rate, and request count
- https://grafana.com/docs/k6/latest/using-k6/thresholds/
Supports
- Thresholds as metric-based pass or fail criteria
- Latency-percentile and error-rate criteria
- Failed thresholds affecting process exit status
- Difference between checks and thresholds
- https://grafana.com/docs/k6/latest/testing-guides/running-large-tests/
Supports
- Load-generator resource limits
- Distributed execution across multiple instances
- Need to validate generator capacity for large tests
- https://grafana.com/docs/k6/latest/testing-guides/automated-performance-testing/
Supports
- Repeatable performance checks across development stages
- Workload reuse across different test profiles
- Smoke and average-load tests as recurring foundations
- Stopping tests after complete overload
- https://grafana.com/docs/k6/latest/testing-guides/load-testing-websites/
Supports
- Pre-production and production environment tradeoffs
- Generator location and environment as execution considerations
- Higher production realism and risk
- https://jmeter.apache.org/usermanual/test_plan.html
Supports
- Threads as independent simulated connections
- Ramp-up, loops, duration, and startup delay
- Samplers as request senders
- https://jmeter.apache.org/usermanual/best-practices.html
Supports
- Correct generator sizing
- Coordinated omission warning
- Distributed execution for large-scale tests
- Parameterized scripts and test data
- https://sre.google/sre-book/monitoring-distributed-systems/
Supports
- Latency, traffic, errors, and saturation
- Separate treatment of successful and failed latency
- Explicit, implicit, and policy-defined errors
- Resource fullness as saturation
- https://sre.google/sre-book/introduction/
Supports
- Load testing as input to capacity planning
- Correlation of raw resources with service capacity
- Forecast demand as a capacity-planning input
- https://sre.google/sre-book/addressing-cascading-failures/
Supports
- Testing capacity limits and overload failure modes
- Queue growth, latency, and resource exhaustion
- Performance testing coupled with capacity planning
- Stop and rejection behavior during overload
- https://sre.google/sre-book/practical-alerting/
Supports
- Response-time distributions and latency tails
- High-level objectives with detailed diagnostic signals
- https://github.com/sindresorhus/awesome
Supports
- Starting index used for required awesome-list discovery
- https://github.com/andriisoldatenko/awesome-performance-testing
Supports
- Curated discovery of Locust, Gatling, Artillery, and Taurus as load-testing ecosystem tools
- https://docs.locust.io/en/stable/
Supports
- Python test authoring
- Web and command-line execution
- Distributed load generation
- https://docs.gatling.io/
Supports
- Code-driven load testing
- Supported Java, JavaScript, TypeScript, Scala, and Kotlin SDKs
- Load-model and protocol documentation
- https://www.artillery.io/docs/reference/test-script
Supports
- YAML, TypeScript, and JavaScript test definitions
- Configuration, load phases, and virtual-user scenarios
- https://gettaurus.org/
Supports
- YAML test configuration
- Repeated-test automation
- JMeter execution support
