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
Intro
Load Testing
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 goal might be a response-time target, an error-rate limit, or a capacity estimate. A useful test produces evidence for a decision. It does not just produce traffic.
The mental model
Think of a load test as five connected parts:
- Objective — the decision you need to make.
- Workload — the traffic pattern you apply.
- System under test — the application and dependencies that receive the traffic.
- Measurements — user-facing results and resource behavior.
- Thresholds — the conditions that determine whether the result is acceptable.
Weakness in any part weakens the conclusion. A precise dashboard cannot rescue an unrealistic workload. A realistic workload cannot produce a clear verdict without thresholds.
Start with the decision
Choose the question before the tool.
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
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