> For the complete documentation index, see [llms.txt](https://developer.harness.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.harness.io/resilience-testing/load-testing/analyze-results.md).

# Analyze Load Test Results

Understand and interpret load test execution results in Harness Resilience Testing

After you run a load test, Harness opens the **Run detail** page and streams results in real time. The same page shows the final results after the run finishes.

***

## Access results <a href="#access-results" id="access-results"></a>

Go to **Resilience Testing** > **Load Tests**. The page has three tabs.

| Tab                      | What it lists                                                                                                                                                                                                                                                              |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Executions**           | Every run across all load tests, newest first. Each row reports the run identifier, **Users**, **Duration**, **Avg Response Time**, **Success Rate**, **Status**, and who started it. Filter by **Status** to isolate **Failed** or **Stopped** runs.                      |
| **Load Tests**           | The tests themselves, with **Mode**, **Infrastructure**, recent executions, and when each was last modified. Filter by **Type** or **Tag(s)**.                                                                                                                             |
| **Composite Load Tests** | Pipelines that sequence one or more load tests, with a **No. of Load Tests** count, recent executions, and when each was last modified. Go to [Composite load tests](https://developer.harness.io/resilience-testing/load-testing/composite-load-tests.md) to review them. |

To open a single run, select it from **Executions**, or open a test from **Load Tests** and choose a run from its execution list. Each execution is numbered and keeps its own results, so you can compare runs over time.

The list is sorted by **Last Executed (New -> Old)**. A run that reports **Not Available** for **Success Rate** produced no metrics, which usually means it failed or was stopped before generating load. Open the run and read its logs rather than the summary columns. **Duration** and **Users** frequently read **Not Available** and `0` even on a healthy run, because they reflect what was configured in the Load Test Studio rather than what the script did.

***

## Page anatomy <a href="#page-anatomy" id="page-anatomy"></a>

Every Load Test Engine uses the same Run detail layout, top to bottom.

* **About This Test.** The left rail, holding the test metadata and the live status of the execution. Every engine reports **Test Name**, **Load Test Infrastructure**, **Load Test Engine**, **Users**, **Duration**, **Run Started By**, **Time Elapsed**, and **Status**. The remaining fields describe how the load was distributed and vary by engine.
* **AI Insights.** A generated analysis of the finished run: a headline with the most important number, a short summary, the findings that stood out with their risk and recommendation, next steps, and what the run could not tell you. Collapse it with the chevron. Go to [AI Insights](https://developer.harness.io/resilience-testing/load-testing/analyze-results/ai-insights.md) to read the card and generate insights for an older run.
* **Summary cards.** Six headline metrics: **Total Requests**, **RPS**, the error card, and the **P50**, **P95**, and **P99** response time percentiles in milliseconds. The error card is labeled **Failed Rate** for JavaScript (k6) and **Error Rate** for Python (Locust) and Java (JMeter), and turns red above zero.
* **Thresholds.** Each declared criterion with its **Metric**, pass/fail **Condition** such as `p(95)<5000`, the **Actual** measured value, and a **Status** that reads `PENDING` while the run is in progress. A breached threshold does not mark the run as **Failed**. A run that completes with a breached threshold ends with **Finished** status and the code `E3006: THRESHOLD_CROSSED`. A threshold configured to abort the run stops it when it breaches, and the run ends with **Stopped** status and the code `E3005: THRESHOLD_ABORT`. A test with no thresholds shows an empty state instead of a table.
* **Charts.** Four time-series views, described below.
* **Action rail.** A column of actions on the right edge of the page, to run, edit, or clone the test, download its manifest, open the report, add notes, and open the logs. Go to [Run Actions](https://developer.harness.io/resilience-testing/load-testing/analyze-results/run-actions.md) to read what each action does.
* **Endpoint Statistics.** A per-endpoint breakdown. Each row shows the **Endpoint**, **Requests**, **Fails**, a **Latency (ms)** bar marking the median (M), 95th (95), and 99th (99) percentiles, the **Avg (ms)**, and the **Current RPS**. An **Aggregated** row totals every endpoint. Use this table to find which specific endpoint is slow or failing rather than reading the whole-test averages.

## Charts <a href="#charts" id="charts"></a>

**Active Users** plots concurrent virtual users over time. Use it to confirm the load followed the shape you configured: a ramp-up from zero to the configured peak, a steady-state plateau, and a ramp-down at the end. An early drop means the run stopped or failed.

**Total Requests Per Second** plots throughput in green and errors per second in red. Read the two lines together. A rising red line while the green line flattens is a strong sign the system is at capacity.

**Response Time Distribution** is a scatter plot of individual response times, color-coded by request name and outcome, so a `Success` and a `Failure` series appear for each named request. Use it to spot latency that drifts upward as load increases and to identify which request produces the outliers.

![The Total Requests Per Second chart with throughput in green and errors per second in red, above the Response Time Distribution scatter plot showing separate success and failure series per request](https://3217710372-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRmV5EkLS9r45VPaoUnJZ%2Fuploads%2Fgit-blob-c32e31c087a34cfaf439749f4e1fa11cf297969a%2Flocust-charts.png?alt=media)

In this run the failed POST requests cluster higher in the distribution than the successful GET requests, which localizes the latency problem to one route.

**Response Time Histogram** bins the per-request response times and plots how many requests fell into each latency band. The subtitle notes that the top one percent of samples is clipped so a few slow outliers do not distort the scale. Use it to see the typical latency band and how tightly response times cluster.

![The Response Time Histogram binning response times into latency bands, the collapsed Load Test Logs panel, and the Endpoint Statistics table with its median, 95th, and 99th percentile latency bars](https://3217710372-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRmV5EkLS9r45VPaoUnJZ%2Fuploads%2Fgit-blob-3d0147c8171afe4af7618c198e1e65a1d09629e6%2Fjmeter-histogram-endpoint-stats.png?alt=media)

***

## Engine differences <a href="#engine-differences" id="engine-differences"></a>

Select your engine to see the fields and tables that are specific to it.

{% @harness-package-selector/package-selector platforms="%5B%7B%22label%22%3A%22Python%22%2C%22slug%22%3A%22python%22%2C%22path%22%3A%22resilience-testing%2Fload-testing%2Fanalyze-results%2Fpython-analyze-results%22%7D%2C%7B%22label%22%3A%22JavaScript%22%2C%22slug%22%3A%22javascript%22%2C%22path%22%3A%22resilience-testing%2Fload-testing%2Fanalyze-results%2Fjavascript-analyze-results%22%7D%2C%7B%22label%22%3A%22Java%22%2C%22slug%22%3A%22java%22%2C%22path%22%3A%22resilience-testing%2Fload-testing%2Fanalyze-results%2Fjava-analyze-results%22%7D%5D" %}

***

## Interpret the results <a href="#interpret-the-results" id="interpret-the-results"></a>

The following guidance applies to every engine.

A healthy run holds **Error Rate** (or **Failed Rate**) at or near `0.00%`, keeps **P95** and **P99** within your SLA or performance budget, scales **RPS** with active users during ramp-up, and produces a response time distribution that clusters consistently without upward drift.

These are the patterns worth investigating.

* **Error rate climbing during ramp-up:** the system may hit capacity before reaching the target user count.
* **Response times rising over time:** a possible memory leak, connection pool exhaustion, or resource saturation.
* **Throughput plateauing while users increase:** a bottleneck is capping request processing, such as CPU, database connections, or rate limiting.
* **A wide gap between P50 and P99:** the median request is fine while the tail is not, which points at intermittent issues like garbage collection pauses, DNS delays, or cold starts.
* **One endpoint failing in Endpoint Statistics:** the problem is scoped to that route, not the whole service.

A run shows **Failed** status when:

* The test infrastructure lost connectivity during execution.
* The load test process exited with an error.

A run that a user ended early, or that an abort-on-fail threshold stopped, reports **Stopped** rather than **Failed**, and keeps whatever metrics it had gathered up to that point. A run that completes with a breached threshold reports **Finished**. Read the **Thresholds** table to see which criteria passed.

{% hint style="info" %}
**STATUS REFLECTS EXECUTION HEALTH, NOT APPLICATION HEALTH**

A high error rate does not by itself mark the run as **Failed**. A test that completes with a 100% error rate still shows as a completed run. Read the **Error Rate** or **Failed Rate** metric to assess how the application behaved, and use **Status** to confirm the test itself ran to completion.
{% endhint %}

***

## Worker utilization <a href="#worker-utilization" id="worker-utilization"></a>

A load test can only report the performance of the target if the pods that generate the load have enough CPU and memory. A load pod that runs out of CPU sends requests late and measures its own delay as response time, so the run looks slower than the target really is.

For a run on Kubernetes infrastructure, select **Workers** on the right edge of the run page to see the resource use of each load pod while the run is in progress.

![The Workers drawer for a running k6 test, with one k6-runner pod in the running state driving 5 users at 22m CPU and 15 MiB memory](https://3217710372-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRmV5EkLS9r45VPaoUnJZ%2Fuploads%2Fgit-blob-c29a315bbd36b37ec71e03b599b2e7dc4d865f75%2Fload-test-run-workers.png?alt=media)

The drawer lists the pods that generate the load:

* **JavaScript (k6):** Each runner pod.
* **Python (Locust):** Each worker pod in a distributed run, or the master pod in a standalone run.
* **Java (JMeter):** Each injector pod in a distributed run, or the master pod in a standalone run.

Each row reports one pod:

| Column           | What it shows                                                                                                                                                                                                |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Worker**       | The pod name. **Usage unavailable** under the name means that Harness could not read the usage of the pod, for example because it has not started.                                                           |
| **State**        | The Kubernetes phase of the pod, such as `running` or `pending`. When the phase alone does not explain the state, the Kubernetes reason appears below it, such as `ContainerCreating` or `ImagePullBackOff`. |
| **Users**        | The virtual users that this pod is driving, as reported by the engine. A dash means that the engine did not report a count for the pod.                                                                      |
| **CPU Usage**    | The CPU the pod is using, in millicores, such as `850m` for 0.85 of a core. The first reading of a new pod shows a dash, because CPU use is measured between two readings.                                   |
| **Memory Usage** | The working-set memory of the pod, the same figure that `kubectl top` reports.                                                                                                                               |

When the pod has a CPU or memory limit, the cell also shows the limit, such as `of 1000m limit`, and a bar for the share of the limit that is in use. The bar turns red at 90% of the limit or more. A pod with no limit shows no bar.

Harness reads the usage about every 5 seconds, and the drawer shows the latest reading for each pod. It does not keep a history.

### Read worker utilization <a href="#read-worker-utilization" id="read-worker-utilization"></a>

* **A CPU bar in the red:** The pod is close to being throttled, so its response times include its own delay. Raise the CPU limit, or spread the users across more workers, and run the test again before you draw conclusions about the target.
* **A memory bar in the red:** The pod is at risk of being stopped by Kubernetes for using too much memory. Raise the memory limit, or lower the users per pod.
* **Pods stuck in `pending`:** The run cannot start until the pods are scheduled. Read the reason under the state. `ContainerCreating` is routine while the image is pulled, but `ImagePullBackOff` means the image cannot be pulled and the run will not start until that is fixed.
* **Users that do not add up to the run total:** For Java (JMeter), Harness divides the threads of each thread group between the injectors and rounds up, so the counts can add up to slightly more than the total. When Harness cannot divide the thread counts of the plan and you set the number of workers yourself, every injector runs the whole plan and reports the full count. The run then shows the warning `E2015: JMETER_LOAD_NOT_SPLIT`.

To set CPU and memory requests and limits on the load pods, turn on **Resource Requirements** in **Advanced Options** of the **Load Test Studio**. Go to [Tune pods with advanced options](https://developer.harness.io/resilience-testing/load-testing/create-a-load-test/k6.md#tune-pods-with-advanced-options) for the options.

The load pods are removed when the run ends, so the drawer of a finished run shows `No workers are running for this test`. Runs on Linux infrastructure have no load pods, so their run page has no **Workers** button.

***

## Troubleshooting <a href="#troubleshooting" id="troubleshooting"></a>

<details>

<summary>Success Rate reads Not Available for a run</summary>

The run produced no metrics, which usually indicates that it failed or was stopped before it generated load. Open the run and read its logs rather than the summary columns. Go to [Run Actions](https://developer.harness.io/resilience-testing/load-testing/analyze-results/run-actions.md#read-the-logs) to open the logs for a run.

</details>

<details>

<summary>A run displays Finished status even though a threshold was breached</summary>

A breached threshold does not mark the run as **Failed**. The run ends with **Finished** status and the code `E3006: THRESHOLD_CROSSED`, and the **Thresholds** table marks the breach. To stop the run at the breach instead, enable **Abort on Fail** for the threshold, and the run ends with **Stopped** status and the code `E3005: THRESHOLD_ABORT`.

</details>

<details>

<summary>Response times look high but the target appears healthy</summary>

A load pod that runs out of CPU sends requests late and measures its own delay as response time. Select **Workers** on the run page and check for a CPU bar in the red. Raise the CPU limit through **Resource Requirements**, or spread the users across more workers, and run the test again.

</details>

***

## Next steps <a href="#next-steps" id="next-steps"></a>

* Go to [AI Insights](https://developer.harness.io/resilience-testing/load-testing/analyze-results/ai-insights.md) to read the generated analysis of a run.
* Go to [Get started with load testing](https://developer.harness.io/resilience-testing/load-testing/get-started.md) to create and run your first load test.
* Go to [JavaScript](https://developer.harness.io/resilience-testing/load-testing/create-a-load-test/k6.md#gate-a-release-with-passfail-thresholds) to declare thresholds that gate a release on performance.
* Go to [Composite load tests](https://developer.harness.io/resilience-testing/load-testing/composite-load-tests.md) to pair a run with a probe that reports whether the service stayed healthy under load.
* Go to [Load testing key concepts](https://developer.harness.io/resilience-testing/load-testing/key-concepts.md) to review virtual users, load profiles, and thresholds.
* Go to [Notifications and Reports](https://developer.harness.io/resilience-testing/load-testing/notifications-and-reports.md) to get notified about runs and to download a run report.

{% @harness-feedback/feedback %}
