Load Test Execution Plan Template
A template to plan, execute, and document load tests that measure system behavior under realistic or peak traffic.
Overview
A load test plan tells you what to measure. An execution plan tells you who runs what, in which environment, in which order, and what to do when the numbers come back wrong. Teams that skip the second half end up re-running the same test three times: once because the environment wasn’t reset, once because nobody captured the config, and once because the threshold was never written down.
This template is the day-of-the-test runbook. It pairs with the Load Test Plan Template, which defines the objectives, user journeys, and thresholds this document executes against, and the Load Test Report Template, which captures the findings afterward.
When to Use
- Before a launch, marketing campaign, or seasonal event that will multiply traffic.
- After a migration, scaling change, or architecture rework that needs validation under load.
- When capacity numbers were extrapolated from a spreadsheet and nobody trusts them.
- As the repeatable runbook for a quarterly or per-release performance regression suite.
- When a vendor, platform, or SLA claim has to be verified with measurements, not marketing.
Don’t use it for unit-level microbenchmarks, single-endpoint smoke tests, or profiling a slow function: those need a profiler, not a plan.
How to Use This Template
- Copy the template into your team’s docs space and assign a test owner before you fill in anything else.
- Fill section 1 first; if you can’t state the goal in one sentence, the test isn’t ready.
- Book the environment window and notify every team in the stakeholders row.
- Execute section 5 step by step during the test; don’t improvise the order.
- Record results in section 6 while the test runs, not from memory afterward.
- Turn every failed threshold into a finding in section 7 with an owner and a due date.
- File the results in the Load Test Report Template and archive both documents where the team actually looks during incidents.
- Re-run after each remediation lands; a finding without a re-test is a guess.
1. Test Goals and Scope
One line per row. If a field doesn’t apply, write N/A rather than leaving it blank; blank fields get read as “forgot to fill in”.
| Field | Description | Example |
|---|---|---|
| Test ID | Unique identifier | LT-2026-Q3-001 |
| System under test | Application or service | Checkout API |
| Test date | When the test runs | 2026-06-27 |
| Test owner | Responsible engineer | Performance team |
| Stakeholders | Teams to notify | SRE, backend, platform, product |
| Goal | Why the test is run | Validate checkout handles 10x traffic at launch |
| Scope | What is included | API endpoints, database, cache, queue |
| Out of scope | What isn’t tested | Payment processor, third-party integrations |
2. Test Scenarios
Weight each scenario by real traffic share, not by what’s easiest to script. Pull the mix from production access logs or your APM’s endpoint breakdown, and keep at least one write-heavy journey, since read-only tests hide the failure modes that hurt.
| Scenario ID | Description | Endpoint / Flow | Virtual Users | Ramp Up | Duration | Think Time |
|---|---|---|---|---|---|---|
| S01 | Browse catalog | GET /products | 500 | 2 min | 10 min | 1-3 s |
| S02 | Add to cart | POST /cart/items | 300 | 2 min | 10 min | 1-3 s |
| S03 | Checkout | POST /orders | 200 | 2 min | 10 min | 2-5 s |
| S04 | Search | GET /search?q=... | 400 | 2 min | 10 min | 1-2 s |
| S05 | Peak burst | All endpoints combined | 2000 | 5 min | 15 min | 0-1 s |
3. Success Criteria
Three columns matter: Baseline is what you measured in the last run or in production, Target is what the business needs, and Must Stay Below is the abort condition. When a metric crosses the abort line mid-test, stop; a test that takes the checkout flow down isn’t data, it’s an incident.
| Metric | Baseline | Target | Must Stay Below | Notes |
|---|---|---|---|---|
| p50 latency | 45 ms | < 60 ms | 80 ms | For API responses |
| p95 latency | 120 ms | < 150 ms | 200 ms | For API responses |
| p99 latency | 300 ms | < 400 ms | 600 ms | For API responses |
| Error rate | 0.01% | < 0.1% | 0.5% | HTTP 5xx and timeouts |
| Throughput | 1000 RPS | > 2000 RPS | - | Orders per second |
| CPU utilization | 40% | < 70% | 80% | Per application node |
| Memory utilization | 50% | < 70% | 85% | Per application node |
| Database connections | 80 | < 150 | 200 | Active connections |
| Queue depth | 10 | < 50 | 100 | Background jobs |
4. Environment Setup
The closer the environment is to production, the more the results are worth. A quarter-scale environment can still validate relative regressions, but record the scale factor so nobody compares the numbers directly against production later.
| Resource | dev/test | production | Notes |
|---|---|---|---|
| Application nodes | 2 | 6 | Same instance size |
| Load balancer | 1 | 2 | Same configuration |
| Database | Single instance | Multi-AZ cluster | Same major version |
| Cache | 1 node | 3 nodes | Same engine version |
| Message queue | 1 node | 3 nodes | Same configuration |
| Load generator | 4 injectors | N/A | Cloud instances or containers |
| Network | Isolated VPC | Production VPC | Mirror latency and topology |
| Data volume | 10% of production | Full production | Use anonymized data |
5. Execution Plan
T0 is when the first real scenario starts. Everything before it exists to guarantee the test measures the system, not leftover state from the previous run.
| Step | Action | Owner | Time |
|---|---|---|---|
| 1 | Verify environment and monitoring | SRE | T-30 min |
| 2 | Reset environment to known state | SRE | T-20 min |
| 3 | Deploy test scripts and data | Performance team | T-15 min |
| 4 | Run baseline test at low load | Performance team | T-10 min |
| 5 | Execute scenario S01-S04 | Performance team | T0 |
| 6 | Execute peak scenario S05 | Performance team | T+15 min |
| 7 | Monitor system and collect metrics | SRE | T+15 to T+30 min |
| 8 | Gradually reduce load and stop test | Performance team | T+30 min |
| 9 | Export results and logs | Performance team | T+35 min |
| 10 | Restore environment | SRE | T+45 min |
6. Results and Analysis
Fill this table during the test, while the dashboards are open. Numbers reconstructed from memory a week later tend to round themselves toward “pass”.
| Scenario | Max VUs | Peak RPS | p95 Latency | p99 Latency | Error Rate | CPU Avg | Memory Avg | Result |
|---|---|---|---|---|---|---|---|---|
| S01 | 500 | 1200 | 55 ms | 180 ms | 0.01% | 45% | 60% | Pass |
| S02 | 300 | 800 | 90 ms | 250 ms | 0.02% | 55% | 65% | Pass |
| S03 | 200 | 450 | 140 ms | 380 ms | 0.05% | 60% | 70% | Pass |
| S04 | 400 | 950 | 70 ms | 210 ms | 0.01% | 50% | 62% | Pass |
| S05 | 2000 | 3400 | 220 ms | 700 ms | 0.8% | 85% | 88% | Fail |
7. Findings and Remediation
Every Fail in section 6 gets a row here. A finding without an owner and a due date is a comment, not a remediation.
| Finding ID | Description | Severity | Recommendation | Owner | Due Date |
|---|---|---|---|---|---|
| LT-001 | Database connection pool exhausted during peak | High | Increase pool size and add connection retry | Backend team | 2026-07-04 |
| LT-002 | Cache hit ratio drops under search load | Medium | Add search result caching and tune TTL | Backend team | 2026-07-11 |
| LT-003 | Queue depth grows when order rate exceeds consumer capacity | Medium | Scale background workers horizontally | Platform team | 2026-07-11 |
Explanation
The plan answers “what do we test and what does good look like”. The execution plan answers the operational questions the plan can’t: who’s on the bridge during the test, which environment, in what order, when to abort, and where the evidence lands afterward. Keeping them separate matters because they change on different cadences: the plan gets revised when requirements change, the execution plan gets revised when the environment or the team does.
The lifecycle looks like this:
k6 Load Test Script Example
The script below ramps to the 2,000 virtual users from scenario S05, tags every request with a correlation ID, and records a custom failure rate as a Rate metric so it can gate the run in thresholds. One check call per response: calling check() twice on the same response double-counts it in k6’s built-in metrics.
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';
const failureRate = new Rate('check_failure_rate');
export const options = {
stages: [
{ duration: '2m', target: 100 },
{ duration: '5m', target: 100 },
{ duration: '2m', target: 300 },
{ duration: '5m', target: 300 },
{ duration: '2m', target: 500 },
{ duration: '5m', target: 500 },
{ duration: '2m', target: 2000 },
{ duration: '5m', target: 2000 },
{ duration: '5m', target: 0 },
],
thresholds: {
http_req_duration: ['p(95)<500', 'p(99)<1000'],
http_req_failed: ['rate<0.01'],
check_failure_rate: ['rate<0.05'],
},
};
export default function () {
const headers = {
'X-Correlation-Id': `corr_${__VU}_${__ITER}`,
'Content-Type': 'application/json',
};
const loginRes = http.post('https://api.example.com/auth/login', JSON.stringify({
username: `user_${__VU % 100}`,
password: 'test-password',
}), { headers });
const loginOk = check(loginRes, {
'login status 200': (r) => r.status === 200,
'login has token': (r) => r.json('token') !== undefined,
});
failureRate.add(!loginOk);
sleep(Math.random() * 2 + 1);
const listRes = http.get('https://api.example.com/orders', {
headers: { ...headers, Authorization: `Bearer ${loginRes.json('token')}` },
});
const ordersOk = check(listRes, {
'orders status 200': (r) => r.status === 200,
'orders has items': (r) => r.json('items').length > 0,
});
failureRate.add(!ordersOk);
sleep(Math.random() * 3 + 1);
}
Variants
- Spike test plan: fire a sudden burst of traffic at the system and check whether it survives the shock and recovers on its own.
- Stress test plan: keep adding load past the expected limit until the failure mode shows itself.
- Endurance test plan: hold a moderate load for hours or days; this is how memory leaks and drift surface.
- Soak test plan: run production-like load over a long window to validate stability rather than capacity.
- Scalability test plan: add resources while the load grows and measure whether the system actually keeps up.
- Browser-based load test plan: drive real browser sessions so frontend and API get measured together.
What Works
- Test in a production-like environment with representative data and traffic patterns.
- Write the success criteria down before the run, while nobody has a result to defend.
- Start with a baseline at low load and ramp gradually; instant full load tells you nothing.
- Monitor infrastructure metrics next to application metrics; a red CPU graph is a finding.
- Re-run the test to confirm a result is reproducible before you report it.
- Include business metrics like conversion rate or orders per second, not just latency.
- Give every finding an owner and a due date before closing the test.
- Automate regression tests in CI for the critical paths between full executions.
Common Mistakes
- Running the test against production without isolation, flags, or a rollback plan.
- Scripting synthetic traffic that doesn’t match the real request mix from logs.
- Testing one endpoint instead of the full journey; the bottleneck lives between them.
- Ignoring warm-up: cold caches and empty connection pools skew the first minutes.
- Skipping the environment reset, so the test measures yesterday’s leftover state.
- Letting the load generator become the bottleneck; watch its CPU and network too.
- Marking a failed threshold as “pass, environmental issue” without a re-test.
- Declaring success without recording the config, so nobody can reproduce it later.
Troubleshooting
- Load generator saturates before the system does: the injectors hit their own CPU or network ceiling and the server looks fine. Watch the generator’s metrics, split load across more injectors, and check for coordinated omission: k6 and JMeter queue requests they can’t send, so reported arrival rates lie.
- Results differ wildly between runs: the environment has noisy neighbors, auto-scaling kicked in mid-test, or the previous run’s data wasn’t cleaned out. Lock the window, disable scaling during the test, and always reset to a known state.
- Error rate spikes only at high VU counts: check the generator’s file-descriptor and port limits before blaming the app:
ulimit -nand ephemeral port exhaustion fake server failures. - Thresholds fail on day one but the system is healthy: the targets were extrapolated, not measured. Re-baseline from real production data before re-running.
- p99 looks fine but users still complain: your percentiles hide a bimodal response: a small percentage of requests time out or retry. Check the max and the error rate, not just the tail percentiles.
See Also
- Load Test Plan Template — the objectives, journeys, and thresholds this execution plan runs against.
- Load Test Report Template — where the findings and remediation get filed.
- Capacity Planning Forecast Template — turn the measured limits into a growth forecast.
- k6 documentation — scripting reference, thresholds, and executor types.
- Apache JMeter user manual — the reference for JMeter test plans and listeners.
- Companion files — the fillable execution-plan template and a runnable k6 script from this resource.
Frequently Asked Questions
What tools are commonly used for load testing?
k6, Apache JMeter, Gatling, Locust, and Artillery cover most use cases. Pick based on protocol support, the language your team scripts in, and how the results feed your dashboards.
How do we simulate realistic user behavior?
Model the request mix from production logs, add think time between requests, vary the input data, and keep a realistic ratio of reads to writes. Uniform random traffic finds uniform random problems.
Should we run load tests in production?
Only with synthetic traffic, feature flags, and an abort plan, and only when there's no other way to get the answer. Everything else belongs in a production-like environment.
How do we correlate load test results with infrastructure metrics?
Capture infrastructure metrics (CPU, memory, network, disk I/O) alongside application metrics during the run, on a dashboard that overlays both. After the test, find which component hit its ceiling first and whether the bottleneck was compute, connections, or I/O.
What's the difference between spike, stress, and endurance testing?
Spike testing fires a sudden burst of traffic at the system to find out whether it survives and recovers. A stress test keeps adding load until something breaks so you can see the failure mode. An endurance test holds moderate load for hours to catch memory leaks and drift. A serious performance strategy runs all three.
What should we do if the load test fails?
Don't re-run immediately: figure out why first. Identify the scenario and threshold that broke, check infrastructure metrics for the bottleneck, and separate a real performance issue from an environment problem. Log the finding with an owner and a fix, then re-test to confirm it worked.
How often should we run load tests?
Full tests before major releases, regression tests in CI on critical paths, endurance tests quarterly, and spike tests before expected traffic events. And re-run after significant infrastructure changes, because new instance types, database upgrades, or a reworked architecture invalidate the old numbers.
Related Resources
Load Test Plan Template
Fillable load test plan template: scenarios, ramp-up profiles, pass/fail thresholds, monitoring setup, and ready-to-run k6, JMeter and Locust scripts.
DocLoad Test Report Template: Benchmarks and Bottlenecks
A standardized template for documenting load test results: throughput, latency percentiles, error rates, bottlenecks with evidence, and action items — with a worked k6 example.
DocCapacity Planning Forecast Template
A structured template for forecasting infrastructure growth, identifying resource bottlenecks, and planning capacity before traffic surges cause outages.
DocMonitoring and Alerting Policy Template
A policy template that defines how alerts are configured, routed, escalated, and reviewed across services and infrastructure.
DocRunbook Template
A reusable template for operational runbooks: incident response, deployment procedures, and routine tasks.
GuideWeb Performance Optimization Guide
A thorough guide to optimizing web application performance for better Core Web Vitals and user experience.