StackPractices
intermediate By Mathias Paulenko

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

  1. Copy the template into your team’s docs space and assign a test owner before you fill in anything else.
  2. Fill section 1 first; if you can’t state the goal in one sentence, the test isn’t ready.
  3. Book the environment window and notify every team in the stakeholders row.
  4. Execute section 5 step by step during the test; don’t improvise the order.
  5. Record results in section 6 while the test runs, not from memory afterward.
  6. Turn every failed threshold into a finding in section 7 with an owner and a due date.
  7. File the results in the Load Test Report Template and archive both documents where the team actually looks during incidents.
  8. 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”.

FieldDescriptionExample
Test IDUnique identifierLT-2026-Q3-001
System under testApplication or serviceCheckout API
Test dateWhen the test runs2026-06-27
Test ownerResponsible engineerPerformance team
StakeholdersTeams to notifySRE, backend, platform, product
GoalWhy the test is runValidate checkout handles 10x traffic at launch
ScopeWhat is includedAPI endpoints, database, cache, queue
Out of scopeWhat isn’t testedPayment 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 IDDescriptionEndpoint / FlowVirtual UsersRamp UpDurationThink Time
S01Browse catalogGET /products5002 min10 min1-3 s
S02Add to cartPOST /cart/items3002 min10 min1-3 s
S03CheckoutPOST /orders2002 min10 min2-5 s
S04SearchGET /search?q=...4002 min10 min1-2 s
S05Peak burstAll endpoints combined20005 min15 min0-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.

MetricBaselineTargetMust Stay BelowNotes
p50 latency45 ms< 60 ms80 msFor API responses
p95 latency120 ms< 150 ms200 msFor API responses
p99 latency300 ms< 400 ms600 msFor API responses
Error rate0.01%< 0.1%0.5%HTTP 5xx and timeouts
Throughput1000 RPS> 2000 RPS-Orders per second
CPU utilization40%< 70%80%Per application node
Memory utilization50%< 70%85%Per application node
Database connections80< 150200Active connections
Queue depth10< 50100Background 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.

Resourcedev/testproductionNotes
Application nodes26Same instance size
Load balancer12Same configuration
DatabaseSingle instanceMulti-AZ clusterSame major version
Cache1 node3 nodesSame engine version
Message queue1 node3 nodesSame configuration
Load generator4 injectorsN/ACloud instances or containers
NetworkIsolated VPCProduction VPCMirror latency and topology
Data volume10% of productionFull productionUse 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.

StepActionOwnerTime
1Verify environment and monitoringSRET-30 min
2Reset environment to known stateSRET-20 min
3Deploy test scripts and dataPerformance teamT-15 min
4Run baseline test at low loadPerformance teamT-10 min
5Execute scenario S01-S04Performance teamT0
6Execute peak scenario S05Performance teamT+15 min
7Monitor system and collect metricsSRET+15 to T+30 min
8Gradually reduce load and stop testPerformance teamT+30 min
9Export results and logsPerformance teamT+35 min
10Restore environmentSRET+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”.

ScenarioMax VUsPeak RPSp95 Latencyp99 LatencyError RateCPU AvgMemory AvgResult
S01500120055 ms180 ms0.01%45%60%Pass
S0230080090 ms250 ms0.02%55%65%Pass
S03200450140 ms380 ms0.05%60%70%Pass
S0440095070 ms210 ms0.01%50%62%Pass
S0520003400220 ms700 ms0.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 IDDescriptionSeverityRecommendationOwnerDue Date
LT-001Database connection pool exhausted during peakHighIncrease pool size and add connection retryBackend team2026-07-04
LT-002Cache hit ratio drops under search loadMediumAdd search result caching and tune TTLBackend team2026-07-11
LT-003Queue depth grows when order rate exceeds consumer capacityMediumScale background workers horizontallyPlatform team2026-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:

Load test execution lifecycle from environment verification through remediation and re-test

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 -n and 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

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.