Tricentis NeoLoad Reviews

Tricentis NeoLoad was for a sports client of ours, and they had a web based application, and that application had a lot of APIs floating into a lot of sports applications. They were sports-based solutions, where you have people going to baseball sporting events, registering for the events, getting tickets, etc. That was the load that we tested with Tricentis NeoLoad.

The API side of Tricentis NeoLoad is good. The API support is much better with this solution, compared with the competition. Pricing for it is also more affordable than its competitor: Micro Focus LoadRunner.

There were some features that were lacking in Tricentis NeoLoad, e.g. those were more into Citrix and other complicated protocols, which were supported easily by a competitor: Micro Focus LoadRunner.

What we want to see in this solution is how it integrates with the entire suite of Tricentis Solutions. Tricentis has a very successful product in Tricentis Tosca, and that is a product that is more focused on test automation. They have test management solutions. They have different management. Performance management or performance engineering within one solution would be a big winner for Tricentis NeoLoad, so this is an area for improvement for this solution. Otherwise, it is a really good tool.

I still need to take a closer look at the integration of Tricentis NeoLoad. I want to see how it integrates with other Tricentis products, because Tricentis did not have a good performance testing tool until now. This is a recent acquisition, so we want to see how these results come together: test automation, performance testing, etc., so that's what I'm looking for.

Tricentis NeoLoad is absolutely stable.

We have used Tricentis NeoLoad and we find it scalable.

Tricentis acquired this product a year ago, so prior to that acquisition, the product was owned by an independent company, and their support was really good. We were supporting from India, and we had constant support from them. We never had any challenges with support for Tricentis NeoLoad.

We previously used Micro Focus LoadRunner, and switched to Tricentis NeoLoad because of the cost aspect, and we also found that Tricentis NeoLoad is also a good solution. It has very similar facilities like Micro Focus LoadRunner, but some of the features that are lacking there is more into Citrix and other complicated protocols, which Micro Focus LoadRunner easily supports. The API side of Tricentis NeoLoad was good, so we were able to do really good work with the solution. We bought it recently.

Compared to Micro Focus LoadRunner, the setup for Tricentis NeoLoad is easy.

Pricing is always cheaper with Tricentis NeoLoad versus the very expensive Micro Focus LoadRunner.

Pricing is really less compared to Micro Focus LoadRunner, but once this product goes under the Tricentis umbrella, we don't know how much are they charging for it now. I have not looked into the most recent pricing for Tricentis NeoLoad.

I have experience with performance testing tools, particularly Micro Focus LoadRunner, Apache JMeter, and Tricentis NeoLoad. We also did a POC with Tricentis Flood, but that is now gone. We also did some work with Microsoft, but they have started removing it. Even Microsoft provides a solution for performance testing: Visual Studio.

I'm rating Tricentis NeoLoad seven out of ten, while Micro Focus LoadRunner I'm rating a five out of ten. I'm not giving Tricentis NeoLoad a score of ten because I want to see more out of it in terms of integration, particularly how it integrates with other Tricentis products.

There is a customized version for BlazeMeter, but it's a solution that cannot be compared with either Micro Focus LoadRunner or Tricentis NeoLoad, because it is more of an open source solution, so you do not get support that's comparable with the support you get from paid solutions.

We use the solution for load and performance testing activities for web-based applications, Siebel CRM, and Oracle E-Business Suite.

The product has enhanced features that let us cut down the script development and maintenance time. We can quickly correlate the values and create the scripts. When there are changes to our application, the maintenance becomes easier. The dashboards are readily available after the executions. The dashboards give extensive statistics, which help with quick report preparation and analysis.

The product must improve the features that allow integration with CI/CD pipelines. The integration with self-service portals and tools must be improved.

I have been using the solution for more than two years.

The tool is stable. The initial versions had issues. With every new version, the product is improving and becoming more stable and robust. I rate the stability a seven to eight out of ten.

I rate the tool’s scalability a seven to seven and a half out of ten. More than 25 people are using the product in our organization.

We have been in contact with the support team. Since Neotys became Tricentis, the turnaround time for support queries has increased considerably. It takes longer to get a response, and it impacts delivery. I would have rated Neotys’ support an eight or eight and a half out of ten. However, in the current state, I rate support a six or six and a half out of ten.

Neutral

We were using tools like LoadRunner along with NeoLoad. However, NeoLoad provided a better balance between the cost and benefits.

The initial setup was quite easy. The deployment can be done quickly for a single set of servers or workstations. However, the time taken depends on how extensive the infrastructure is.

The tool is not cheap. However, the cost is a bit lower than other tools like LoadRunner.

I would recommend the solution to others. However, my recommendation would depend on other parameters like the extent of testing and investment that they may want to do. There is some investment associated with it. It may not be justified if they are just doing load testing as one of the activities. Considering the ease of use, technical setup, and level of support provided, I rate the solution a seven out of ten.

We are primarily testing APIs but also testing the UI in some cases. In my last job, I also developed a plugin to enable NeoLoad to measure the end-user experience. If you have a modern web application, you usually only exchange JSON files between the client and the server. On the client side, you will render the JSON information to an HTML side or a dynamic DOM structure.

NeoLoad is used for testing the response time, which is not the same as the time it takes for the user to see the page. When the JSON document arrives on the client side, the client has to render the information. If you are considering the user experience from the end user's perspective, you are not interested in how long it takes to get the JSON. You want to know how long it will take to get the JSON and see the information on the page.

NeoLoad can't do this because it does not render the data from the server. The browser engine uses considerable RAM, so we cannot simulate many users simultaneously. We enabled NeoLoad to control a typical test. For example, a QF Test like Robot Framework tests the web UI. It starts and renders the application to measure how long it takes to see some special information on the page. 

These response times are fed into NeoLoad through a data exchange API, enabling us to visualize the actual user experience inside NeoLoad. That's NeoLoad's primary advantage. It has incredible APIs to implement special additional features or plugins you need for special applications.

NeoLoad helped us to transition from load testing to continuous performance measurement. It is integrated into our CI/CD pipeline. We implemented performance testing like you would have unit or functional tests. Every day, we get information if something happens in our application that affects the performance in a negative way.

NeoLoad offers better reporting than most competing tools. It is effortless to analyze and measure the reported data. It's also simple to generate a report that most people can read and management can understand. NeoLoad helps you figure out the main issues inside the application. 

Some users may find NeoLoad too technical, while other users may prefer a scripting language instead of a UI with figures and forms they have to fill in.

I began using NeoLoad when Neotys still owned the product. In total, I have about 13 years of experience working with the solution. 

Setting up NeoLoad is straightforward.

We deployed NeoLoad in-house. I already had experience with the solution from my previous job, so we didn't need Tricentis to send a consultant to help us. However, it's helpful to take advantage of their consultants if you need them. Tricentis has a network of freelancers, so it's easy to find a consultant near you, and you can usually find somebody who speaks your mother tongue.

We are using it for performance testing.

It's improving our test lifecycle time. It's taking less time compared to the previous tool.

The Frameworks feature is valuable. NeoLoad Web and the API are also valuable. It provides API support.

The overall stability of the GUI should be improved. The GUI component is not stable enough. We have observed crashes several times. 

There should also be support for more protocols for desktop applications.

I have been using this solution since 2019. It has been four years. 

I'd rate it a four out of ten in terms of stability. The GUI isn't stable enough.

I'd rate it a seven out of ten in terms of scalability. 

Within our team, we have around 25 users. Their roles are testers, test leads, and test managers.

We aren't planning to increase its usage. The way we are using NeoLoad and other tools is pretty streamlined. We are using NeoLoad 90% as per our requirements, and we aren't planning to increase its usage.

I'd rate their support a four out of ten. The problem is that we have to raise a support ticket in the portal. They usually take a long time to reply. The first or second response from the team usually covers the basic tasks, which the team would have already done before reaching out to their support team. So, by the time we get a proper response from them, we might have moved away from that particular project or we might have found some alternative. That part is a bit bad.

Neutral

We were using Micro Focus LoadRunner. We switched because of the organization's requirements.

As compared to other tools, the initial setup is easy, but there is some complexity that comes with the Kubernetes-based setup of one of the components. So, it's a bit easier than others, but there are certain aspects that make it difficult. I'd rate it a six out of ten in terms of the ease of the setup.

Its deployment took a couple of weeks, which also included testing. 

It was deployed in-house. We deployed it ourselves based on the documentation.

For deployment, we only need one employee who has experience in cloud deployment. For maintenance also, one admin is enough. 

I'd rate it a seven out of ten in terms of pricing.

We evaluated open-source tools such as Scala and JMeter. We went for NeoLoad because of the collaboration feature, which isn't there in Scala and JMeter. Another reason was the enterprise support, which doesn't come with open-source tools.

It's definitely worth a try. Compared to LoadRunner and other tools, it gives more flexibility and is easier to maintain. 

Overall, I'd rate Tricentis NeoLoad a seven out of ten.

We use the solution for performance testing.

The solution is easy to learn and use.

They should improve the reporting feature of the solution. It is easier to comprehend the analysis on its on-premise setup but not on its on-cloud setup.

We have been using the solution for two years.

We faced issues with our on-cloud setup once or twice within the past year. Apart from that, the solution is relatively stable.

The solution's scalability depends on the number of users and what they use it for. We have five or six users in our company using the solution. It scales as much as we require on-cloud. The scalability on-premises depends on the number of hardware and licenses we have purchased.

The solution's setup was straightforward. It took five minutes to complete the process. 

The solution is quite expensive. But users can select the features they require and pay accordingly.

The buyers should make a purchase decision depending on the usage of their project protocols. They should use the solution if they have to deal with a load on-premises. It is quite a good product compared with other solutions. But working better for on-premises setup doesn't make it an exceptional product. If you're working with web API only, better products are available.

I rate the solution as a seven out of ten.

I am a senior performance engineer providing end-to-end performance testing. This involves gathering all non-functional requirements, creating a test plan, and creating a test strategy document. From there, we would start our benchmark and baseline testing based on the tool and protocol of the specific client in order to gather the scripting and the load testing. NeoLoad helps us identify bottlenecks and memory leaks which will help us increase the hardware capacity for the client and/or look at things on the software end including scalability, reliability, testing, and failure testing.

It offered us an easy to use, limited code option for end-to-end performance testing.

Each of the main components - design, runtime, and results - are unique in their own way.

The design offers four components: user part (which is where we would be creating and enhancing scripts while implementing things like pacing, think time, and error handling concepts), servers (which is where we have the service testing of API testing), population (which is where we can plug scripts, create multiple populations, and perform bandwidth testing), and monitors (which is a server-side where we can add credentials to a database or server via SSH details).

Runtime allows us to create scenarios, populations, low variation policies, load generators, and custom load profiles. Other functions include graphs, templates, check alerts, set alerts, check response time, etc.

The results tab provides us with the NeoLoad report which we can segregate.

We would like NeoLoad to be able to support more protocols.

Testing can also be a little tricky at times.

I have been using this tool for almost nine years.

This tool is easy to use. It requires little code implementation thanks to many predefined areas. I have not experienced any stability issues over the past nine years I have been using it.

I would rate the stability as five out of five. Right now we have about 500 users but in the past, we have had roughly 200k. They range from senior performance engineers to performance architects to performance test engineers.

Customer service is fantastic. I have been working with one customer service rep for the past nine years. 

Initial installation, registration, and setup were all straightforward and very easy, especially in comparison to other tools.

We were able to implement the tool with our in-house team.

We were able to set up per user basis licensing.

Newer additions such as NeoLoad SAP, Citrix, NeoLoad Web, etc. are excellent extensions with a broad range of new functions.

Organizations should be aware that there are limited videos available on the internet regarding NeoLoad so they should ensure that they receive proper training from the reseller/integrator upon purchase. 

We had three specific use cases we targeted Tricentis NeoLoad for. The first was for services, the second for terminal emulation mainframe applications, and the third was for the web.  We are looking for a more cost effective, efficient (low code) alternative to our current framework. 

Tricentis provides great documentation and collaboration.

The most useful aspect of Tricentis NeoLoad was the low/no code for the web.

Tricentis NeoLoad could improve the range of codeless scripting such as with terminal emulation apps. 

We did a trial of Tricentis NeoLoad for approximately three months.

Tricentis NeoLoad is a stable solution.

We did not have any problems with the scalability of Tricentis NeoLoad but did not fully push the product.  We have approximately six or seven people involved in the POC. This included senior engineers and test developers.

We do not plan to expand the use of this solution at this time because it does not meet all of our needs.  Would consider a second look in the future.

The technical support from Tricentis NeoLoad is very helpful.

We have used Micro Focus LoadRunner. However, it is expensive and there appears to be a declining number of users.  Tricentis NeoLoad is more affordable and would better enable our pipeline but has fewer features.  We are not in a hurry to change but will continue to review products of interest and will continue monitoring Tricentis product roadmap.

The initial setup of Tricentis NeoLoad was straightforward. We had the installation instructions and the packages, and it took us approximately four hours to complete.

We did the implementation in-house.

Tricentis NeoLoad price is a benefit of using this tool, it is less expensive than some of the other solutions.

I would encourage others to take a look at this solution. It is a good solution and they maintain the technical expertise needed for success.

I rate Tricentis NeoLoad an eight out of ten.

The two standout features for us are:

• Team Server Collaboration - as is the case with many MNCs like ours, teams/team members are spread geographically at various locations. The Team Server module is a boon for such teams as multiple users can work on the same project simultaneously and check-in the changes. It also helps manage and allocate virtual users (of shared license) for execution of multiple projects at same time.
• Results & Analysis - NeoLoad provides comprehensive results for any load test. The results can be drilled-down to minute levels (from scenario level all the way to individual request level) of any transaction which makes root cause analysis very effective. NeoLoad can also consolidate results from different sources and the results are graphical (one can build custom graphs for any transaction) and colourful for easier interpretation.

Other advantages are

1. GUI driven recording makes it easier to record and prepare test scenarios without need for extensive coding knowledge thereby enabling tool users to ramp up faster
2. Supports a ton of protocols plus additional plugins such as Jenkins, AppDynamics, etc.
3. Custom scripts and frameworks can be built
4. Recording and simulating mobile applications is simple yet realistic

NeoLoad is a robust and versatile tool. With plugins for CI tools like Jenkins, NeoLoad is configured to automatically trigger small load tests on modules each time there is a build update. This has enabled us to identify performance issues for our clients at a very early stage. It has undoubtedly an impact during larger scale enterprise performance tests when all the modules are integrated and tested as cost to fix performance issues increases with later stages of deployment.

We have raised a few support tickets for certain feature sets/improvement areas.
These include permanent fixes for a few stability issues discussed in the following question and implementation of more robust solutions for media streaming protocols, TCP/IP and websocket protocols.

Also, there are a few changes in the latest version, 5.2, which have brought in many improvements but have removed certain features. For example, v5.2 has done away with the 90th percentile reporting for response times, which was present in earlier versions. While this is a small deviation, it still is important for organizations using it.

The tool can hang and take a long time to open projects if the size is large and if many graphs and result templates are stored. Certain protocols although supported by NeoLoad need to have custom solutions built (e.g. web socket connections) while solutions for certain other protocols such as media streaming protocols like HDS, HLS, etc. are still in the nascent stage.

We have used NeoLoad since late 2009.

There is no specific maximum project size defined (actual NeoLoad project size). This size is dependent on number of user journeys in the project, number of scenarios defined, number of graph templates stored, and number of results stored and so on. The bigger the project, the slower it opens in the tool (as expected) but many times can be excruciatingly slow. The other drawback is that the graphs and results may not get saved correctly. With the latest versions of NeoLoad, this issue has been significantly fixed but it can still occur at an undesirable moment as the optimum size of a project can only be determined by trial-and-error. Our experience has taught us to keep multiple backups of same project under two categories for such exigencies – the first category would contain backup of the project with previous results and graphs while the second one would have only the project (VUs and scenarios) but with previous execution results and graph templates removed.

The other issue we faced was with respect to results generation. If we need to abort a performance test that is in progress, all one has to do is click the stop button. However, if the stop button is clicked twice inadvertently or clicked twice because it still showed “consolidating results” message for eons after the first click, the results ultimately generated would get corrupted. Either the results would not show for all virtual users executed or would not get generated at all. The last time we checked, Neotys did not have a concrete solution to this problem even after analysing the execution logs and troubleshooting it. Their “solution” was to check our stop policy for the scenarios executed (to make sure all virtual users reached their ‘end’ state to generate results) and also to check if any antivirus or firewall was impeding result generation (an antivirus or firewall can prevent NeoLoad from writing results to your folder). From our side, our stop policies were fine and there was no antivirus/firewall to block NeoLoad so the solutions were not that useful. As a workaround, we would click just once to abort an execution run and wait for the results to be generated even if it took a while.

The customer service and technical support is excellent if you are a paid customer. The turnaround time and SLA for a priority one - Urgent - issue/ticket is almost immediate. For less priority tickets it is quick (usually a couple of hours) and the representatives even help build a custom solution for your project if need be. However, if you are using the trial version, you would have to depend on NeoLoad forums for answers. On the flip side, Neotys documentation available on their side is detailed and exhaustive which should answer most questions when you are evaluating the product.

We have used a host of other solutions such as LoadRunner, JMeter, WebLOAD, SOASTA, etc. While the choice of the solution depends on various factors such as open source vs commercial tool, protocols used, number of virtual users etc. NeoLoad comes up trumps on most factors which were needed for our clients namely:

1. Cost
2. Ease of deployment and scalability to test for high user loads (in the range of 100,000s users for large enterprise tests)
3. Ability to monitor performance at various levels of architecture
4. Graphical representation of results
5. Detailed comparison can be seen in the sheet attached

Initial setup is a breeze. The installation is a complete package without having to switch between standalone modules for recording scenarios, execution and analysis which is not the case in say, LoadRunner or WebLOAD which has different modules for each (like VuGen, Controller & Analysis).

Neotys also offers their own cloud infrastructure to leverage upon for tests with larger user loads which can be configured to each project needs. However, if you are setting up your own cloud infrastructure on say, Amazon AWS, you would have to be equipped with enough knowledge to set up the images (AMIs) and configure the necessary IPs & locations for the test.

When we started out in 2009-2010, we did use the vendor team to guide us through and setup the necessary infrastructure. Over the years, we have built a strong in-house team and have setup our own infrastructure and cloud instances.

Depending on the technical expertise of your team, you can choose to implement in-house or avail the support of the vendor team. While the basic installation is straightforward, the vendor team could help you choose the right hardware systems/configuration for localized load generation or help you configure Neotys cloud for IP simulation or handling larger user loads.

Neotys offers various licensing plans to suit every business. The free version comes with 50 users with all protocols included for small load tests. The paid licensing plan depends on number of virtual users needed (to simulate the load), duration, the protocols under test, number of concurrent applications being tested, cloud usage etc. For example, the licence can be availed even for a day, a month, or a year depending on the need. In that sense, the licence cost can range from $1500 to >$20000. A general rule of thumb is the longer the licence period and the greater number of virtual users results in a lower price over the long term.

Leverage the free version of performance tools to its maximum capability to evaluate and cross check against the performance testing needs for your business to make an informed decision on buying the tool. The pros outweigh the cons and so NeoLoad is highly recommended over its competitors.