You can run JMeter and Gatling performance tests on HyperExecute either through the Projects dashboard or, for repeatable terminal and pipeline runs, with the HyperExecute CLI and a YAML configuration. The portal route avoids writing YAML; the CLI route gives teams a configuration they can invoke as part of their delivery workflow. In either case, check how users are distributed across machines and regions before interpreting the load: a test plan’s thread count may be replicated rather than treated as the total.
Choose the portal or CLI route
| Route | Best fit | What you do |
|---|---|---|
| HyperExecute Projects dashboard | A guided run without YAML, especially for a one-off test or initial setup. | Create a project, upload the test files, choose the test and configure its load in the portal. |
| CLI with YAML | Repeatable runs started from a terminal or pipeline. | Prepare a project and configuration, set credentials, then invoke the HyperExecute CLI with that configuration. |
The documented portal workflows cover JMeter and Gatling. HyperExecute documentation also lists k6 in its performance-testing category and provides a CLI/YAML guide for k6; that does not establish an equivalent portal upload workflow for every framework.
Before you start
- For JMeter, have a usable
.jmxtest plan and any supporting data files. - For Gatling, have the simulation project and its required files in the format described by the current HyperExecute Gatling guide.
- For a CLI run, install the appropriate HyperExecute CLI binary, have account credentials, and keep the YAML schema and CLI version aligned with the current documentation.
- Decide what the test is meant to answer, where to generate load, and whether the configured user count is per generator or aggregate.
Do not put real access keys in source-controlled YAML or example commands. Supply credentials through environment variables using the variable names required by the current vendor guide.
Run a JMeter test in the portal
- Prepare and save the JMeter test plan as a
.jmxfile. Confirm that the plan’s thread groups, timers, assertions, and data inputs represent the workload you intend to test. - Open HyperExecute’s Projects dashboard and create a project for the test.
- Upload the JMeter plan and any required supporting files, then select the plan in the project.
- Set the load controls: users, test duration, ramp-up, load distribution, and machine count. If the test reads a CSV data file, configure CSV splitting where appropriate.
- Check the region configuration explicitly. The vendor guide describes East US as a default region, but defaults and available regions can change.
- Review the resulting aggregate load across machines and regions, then choose Run Test.
- After completion, inspect the job status, logs, reports or artifacts, and JMeter’s emitted performance results before drawing conclusions.
Understand the load controls
- Users: In JMeter, thread count usually represents virtual users in the plan. Verify whether HyperExecute applies that count to each machine or distributes a total across machines.
- Duration and ramp-up: Duration determines how long the workload runs; ramp-up controls how quickly users are introduced. A sharp ramp and a gradual ramp answer different questions.
- Machines and regions: These define where and how many load generators run. More generators can increase aggregate load, but they do not automatically mean the configured user count is a global total.
- Load distribution: Use explicit distribution overrides when you need a particular aggregate total, and verify the effective distribution in the job configuration or logs.
- CSV splitting: If multiple generators consume test data, configure splitting so workers receive the intended data rather than inadvertently reusing rows or exhausting their inputs.
Why aggregate users can surprise you
The TestMu AI guide gives an example in which a 250-user JMeter plan, run on three machines across two regions without load-distribution overrides, can result in 1,500 concurrent users: 250 × 3 × 2. Treat this as the guide’s configuration example, not a universal rule for every plan or current setup. Verify the platform’s actual distribution for your job.
Recommended Free Tools
The same 2026 vendor guide describes 2,000 users as a ceiling under favorable conditions, not a guaranteed capacity or independent benchmark. It says outcomes depend on factors such as lightweight requests, suitable timeouts, and sufficient machines and regions. Size and validate a run for your own workload rather than treating that figure as a promise.
Run a Gatling test in the portal
- Create a new project in the HyperExecute Projects dashboard and select Gatling as the test framework.
- Upload the simulation files in the structure required by the current vendor guide.
- Select the simulation and choose the test type that matches the question you need to answer.
- Configure the workload, duration, arrival rate or user count as applicable, and the machine and region distribution.
- Review the configuration and launch the run.
- Use the job status and logs to confirm execution, then inspect the generated report and any uploaded artifacts.
Choose the Gatling mode by test question
| Mode | Workload shape described in the guide | Question it helps answer |
|---|---|---|
| Capacity | Set a duration and initial and final user-arrival rates. | At what point does the system reach its scaling limit under an increasing arrival rate? |
| Stress | Set a duration and total injected users. | How does the system behave under peak load, including failure and recovery? |
| Soak | Set a duration and a constant arrival rate. | Does sustained load expose memory leaks or gradual performance degradation? |
These are workload distinctions, not substitutes for defining a realistic scenario. Use the current Gatling guide and portal labels to confirm the exact controls available to your account and configuration.
Run a repeatable CLI/YAML job
The CLI route is appropriate when the test should be started from a terminal or pipeline rather than manually configured for each run. The precise flags and YAML schema are version-sensitive; use the current HyperExecute Gatling guide as the authority for the installed CLI and account.
- Prepare the project. Make sure the Gatling project, simulation, dependencies, and any test data are available to the job in the layout expected by the current guide.
- Check the CLI and configuration version. Install the appropriate HyperExecute binary and confirm that its supported YAML schema matches the configuration you plan to use.
- Set credentials securely. Export the account credentials as environment variables using the names specified in the vendor documentation. Keep secret values out of the YAML file and logs.
- Set up the YAML runner. Use the current guide’s runner configuration for the project. Its example includes Maven dependency resolution,
mvn gatling:test, and uploading report artifacts; those are example configuration elements, not a universal YAML file for every Gatling project. - Invoke the CLI with the configuration. Use the command and options documented for your CLI version to submit the YAML job. Do not copy flags from an older guide without checking compatibility.
- Check execution and outputs. Follow the job status and logs in HyperExecute, then locate the reports and artifacts uploaded by the job.
The vendor guide describes JMeter project workflows as a CI/CD orchestration feature in a December 2025 release note. Availability and exact setup can change, so verify the current product documentation before relying on that feature in a pipeline.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteRead results without confusing load and performance
- Confirm the job actually ran. Check its final status and logs for setup errors, failed loads, or incomplete execution.
- Check effective load. Compare configured users, duration, ramp-up or arrival rate with the distribution across machines and regions. Do not infer aggregate concurrency from a plan’s thread count alone.
- Open framework output. Review the JMeter or Gatling report and any artifacts uploaded by the job. HyperExecute’s Gatling guide documents report artifact upload and access through the HyperExecute logs UI.
- Interpret the measured system, not just the generator. Relate response times, errors, throughput, and changes over time to the scenario and target system. A generator or network bottleneck can limit what the test says about the application.
Troubleshooting common problems
The portal cannot run the uploaded test
Check that you selected the intended project and test file, and that supporting files are included in the expected structure. For Gatling, compare the upload layout with the current vendor guide. For JMeter, confirm the plan’s referenced data and other resources are available to the run.
The observed user count is much higher or lower than expected
Check the load-distribution overrides and whether the plan’s user count is applied per machine, per region, or as an aggregate. Recalculate the configured machines and regions, then verify the effective setup in the job details or logs before rerunning.
A CSV-driven test repeats data or runs out of rows
Review the CSV splitting and consumption behavior for the number of workers. Ensure the file has enough suitable data for the run and that distribution does not cause generators to reuse the same rows unintentionally.
A CLI job rejects its YAML or fails before the test starts
Confirm that the installed CLI version supports the YAML schema and fields in the file, that required credentials are present as environment variables, and that the runner setup matches the current guide. Avoid mixing commands or schema examples from different versions.
The job completes but no report is available
Check the runner’s artifact-upload configuration and the job logs for the report’s actual output path. The Gatling guide’s example includes report artifact upload; a report that was generated locally by the runner may not appear in the UI unless it is uploaded.
Rank #4
The run stalls or produces unexpectedly weak load
Inspect logs for setup delays, dependency resolution, timeouts, or resource constraints. The vendor’s favorable-condition guidance for high user counts calls out lightweight requests, suitable timeouts, and enough machines and regions; it is not a promise that a given configuration will reach a target load.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Performance, reliability, and cost considerations
For repeatable comparisons, keep the scenario, test data, duration, ramp, region and distribution settings controlled between runs. Record the CLI/configuration version for pipeline jobs and retain the relevant logs and reports. Start with a load appropriate to the environment, then increase it deliberately; a larger configured user count is not useful if the test is bottlenecked by its generators or if distribution is misunderstood.
The available vendor guidance establishes configuration examples and conditional capacity guidance, but does not establish a universal cost per test or a general performance guarantee. Check current HyperExecute plan and usage terms for the account and region you intend to use.
Best Value
Or skip the browser setup
ScreenshotNeo is a separate website screenshot API and MCP server; it does not run JMeter or Gatling performance tests. If you also need clean website captures for documentation or an AI-agent workflow, one GET request can return an image or PDF. The parameter names used by other screenshot APIs also work, which can make switching easier. See the ScreenshotNeo API documentation.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp
ScreenshotNeo accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each of those steps can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies page verdict and billing status in headers. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for AI agents. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.
Sign up for ScreenshotNeo’s free plan: 1,000 screenshots a month, no card required.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Frequently Asked Questions
Do I need to write YAML to run JMeter or Gatling on HyperExecute?
No. The documented portal workflows let you upload and configure JMeter and Gatling tests in the Projects dashboard. YAML is for the CLI route, such as terminal or pipeline execution.
Does HyperExecute offer the same portal workflow for k6?
The documentation lists k6 in its performance-testing category and has a CLI/YAML guide for k6, but the documented portal upload workflows in this guide cover JMeter and Gatling.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
