Setup Load Test

What is Load Testing?

Load testing is a critical discipline in performance engineering that involves simulating realistic user traffic and conditions to evaluate how an application behaves under stress. Its primary goal is to determine the system's capacity, identify performance bottlenecks, and ensure the application remains stable and responsive as user demand increases.

Significance of Load Testing:

1. Capacity Planning: Determine the maximum number of users your system can handle before performance degrades.

2. Bottleneck Identification: Pinpoint specific components (database queries, API endpoints, server resources) that slow down under load.

3. Scalability Validation: Confirm that your infrastructure scales effectively to meet peak demand.

4. Risk Mitigation: Proactively fix performance issues before they lead to production outages or poor user experience.

PerfAgents streamlines this process by enabling you to leverage industry-standard JMeter load tests while seamlessly scaling load generation across distributed cloud infrastructure.

Create Your First Load Test

After selecting a project, you can configure and execute your first load test. Navigate to Create Load Test from the Left Navigation. The load test creation process is structured into three main configuration sections:

Section 1: Test Configuration

This section defines the identity and script for your load test.

Field	Description	Example
Test Name (Required)	A descriptive name for the test.	Homepage Load Test – Q1
Description (Optional)	Explain the purpose of this test.	“Simulate 500 concurrent users during peak sale.”
Tags (Optional)	Add tags separated by spaces or commas for filtering.	homepage, q1, critical

Upload JMX File

• PerfAgents uses JMeter (`.jmx`) files for load test execution.

• Drag and drop your `.jmx` file or click browse.

• Once uploaded, the file appears under “Uploaded JMX File”.

Supporting Files (Optional)

Upload any necessary files for your test, such as CSV data files, configuration files, or other resources.

Test Variables

Define key-value pairs to override variables in the JMX file, enabling execution for different configurations without modifying the script.

Name	Value
base_url	https://staging.example.com

JVM Arguments (Optional)

Specify custom JVM configuration settings (e.g., '-Xms6g -Xmx8g') for test execution, useful for high-load scenarios requiring memory tuning.

Section 2: Load Configuration

The Load Configuration section dynamically renders thread group controls based on the uploaded JMX file. Upon uploading a JMeter script, PerfAgents automatically detects the thread groups and generates customized configuration panels based on their specific types. For multi-thread JMeter scripts PerfAgents parses all thread groups within the file and displays dedicated configuration panels for each one. This ensures complete transparency and granular control over every execution unit within your test plan.

Thread Group–Wise Configuration Rendering

When a JMX file is uploaded:

• PerfAgents detects all thread groups defined in the test plan.

• Each thread group is displayed as an independent configuration block.

• Configurations are auto-mapped based on the type of thread group.

• Users can view/modify load parameters without editing the original JMX file.

Each thread group is clearly segmented and labeled for visibility and control.

Supported Thread Group Types

PerfAgents supports multiple JMeter thread group types and renders configuration options specific to each type.

Standard Test Plan Thread Group

The Standard Test Plan Thread Group represents the traditional JMeter thread group model. It is designed for straightforward, time-based load execution where traffic follows a predictable ramp-up, steady-state duration, and optional loop behavior. This configuration is best suited for simple and controlled load testing scenarios where complex traffic staging is not required.

Configurable Parameters

1. Virtual Users: Defines the total number of concurrent threads (virtual users) that will execute the test plan. This represents the peak concurrency level during the test execution. Users are introduced progressively based on the ramp-up configuration.

2. Duration: Specifies how long the thread group will remain active once execution begins. This allows you to define a time-bound test window (e.g., 2 minutes, 15 minutes, 30 minutes, etc.), ensuring predictable execution control.

3. Ramp-Up Time: Determines how long it takes to reach the configured number of virtual users. Instead of starting all threads instantly, users are distributed evenly across the ramp-up period. For example:

   1. 100 users with a 100-second ramp-up → 1 user starts per second.

   This helps prevent artificial traffic spikes and simulates gradual traffic growth.

4. Start-Up Delay: Defines a delay before the thread group begins execution. This is useful when:

   1. Coordinating with other thread groups

   2. Sequencing traffic

   3. Allowing setup tasks to complete before load injection begins

5. Loop Count (Including Infinite Option): Specifies how many times each virtual user executes the test script during the active duration. Options include:

   1. Fixed loop count (e.g., run 5 times)

   2. Infinite loop (executes continuously until duration ends)

   The infinite option is typically used for time-based tests where sustained load is required without limiting iteration count.

Visualization Support

PerfAgents enhances the standard thread group configuration with real-time validation and visualization:

1. Live Thread Curve Preview: A dynamic graph displays how virtual users will increase over time based on the configured ramp-up and duration. This allows you to:

   1. Validate concurrency growth

   2. Identify unintended spikes

   3. Confirm steady-state behavior

2. Peak Users Display: Automatically calculates and displays the maximum number of concurrent users defined in the configuration. This helps verify infrastructure capacity planning before execution.

3. Total Duration Summary: Displays the total calculated test runtime including ramp-up and steady-state periods. This ensures clarity around actual execution time before the test is launched.

Ultimate Thread Group (UTG)

The Ultimate Thread Group (UTG) is designed for advanced traffic modeling and complex load simulation scenarios. Unlike standard thread groups that follow a simple ramp-up and duration model, UTG allows you to define multiple staged schedules within a single thread group. This makes it ideal for replicating real-world production traffic patterns where user load fluctuates over time.

Configurable Parameters

Each row in the UTG schedule represents a separate execution stage. You can define multiple rows to simulate phased traffic behavior.

1. Start Threads Count: Defines the number of virtual users that will begin execution during that specific stage. This allows you to incrementally increase or decrease the active user count across different time windows.

2. Initial Delay (sec): Specifies how long the thread group should wait before initiating that particular stage. This helps in:

   • Delaying load injection

   • Sequencing traffic waves

   • Staggering execution across multiple schedules

3. Startup Time (sec): Determines how long it takes for the defined threads to ramp up to their full count. Instead of launching all threads instantly, they are gradually introduced over the configured duration. This prevents sudden load spikes unless intentionally configured.

4. Hold Load For (sec): Defines how long the threads remain active at peak concurrency during that stage. This parameter is used to simulate steady-state traffic where user activity remains constant for a defined period.

5. Shutdown Time: Controls how long it takes for the active threads to ramp down and terminate. Similar to ramp-up, threads do not stop abruptly unless configured to do so. This allows smoother load drop-offs.

Visualization Support

PerfAgents provides visual validation of your UTG configuration:

1. Thread Schedule Table: Displays each configured stage with its respective timing and concurrency values.

2. Thread Count Over Time Graph: Generates a real-time visualization of expected active threads based on your UTG schedule. This helps you:

   • Validate ramp patterns before execution

   • Identify potential unintended spikes

   • Confirm peak concurrency behavior

3. Peak Thread Indication: Automatically highlights the maximum concurrent thread count derived from the defined schedules. This ensures infrastructure sizing aligns with your expected peak load.

SetUp Thread Group

The SetUp Thread Group is executed before the main load test begins. It is designed to prepare the system and environment so that the actual load phase runs under realistic and controlled conditions. Unlike the primary load thread groups, the SetUp Thread Group does not represent production traffic. Instead, it ensures that prerequisites are completed prior to load injection.

Configurable Parameters

1. Virtual Users: Defines how many threads will execute the setup logic. Typically, this number is smaller than the main load group unless large-scale preparation is required.

2. Duration: Specifies how long the setup logic should run. This ensures the preparation phase completes within a defined time window.

3. Ramp-Up Time: Controls how gradually setup threads are introduced. This can be useful when:

   1. Initializing large datasets

   2. Avoiding sudden backend spikes during setup

4. Start-Up Delay: Defines the amount of time the thread group waits before it begins execution. In simple terms, it introduces a controlled pause between the test launch and when this specific thread group starts running.

5. Loop Count (Including Infinite Option): Defines how many times each setup thread executes its assigned flow. This can be:

   1. Fixed (e.g., create 100 users)

   2. Infinite (until duration completes)

TearDown Thread Group

The TearDown Thread Group is executed after the main load test completes. It is designed to handle post-test cleanup and environment restoration tasks. Unlike the primary thread groups that generate load, the TearDown Thread Group ensures that the system is returned to a stable and controlled state once testing finishes.

Configurable Parameters

1. Virtual Users: Defines how many threads will execute cleanup tasks. Typically, this is lower than the main load unless large-scale cleanup is required.

2. Duration: Specifies how long the teardown logic will run. This ensures cleanup completes within a controlled time window.

3. Ramp-Up Time: Determines how gradually teardown threads are introduced. Useful when cleanup actions involve backend processing and should not cause abrupt load spikes.

4. Start-Up Delay: Defines how long the TearDown Thread Group waits before beginning execution after the main load test completes. This allows you to introduce a controlled pause between the end of the load phase and the start of cleanup operations.

5. Loop Count (Including Infinite Option): Specifies how many times each thread executes the teardown script. Can be:

   1. Fixed (e.g., delete 100 records)

   2. Infinite (runs until duration ends)

Section 3: Load Generator Configuration

This defines the cloud infrastructure used to execute the test.

Setting	Description	Example
AWS Region	Select the region where load will be generated.	`us-east-2 (Ohio)`
Instance Type	Select the machine type for execution. Higher load requires larger types.	`m5.xlarge (4 vCPUs, 16 GiB RAM)`
Number of Generator Nodes	Specify how many load generator machines to use. Default is 1.	`3`

Final Step: Create Load Test

After configuring all sections, click Create Load Test. The test will appear under “All Tests” section, ready for execution.

UI Automation in Load Testing

PerfAgents offers an advanced UI Automation feature that allows you to execute automated UI scripts alongside your load tests. This ensures that while your system is under stress, you can also validate the end-to-end user experience and UI responsiveness.

UI Script Upload

Once you have configured your basic load settings, you can navigate to the UI Automation tab to manage your automated scripts.

1. Upload UI Script Files:

   1. Drag and drop or browse your UI script files (supports .js and .ts formats).

   2. Maximum file size: 100 MB.

2. UI Script Type: Select the automation framework. Currently, PerfAgents provides robust support for Playwright.

3. Download Template: A convenient option to download a sample script template to ensure your automation follows the required structure.

Trigger Configuration

The trigger configuration defines how and when your UI scripts are executed during the load test.

Configuration	Description
Trigger Type	Define the basis for execution (e.g., Thread Count, Time Based).
Peak Thread Count	It defines the peak load threshold at which the first UI script execution is initiated when Trigger Type is Thread Count.
Trigger After	It specifies the elapsed time after which the first UI script execution is triggered when the Trigger Type is set to Time Based.
Iterations	Set how many times the UI script should repeat.
Intervals (seconds)	Define the delay between subsequent UI script executions.

Visual Execution Preview: The real-time graph on the right provides a visual representation of the Virtual Users (Threads) over the Elapsed Time, helping you correlate UI automation triggers with the overall load profile.

By integrating UI Automation, you can capture logs, and performance metrics from a real browser perspective while the backend is under heavy load.