Top 15 Free Software Testing Tools in 2025

Let's face it: in today's fast-paced tech world, software testing is no longer a luxury – it's an absolute necessity. With users expecting nothing short of perfection, even the tiniest bug can send your hard work crashing down faster than you can say "404 error."

But here's the good news: you don't need a Fortune 500 budget to test like the pros. The software testing world is brimming with powerful, feature-packed tools that won't cost you a dime. Yep, you heard that right – totally free!

In this blog, we're diving into the cream of the crop – the top 15 free software testing tools that are making waves in 2025. Whether you're a solo developer, part of a scrappy startup, or working in a large enterprise, these tools will help you catch those pesky bugs, streamline your workflows, and deliver top-notch software that'll make your users go "Wow!"

So, grab your favorite caffeinated beverage, get comfy, and let's embark on this exciting journey through the world of free software testing tools. Trust me, by the end of this post, you'll be itching to take these bad boys for a spin!

The Main Types of Software Testing Tools

Before you unleash your inner bug bounty hunter, let’s get our bearings. Software testing tools aren’t one-size-fits-all—they come in all shapes and sizes, each tailored to specific needs. Knowing what’s out there helps you build your own “Avengers” lineup for testing day.

Static vs. Dynamic: The Two Big Camps

At the highest level, software testing tools fall into two broad categories:

• Static Testing Tools: Think of these as your spellcheckers and code auditors. They inspect your code without actually running it. Perfect for spotting sneaky mistakes, identifying unused code, or reviewing data flow between modules—all while your app naps peacefully.

• Dynamic Testing Tools: These tools prefer getting their hands dirty. They run the application with real or simulated data, monitoring how it behaves in action. If something breaks, dynamic tools are usually first on the scene with the flashing red light.
  
  

Diving Deeper: The Testing Tool Lineup

Ready for a quick tour? Here are the primary types of software testing tools you'll find in every seasoned tester's toolbox:

• Test Management Tools: Organize your test cases, track progress, and keep the whole testing circus running on schedule.

• Automated Testing Tools: Automate repetitive or complex test cases, freeing you from the tedium and reducing the risk of “Oops, I missed that one.”

• Performance Testing Tools: Measure the speed, scalability, and stability of your app when users pile in—no one likes a slowpoke.

• Cross-Browser Testing Tools: Ensure your site looks sharp and works right, whether your users are browsing on Chrome, Firefox, Safari, or that guy who still swears by Internet Explorer.

• Integration Testing Tools: Check if different modules play nicely together—because solo acts aren’t enough when it comes to big apps.

• Unit Testing Tools: Focus on individual chunks of code to make sure each one does its job before joining the big leagues.

• Mobile Testing Tools: Test your app's mettle on various mobile devices and operating systems.

• GUI Testing Tools: Probe the look and feel of your application, making sure buttons actually button and sliders actually slide.

• Bug Tracking Tools: Capture, track, and manage every pesky issue from discovery to fix—because if it isn’t tracked, it isn’t getting fixed.

• Security Testing Tools: Put up security fences by detecting potential vulnerabilities and safeguarding your app from attacks.

Now that you know your options, let's roll up our sleeves and check out the heroes leading the free software testing revolution in 2025!

Static Testing Tools: Your Behind-the-Scenes Code Guardians

Before we dive headfirst into the all-star lineup of free testing tools, it’s worth shining a spotlight on a lesser-sung hero in the testing world: static testing tools. Think of these as eagle-eyed inspectors combing through your codebase without ever hitting the run button.

Static testing tools analyze your code’s structure and logic without executing it—meaning they can sniff out potential bugs, security holes, and logic hiccups before your app ever takes its first breath. Here’s a quick tour of the heavy hitters in this category:

• Code Flow Analyzers: These handy tools track how data travels through your program, flagging spots where the path gets murky or variables might be up to no good.

• Code Coverage Tools: Want to make sure you’re not leaving any stones unturned? Coverage analyzers help you verify that every nook and cranny of your code has been tested (no secret hideouts for bugs!).

• Control Flow Analyzers: They map out every possible route through your logic and highlight code that’s unreachable, inconsistent, or just plain suspicious.

• Interface Analyzers: Focusing on how your functions, methods, or modules communicate, these tools catch mismatches and data handshake blunders before they cause you grief down the line.

With these static testing MVPs on your virtual bench, you can tackle lurking issues early, streamline your testing process, and step into dynamic testing with confidence.

Security Testing Tools: Your Digital Bodyguards

Now, let's talk about the digital bouncers of the tech world—security testing tools. Think of them as the bodyguards for your code, standing at the entrance, making sure nothing shady sneaks in.

In essence, security testing tools are designed to sniff out vulnerabilities in your application before the bad guys do. They scan your software for weak spots like:

• SQL injection holes that could let attackers access your database,

• Cross-site scripting (XSS) flaws which might expose your users to all sorts of unwanted hijinks,

• Broken authentication methods that could allow unauthorized access,

• Outdated dependencies that hackers love to exploit,

• And a whole lot more.

With these tools in your arsenal, you’ll uncover security gaps early, patch them up, and confidently ship software that’s as safe as it is awesome.

Static vs. Dynamic Testing Tools: What's the Difference?

Before we jump into our list of heavy hitters, it's worth getting clear on the two main categories you'll run into in the testing world: static and dynamic testing tools. Think of it as the difference between proofreading your essay before handing it in (static) versus watching your teacher mark it in real-time (dynamic).

Static Testing Tools:
These tools swoop in before your code even gets a chance to run. Their mission? To sniff out bugs, code smells, and logic mishaps in your scripts without actually executing anything. It’s like having your sharpest, red-pen-wielding English teacher scrutinize every line, but for code. Static analyzers can spot dead code, potential vulnerabilities, or places where your modules aren’t playing nicely together—all before you push "Run."

• Identify issues early (before runtime)

• Hunt down unused or inconsistent logic

• Highlight vulnerabilities and enforce best practices

Dynamic Testing Tools:
On the flip side, dynamic testing tools come alive during execution. Here, your application is put through its paces with real data, letting you observe how things shake out when the rubber meets the road. This is where errors, crashes, and oh-so-fun edge cases reveal themselves. It’s hands-on, sometimes a little dramatic, but absolutely essential if you want to know how your code behaves in the wild.

• Test code while it’s running

• Uncover bugs triggered by real inputs

• Measure reliability, performance, and user flow

In short: static tools help you catch sneaky problems before they ever see the light of day, while dynamic tools help you wrestle bugs that only show up when things are actually in motion. Together, they’re the Batman and Robin of software quality—covering all your bases so you can launch with confidence.

Why Use Software Testing Tools?

Before we jump into the list, let's take a moment to appreciate why these tools are so essential:

• Automate repetitive tasks: Say goodbye to endless manual clicking. Let the robots do the grunt work so you can focus on what really matters.

• Ensure consistent test coverage: No more "oops, forgot to check that feature" moments. Automated tools make sure every corner of your app gets the attention it deserves.

• Simulate real user conditions: Whether you're testing a login page or a checkout flow, these tools help you mimic real-world usage scenarios, catching issues before your users do.

By catching problems early in the development cycle, you can:

• Reduce the cost of fixing bugs: It's way cheaper (and less stressful) to squash bugs before launch day.

• Enhance user satisfaction: Stable, reliable software keeps your users happy—and coming back for more.

• Ensure compliance with safety and regulatory standards: Especially important in industries like finance, healthcare, and e-commerce.

Top 15 Free Software Testing Tools

1. Qodex.ai

Description: Qodex.ai is an AI-powered software testing tool designed to automate test case generation, execution, and maintenance. It analyzes an application’s structure, user flows, and data interactions to automatically create comprehensive and adaptive test suites. Unlike traditional tools, it continuously learns from application changes and user behavior, reducing maintenance overhead. Best suited for teams looking to leverage AI for smarter, faster, and more scalable testing workflows.

Pros:

• Reduces manual testing effort significantly

• Automatically adapts to application changes

• Generates comprehensive test coverage

• Improves quality through continuous learning

Cons:

• Requires initial time investment for AI training

• May be excessive for simple applications

• Pricing for advanced features is unclear

Beyond these highlights, Qodex.ai brings the classic strengths you expect from top-tier testing tools: automating repetitive tasks, ensuring consistent test coverage, and simulating real user conditions. These advantages are game-changers for catching issues and bottlenecks before your software ever reaches production. By detecting problems early in the development cycle, you can reduce the cost and headache of fixing bugs, boost user satisfaction, and stay on top of safety or regulatory requirements—all without breaking a sweat.

But what really sets Qodex.ai apart is its ability to mimic real-world testing scenarios using dynamic data. For example, it can act as a test driver, providing fresh input data to your app’s modules, or as an emulator, simulating components that aren’t built yet—so your tests stay ahead of development. Qodex.ai even borrows a page from mutation analysis by introducing intentional errors to gauge your app’s fault tolerance, ensuring your software is as bug-resistant as possible.

2. Apache JMeter

Description: JMeter is a powerful, open-source tool primarily used for load testing and measuring performance. It can simulate heavy loads on servers, networks, or objects to test strength and analyze overall performance under different load types. JMeter supports various protocols including HTTP, JDBC, LDAP, and more.

But JMeter isn't just about brute force—it shines when you need to assess the stability, scalability, and speed of your applications under real-world traffic conditions. Whether you're stress-testing a web app before a big launch, benchmarking your API endpoints, or ensuring your database won't buckle at peak hours, JMeter steps up to the plate. Its flexibility means you can mimic thousands of concurrent users, replay complex user journeys, and dive deep into performance bottlenecks—think of it as your trusty Swiss Army knife for all things performance testing.

JMeter’s flexibility makes it a go-to for dynamic testing. You can use test beds to display your source code alongside running applications, or set up complex test scenarios that push your app to its limits—just like your most demanding users might. And if you ever want to get extra creative, JMeter integrates with tools that allow you to inject errors or simulate missing components (think emulators and mutation analyzers) so you can see how your application handles the unexpected.

Pros:

• Supports a wide variety of protocols

• Large, active community and documentation

• Highly extensible with plugins

• Suitable for both load and functional testing

Cons:

• Steep learning curve for new users

• Outdated GUI design

• Resource-heavy for very large simulations
  
  

3. Bugzilla

Description: Bugzilla is a web-based general-purpose bug tracker and testing tool that has been around since 1998. It's highly customizable and can be used for bug tracking, feature requests, and other issue tracking needs. Despite its age, Bugzilla remains popular due to its reliability and robust feature set.

If you're serious about keeping your bugs in check, Bugzilla isn't the only player in town—many teams also find bug tracking essentials in tools like Trello and GitHub Issues. These alternatives offer streamlined bug monitoring and logging, and can be particularly appealing for teams already invested in their platforms. However, Bugzilla stands out when you need deep customization, detailed workflow management, and powerful query options to slice and dice your bug data just the way you want.

Bugzilla also shines when it comes to dynamic testing processes. Picture using it as your central test bed—where running programs and code are visible together, and bugs can be tracked in real time as you introduce new data or even deliberate errors (mutation analysis, anyone?). It's like having a digital laboratory for your defects.

Pros:

• Highly customizable workflows

• Extremely reliable and time-tested

• Advanced querying and reporting features

• Free and open-source

Cons:

• Outdated interface

• Overly complex for smaller teams/projects

• Requires effort for setup and customization
  
  

4. Robot Framework

Description: Robot Framework is a Python-based open-source automation framework that supports acceptance testing and acceptance test-driven development (ATDD). It uses a keyword-driven approach, making test cases readable and maintainable for both technical and non-technical users. Its large ecosystem of libraries and plugins makes it flexible for UI, API, and database testing. Best for teams adopting acceptance testing or behavior-driven development methodologies.

With Robot Framework, you can build dynamic test flows that incorporate real-time data, emulate missing system parts, and even automate fault injection to verify your app’s resilience. Its extensibility means you can connect with other dynamic testing essentials—like emulators and mutation analyzers—without missing a beat.

Pros:

• Easy-to-read keyword-driven syntax

• Wide library support for multiple use cases

• Good for acceptance and ATDD testing

• Can integrate with multiple languages via remote interfaces

Cons:

• Slower execution on large test suites

• Requires Python knowledge for advanced customization

• Learning curve for creating custom libraries
  
  

5. SoapUI (Open-Source)

Description: SoapUI is one of the most popular functional API testing tools, primarily used for SOAP and REST APIs. The open-source version enables automation of functional, regression, and load tests, with a user-friendly drag-and-drop interface. It’s often favored by QA engineers working on enterprise-grade applications with complex API ecosystems.

SoapUI’s dynamic testing features let you send real-time data as input and see how your APIs handle not just happy paths, but all sorts of curveballs. You can even use it as a test driver or mutation analyzer, introducing unexpected data to ensure your APIs are ironclad.

Key Features:

• Supports testing for both SOAP and REST web services

• Load testing, security testing, and mock services

• Drag-and-drop interface for building complex test scenarios

• Data-driven testing (more advanced in the pro version)

Pros:

• Comprehensive SOAP and REST testing support

• User-friendly interface for test design

• Enables complex test scenarios

• Large user base with strong documentation

Cons:

• Limited reporting in the free version

• Can consume high system resources

• Advanced features only in the Pro version
  
  

6. Cypress

Description: Cypress is a modern, developer-friendly testing tool built specifically for JavaScript-based web applications. It offers a fast and reliable testing environment, with built-in handling of asynchronous operations and real-time debugging. Running directly inside the browser, it provides deep visibility into app behavior, making it a top choice for front-end developers and agile teams.

Cypress takes dynamic testing to the next level by running tests in real browsers, interacting with your apps using real-time data, and allowing you to observe code and results side-by-side—just like a live test bed. And its time-travel debugging? Like your own QA DeLorean.

Key Features:

• Supports Windows, Mac, and Linux

• Cross-browser testing capability

• Real-time reloading and debugging

• Built-in assertions and automatic waiting

• Time travel to visually debug test steps

Pros:

• Real-time reloading and debugging

• “Time travel” feature for easy test tracking

• Automatic waits for better reliability

• Excellent documentation and community support

Cons:

• Limited to JavaScript/TypeScript front-end testing

• No multi-tab or multi-domain support

• Not suitable for non-browser-based apps
  
  

7. Katalon (Free Version)

Description: Katalon is a multi-purpose automation platform that supports testing for web, API, mobile, and desktop applications. The free version allows teams to use both codeless (record-and-playback) and script-based approaches, making it suitable for testers of different skill levels. Its seamless integrations with CI/CD tools make it an accessible choice for teams practicing DevOps and continuous testing.

Katalon supports dynamic testing by letting you set up test drivers for inputting data, emulate unbuilt components, and analyze fault tolerance by simulating errors. It’s particularly handy for teams who want to experiment with real-world scenarios without ever leaving their test environment.

Katalon Studio at a Glance:

Katalon is a low-code solution, making it accessible to both beginners and advanced testers. It supports a variety of testing methodologies, including BDD and keyword-driven testing, and comes with built-in project templates and reusable keywords. Katalon also offers record-and-playback capabilities, enabling users to quickly generate tests without writing a single line of code, while still providing the flexibility for those who prefer scripting in Groovy.

Integration is a strong suit—Katalon works seamlessly with popular tools like JIRA, Jenkins, Azure DevOps, and Slack, fitting easily into most CI/CD pipelines. This makes it ideal for teams looking to automate web, mobile, desktop, and API testing in one unified platform.

Key Features:

• Record and playback for UI testing

• Scripting support with Groovy

• Project templates and keyword-driven testing

• Integrates with tools like JIRA, Jenkins, and Azure DevOps

• Supports web, mobile, API, and desktop applications

Pros:

• User-friendly interface suitable for beginners and experts

• Supports multiple testing types (web, mobile, API)

• Built-in project templates and keywords

• Integrates with popular tools like JIRA, Slack, and Jenkins

• Scriptless and script-based options for flexibility

Cons:

• Advanced features require paid upgrade

• Can be slow for very large test suites

• Limited reporting in free tier
  
  

8. TestPad

Description: TestPad is a lightweight manual and exploratory testing tool designed for simplicity and collaboration. Its spreadsheet-like interface allows teams to organize and execute test cases quickly, without the overhead of traditional test management systems. Great for agile teams looking to manage exploratory and checklist-style testing with minimal setup.

TestPad’s flexible interface is perfect for dynamic and exploratory testing. You can use it like a live test bed, updating test cases on the fly, or as a test driver, inputting new data with each run. For teams who love to tinker and adapt, this is a manual tester’s playground.

Key Features:

• Spreadsheet-like, intuitive interface

• Flexible organization of test cases

• Collaborative features for team-based testing

• Supports both scripted and exploratory testing

Pros:

• Intuitive spreadsheet-like interface

• Fast test case creation and execution

• Encourages collaboration among testers

• Flexible support for scripted and exploratory tests

Cons:

• No automation support

• Basic reporting capabilities

• May not scale well for larger enterprises
  
  

9. Postman (Free Version)

Description: Postman is a widely adopted API development and testing platform. It provides a complete environment for sending API requests, inspecting responses, and writing automated test scripts in JavaScript. Its collaborative features (in paid versions) make it a top choice for teams managing complex API ecosystems. Best for developers and testers who need quick, iterative API testing.

With Postman, you can drive APIs with real-time input data—making it a stellar test driver—and even set up scenarios that test your API’s limits and error-handling. You can also use collections as mini test beds to observe how your API behaves under various conditions.

Key Features:

• API request builder with support for different HTTP methods

• Automated testing using JavaScript-based assertions

• Collection runner for batch testing

• Extensive documentation and learning resources

• Integration with popular CI/CD tools

Pros:

• Beginner-friendly interface

• Supports scripting for automated validation

• Large resource base and tutorials

• Easy sharing of API collections

Cons:

• Limited team collaboration in free tier

• Can get cluttered with large numbers of requests

• Advanced features like mocking and monitoring require paid upgrade
  
  

10. Appium

Description: Appium is an open-source mobile automation framework used for testing native, hybrid, and mobile web apps across iOS and Android. It works with multiple programming languages and integrates with popular testing frameworks, making it highly flexible. A great option for QA teams focused on cross-platform mobile app testing.

Appium lets you build dynamic mobile test environments, acting as both test driver and emulator to simulate real device interactions and components yet to be developed. Mutation testing is also possible for those who want to push robustness to the limit.

Key Features:

• Cross-platform testing on iOS and Android

• Supports popular programming languages like Java, Python, C#, Ruby, and more

• Works on real devices, emulators, and simulators

• Integrates with various testing frameworks and CI/CD tools

• No need to modify the app for testing

• Free and open-source, with a large and active community

Pros:

• Supports iOS, Android, and hybrid apps

• Works with multiple programming languages

• No need to recompile or modify apps

• Large and active community

Cons:

• Setup can be complex for beginners

• Slower execution than platform-specific tools

• Requires separate configurations for iOS and Android

Other Mobile Testing Considerations:
When evaluating mobile testing solutions, it's important not only to consider Appium but also the broader landscape of mobile testing tools. For teams looking to automate testing on Android specifically, tools like Robotium offer a straightforward way to create robust tests for native and hybrid apps. Additionally, crowd-sourced platforms such as Test IO provide on-demand manual testing across a wide variety of real devices and operating systems—helpful for catching issues that automated scripts may miss.

Whether you're writing automation scripts or seeking broader device compatibility through manual testing services, combining these tools can help ensure your mobile apps deliver a consistent, high-quality user experience.

11. Watir

Description: Watir (Web Application Testing in Ruby) is an open-source Ruby library for automating web browsers. It allows you to write expressive and easy-to-maintain tests for web applications using Ruby, a language known for its readability.

Watir shines in dynamic environments—think data-driven testing with real-time updates, or using test drivers to input new data during each run. If you’re the type who wants their test suite to adapt as quickly as their codebase, Watir’s for you.

One of Watir's standout features is its cross-browser testing capability—ensuring your web application functions smoothly across various browsers like Chrome, Firefox, Safari, and Edge. This makes Watir a reliable choice for teams aiming to deliver a consistent user experience regardless of browser preference. Much like Selenium, Watir empowers testers to validate their application in real-world scenarios, catching those pesky browser-specific bugs before your users do.

Key Features:

• Clean and readable Ruby-based syntax

• Cross-browser testing capabilities

• Integrates with other Ruby testing tools

• Supports data-driven testing

Pros:

• Clean and expressive Ruby syntax

• Cross-browser support

• Easy to integrate with Ruby testing frameworks

• Supports data-driven testing

Cons:

• Ruby-only (limits adoption outside Ruby teams)

• Smaller community compared to Selenium

• Can be slower for large-scale tests
  
  

12. TestNG

Description: TestNG is a Java-based testing framework inspired by JUnit and NUnit. It supports a wide range of testing types, including unit, functional, end-to-end, and integration testing. Known for its flexibility and parallel execution, it is popular in enterprise projects that require scalable, data-driven testing.

TestNG is perfect for dynamic testing: it supports data-driven and parallel test execution right out of the box, helping you simulate real-world load and usage patterns. Throw in some fault-injection (mutation analysis) and you’re covering all the bases.

TestNG is particularly strong when it comes to unit testing—verifying the functionality of individual modules and ensuring that every piece of code works as intended in isolation. Tools like Jenkins can be used alongside TestNG for continuous integration and automated test execution, streamlining the testing process from development to deployment.

In particular, TestNG shines when it comes to integration testing—making it a great fit for scenarios where you need to verify that different modules or components of an application work together as expected. While tools like Citrus and FitNesse also focus on integration testing, TestNG stands out for its flexibility and ability to manage complex test scenarios right within your Java environment.

Key Features:

• Extensive annotation-based configuration

• Parallel test execution

• Built-in support for data-driven testing

• Detailed reporting features

Pros:

• Flexible annotations for test design

• Great for data-driven testing

• Parallel execution support

• Generates detailed reports

Cons:

• Java-only framework

• Learning curve for new users

• Complex setup for beginners
  
  

13. Zephyr Scale (Free Version)

Description: Zephyr Scale is a test management solution built for Jira. It provides a structured way to create, organize, and execute test cases within Jira workflows. The free version is best suited for smaller teams that want basic test management tightly integrated with Jira.

Zephyr Scale brings dynamic testing discipline to your Jira workflow—track live results, input new data on the fly, and keep your team in sync as you adapt test cases to evolving requirements. It makes your bug-hunting and feature-verifying process as flexible as your backlog.

Key Features:

• Seamless Jira integration

• Test case creation and management

• Traceability between requirements, tests, and issues

• Manual and automated test execution support

Pros:

• Seamless Jira integration

• Easy creation and organization of test cases

• Supports both manual and automated execution

• Good traceability with Jira issues

Cons:

• Works only within Jira

• Limited features in free tier

• Overwhelming for very large projects

Test Management Tools at a Glance:
Test management tools like Zephyr Scale (as well as alternatives such as JIRA and Redmine) help plan, organize, and manage all testing activities in one place. These tools are essential for tracking test progress, assigning tasks, and maintaining transparency across development and QA teams. Whether you need to manage manual test cases, automate regression suites, or simply keep your sprints organized, test management solutions play a pivotal role in efficient software delivery.

14. Selenium

Description: Selenium is one of the most popular open-source automation frameworks for web applications. It supports multiple programming languages (Java, Python, C#, etc.), browsers, and operating systems. It is highly flexible and integrates with most CI/CD pipelines, making it the backbone of browser-based test automation in modern QA.

Selenium is a classic choice for dynamic and automated web testing. It supports test drivers for input automation, integrates with emulators for unbuilt components, and can even be used alongside mutation analyzers for fault tolerance. With Selenium, your test suite is as dynamic as the web itself.

Key Features:

• Supports multiple browsers (Chrome, Firefox, Safari, Edge)

• Works across Windows, macOS, and Linux

• Integrates with popular CI/CD tools like Jenkins and test frameworks such as TestNG and JUnit

• Parallel test execution with Selenium Grid

Pros:

• Multi-language and multi-browser support

• Huge community and learning resources

• Highly flexible with strong integrations

• Industry standard for web automation

Cons:

• Requires significant setup and maintenance

• Scripts can be brittle and prone to breakage

• No built-in reporting capabilities

• Steep learning curve for new testers
  
  

15. Gatling

Description: Gatling is an open-source load and performance testing tool written in Scala. It’s known for its high efficiency and ability to simulate thousands of concurrent users with minimal resource usage. Gatling is ideal for engineering teams testing web applications, APIs, and services under heavy load.

Pros:

• High performance and scalability

• Code-centric DSL for maintainable tests

• Generates detailed HTML reports

• Supports HTTP, WebSockets, and other protocols

Cons:

• Requires Scala knowledge for complex usage

• Focused primarily on load/performance testing

• Not suitable for UI or functional testing

• Smaller community compared to JMeter
  
  

Closing Thoughts

With so many tools available, the right choice depends on your project type, team skillset, and scale:

• API Testing: Postman, SoapUI, Qodex.ai

• Web Automation: Selenium, Cypress, Katalon

• Load & Performance: JMeter, Gatling

• Test Management: Zephyr Scale, TestPad

• Mobile Testing: Appium