When an application receives more traffic than usual, will it maintain acceptable response times? Can it handle multiple users performing important business activities simultaneously? What happens when demand exceeds the capacity of its infrastructure?
Performance testing helps answer these questions before they become production problems.
Tricentis NeoLoad is a performance testing tool used to simulate user activity, execute load tests, monitor application behavior, and analyze performance results.
In this NeoLoad tutorial, we will walk through the basic process of creating a project, recording a user path, configuring virtual users, running a load test, and reviewing the results.
NeoLoad is a performance testing solution from Tricentis that helps teams evaluate application behavior under simulated workloads.
It can be used to design and execute load-testing scenarios, analyze application response times, monitor supported infrastructure components, and investigate performance issues.
For example, an e-commerce company could use NeoLoad to simulate customers browsing products, searching for items, and completing checkout operations.
By testing these workflows under controlled load, the engineering team can investigate whether the application meets its performance expectations.
NeoLoad supports different testing technologies and workflows. This tutorial focuses on a basic web application test using recorded HTTP/HTTPS traffic.
An application may function correctly with one user but behave differently when hundreds or thousands of requests reach its services.
Performance problems can arise from inefficient database queries, insufficient resources, network delays, application bottlenecks, or limitations in external dependencies.
Performance testing helps teams evaluate:
Common types of performance testing include load testing, stress testing, spike testing, and endurance testing.
This tutorial focuses on load testing, which checks how an application performs under an expected workload.
Before beginning, make sure you have:
Important: Only run load tests on systems you own or have permission to test. The extra traffic can affect application performance and availability.
Use a test environment rather than a live application whenever possible.
Download NeoLoad from Tricentis through its official channels. Follow the installation instructions for your operating system and set up the required license.
Once the installation is complete:
The NeoLoad Controller is used to design tests, manage execution, and analyze results. Load Generators produce traffic that simulates virtual users.
Depending on the test environment, these components may run locally or on separate infrastructure.
A project organizes the user paths, scenarios, variables, and other configuration needed for performance testing.
To create a project:
For example, you might name the project CustomerPortal_LoadTest.
Use a meaningful name so that the purpose of the project is clear to other team members.
After creating the project, review its design workspace.
The core concepts you will use include:
User Paths: Represent sequences of application requests that simulate user behavior.
Populations: Group user paths and define how different virtual user behaviors are distributed.
Scenarios: Define the workload to execute, including user load, duration, and related settings.
Monitors: Collect supported infrastructure measurements when appropriate monitoring components are configured.
A user path represents a sequence of requests performed by a simulated user.
For example, a user path might include opening a website, navigating to a product page, searching for a product, and viewing the results.
NeoLoad can capture web traffic generated while you interact with an application.
To record a basic user path:
For example, you might record a workflow that:
NeoLoad captures the corresponding web requests for later replay.
Tip: Keep recordings focused on realistic business workflows. Avoid recording unrelated browsing activity that does not belong in the test.
Recording traffic is only the beginning. Before generating load, verify that the captured requests represent the intended workflow and can be replayed correctly.
A NeoLoad user path can contain three main containers:
Init: Activities that initialize a virtual user session, such as logging in when appropriate.
Actions: Business activities repeated during the virtual user session.
End: Cleanup actions, such as logging out when required.
Review the recorded requests and organize them into meaningful transactions.
For example, instead of evaluating every individual request in isolation, you might group related requests into transactions called:
This makes the results easier to interpret.
Handle Dynamic Values
Applications frequently generate values that change between sessions, such as session identifiers or anti-CSRF tokens.
If the recorded user path contains hard-coded values that expire or change, playback may fail.
NeoLoad supports extracting dynamic values from responses and reusing them in subsequent requests. This process is commonly known as correlation.
Use appropriate variables, parameterization, and correlation to make the user path work across repeated executions.
Add Realistic Think Times
Real users do not necessarily make every request immediately after the previous one.
Configure suitable delays to represent realistic interaction patterns.
However, the correct timing depends on the business workflow and the performance-testing objective.
Before running the load test, check that the recorded user path works as expected.
For example, if the application requires a session token that changes at every login, you may need to configure correlation before the recorded workflow can replay correctly.
A successful technical replay should also be reviewed for business correctness. An HTTP response can succeed while the application returns an unexpected page or error message.
A population groups the user paths you want to include in a test and defines how virtual users are distributed across them.
For an e-commerce test, you could include two user paths:
For example, assign 70% of virtual users to browsing and 30% to searching. Set the proportions based on how customers are expected to use the application.
To create a population:
Once the population is ready, define the workload the application will experience during the test.
A scenario specifies how virtual users are introduced and how long the test runs.
You can configure the scenario using these settings:
Example: Load Test with 100 Virtual Users
To test how the application handles 100 concurrent users:
The numbers are examples rather than universal recommendations.
A realistic load test should use workload assumptions that reflect the application’s expected traffic, user behavior, and business requirements.
Important: The number of virtual users does not directly represent requests per second or actual customer volume. Think times, transaction duration, request frequency and user behavior all influence generated load.
After configuring and validating the scenario, you can begin test execution.
In NeoLoad:
During the test, observe how application performance changes as the workload increases.
NeoLoad provides runtime information for metrics and execution errors. Additional infrastructure monitoring can help explain performance behavior when supported monitoring components are configured.
If serious errors or unexpected resource usage occur, follow the agreed test safety and stop procedures.
After the test finishes, open the Results section to evaluate the application’s behavior.
Do not judge the test only by whether it completed.
Response Time
Review how long important transactions take to complete.
Pay particular attention to response time distributions and higher percentiles rather than relying only on averages.
For example, the 95th-percentile response time helps describe the experience of slower transactions within the measured sample.
Throughput
Review how many requests or transactions were processed over time.
This can help determine whether the system maintained expected throughput as the number of users increased.
Error Rate
Investigate failed requests, timeouts, unsuccessful transactions, and validation errors.
An application may appear fast while returning errors, so response time and error rate should be evaluated together.
Resource Utilization
Where monitoring has been configured, review relevant CPU, memory, database and infrastructure measurements.
These metrics can help identify resource constraints that correspond with periods of poor application performance.
Compare Results with Objectives
Compare the measurements with requirements defined before the test.
For example, a team might require a critical transaction to meet an agreed 95th-percentile response-time threshold under a specified workload.
NeoLoad supports service-level criteria that can help evaluate whether test results meet defined performance expectations.
Consider a hypothetical checkout test with 100 virtual users.
The results show:
| Metric | Example Result |
| Virtual users | 100 |
| 95th-percentile checkout response time | 4.2 seconds |
| Checkout error rate | 3% |
| Application server CPU utilization | 92% |
These figures are illustrative, not results from an actual InApp test.
High CPU usage could point to a resource bottleneck, but it doesn’t necessarily explain why checkout responses are slow.
The team should check application logs, database activity, request patterns, and other relevant metrics to identify the cause.
The goal of performance testing is to understand what’s affecting performance and determine what needs to be improved.
Recorded Requests Fail During Replay
Check whether the application uses dynamic tokens, session identifiers, or other values that require correlation.
The Test Produces Unexpected Errors
Verify test accounts, environment availability, data state, authentication, and expected application responses.
Virtual Users Do Not Generate the Expected Load
Review think times, user path duration, request behavior, population configuration, and available Load Generator capacity.
Response Times Increase Under Load
Review application errors, infrastructure metrics, database performance, and external service dependencies.
Do not assume that increasing server capacity is always the correct solution.
Test Results Are Difficult to Interpret
Use meaningful transaction names, define test objectives before execution, and compare results against a baseline where available.
To get reliable results from NeoLoad, keep these practices in mind:
NeoLoad helps teams move beyond assumptions about application performance by simulating workloads and collecting measurable results.
A useful NeoLoad test starts with a realistic user path, includes proper validation and workload configuration, and ends with a careful review of response times, throughput, errors, and relevant infrastructure behavior.
The objective is not simply to run more virtual users. It is to understand how the application behaves under expected demand and identify what needs improvement.
Improve Application Performance with InApp
InApp provides software testing and quality engineering services to help organizations evaluate application reliability, improve release confidence, and address performance challenges.
Whether you need to assess an existing application, strengthen testing practices, or prepare a business-critical system for increased demand, our engineering teams can help identify the appropriate next steps.
Explore InApp’s Software Testing Services
NeoLoad is used for performance and load testing. It helps teams simulate user activity, execute workloads, and analyze application behavior under different conditions.
Yes. NeoLoad is a performance testing product from Tricentis that supports load testing and related performance engineering workflows.
A virtual user represents simulated behavior that follows a defined user path during performance test execution.
A user path defines the sequence of requests and activities performed by a virtual user. A scenario defines how the workload is executed, including user load, duration, and population configuration.
NeoLoad supports infrastructure monitoring through appropriate monitoring components and configurations. The available measurements depend on the monitored systems and the selected setup.
NeoLoad provides test results and monitoring information that help teams investigate performance problems. Root-cause analysis still requires technical interpretation and supporting evidence.
NeoLoad supports automation and integrations that can help teams incorporate performance testing into suitable software delivery workflows. The implementation depends on the organization’s infrastructure and tooling.
