How I Choose Test Automation Tool?

Jayateerth Katti
8 min readSep 25, 2023

Testing is everyone’s responsibility.

It is the responsibility of all stakeholders for a product-Product Manager, Architect, Developer, Tester, Customer support agent. Quality is responsibility of each one of them,

But it is you, the tester, who owns quality.

I think you already know it.

Testing is not just checking. It is ownership of quality. As a tester, you should know what to test, when to test, how much to test, etc.

You test to make your customer happy. You test to make your product successful. You make your company profitable. You test to increase the brand value of your company. You test to grow in your career.

So, testing is intellectual.

Testing is not checking. Checking is major part of testing. No doubt about that. When certain input is provided, you make sure that output is what is expected. This is checking.

Now you know what is checking.

Do you think testing can be automated? No. testing can not be automated. But checking can be. Checking is algorithmic. You provide input to a system and check output.

This seems to be laborious job.

Yes. Specifically when you execute same test suite multiple times. May be part of smoke test or Regression test.

Over a period of time, it becomes boring. Then you think of automating it.

Am I right?

Automating Test cases

So, you start thinking about automating test cases.

Now many questions will come to you. First one is which tool to use for automation.

This question becomes more complex. Because there are lot of tools available for automation. Example: Selenium, Appium, UFT, Cypres, Katalon etc.

Which Tool To Select?

Well, I had this same question when I started my automation journey.

In my 20 years of career, I have worked on multiple projects. Automated different applications checking. They were built on different technical stack.

I have learnt the skill of selecting automation tool over the years.

Based on this experience, I will share how I select the automation tool.

You can copy the tool selection process.

Let’s dive in.

How I select Automation Tool ? (My Process of Tool Selection)

In my first project, we had QTP (Quick Test Professional) tool.

I did use that. Framework was already developed. I only kept on developing automated scripts. That is addition to existing list of scripts.

Then new automation project started.

I directly started with QTP, since licensed version was available. Did develop scripts for few test cases. Then I hit road block. Some elements of the application were not identified by tool. I had to stop the use of QTP.

Developed scripts became useless.

Then I learnt how to select a tool for automation.

Here is my process of tool selection.

  1. Understand Project Requirements:

First things first. I begin the process by understanding my project’s requirements. Is it application testing? If yes, then what type of application are we testing (web, mobile, desktop)? What are the technologies involved?

Or is it API testing? I consider factors like the size of the project, its complexity, and the available resources. Example: If I am testing a web application, the project requirements may include cross-browser compatibility testing. In this case, I’d prioritize tools that support in web testing.

  1. Define Testing Goals:
    I define testing objectives.
    That includes what will I be testing — functional, performance, security, or compatibility testing.
    Knowing testing goals will help me narrow down the options.
    There different tools available for different type of testing.So goal should be clear to select the tool.
    Example:
    If our goal is to perform load testing for an e-commerce web application, the load may be huge during holiday sales.
    To test this, I would need a tool like Apache JMeter that specializes in performance testing.
  2. Evaluate Tool Types:
    Then I get in to tools.
    This step is more of analysing different tools.I check following in the tools.Open Source vs. Commercial:There are some very good free tools available.
    So as licenced tools.
    So I will analyze them.This depends on budget. Open-source tools like Selenium or Appium can be cost-effective, while commercial tools like TestComplete or UFT offer comprehensive features but come at a price.
    If my company already has license for any tools, then there might not be additional cost involved.
    Now-a-days there many tools which do not need any code to be developed.
    Some tools need little coding. Some have drag and drop features. Some tools offer both options. Depending on the time available for development & budget and skill set of team, I decide which one to prefer.
    Example:
    During budget constraints, choosing Selenium (an open-source tool) makes sense, especially when automating web testing.

2. Compatibility and Integration:

This is one of the important factors.

I ensure that the tool is compatible with our product. That is, I check if the tool has the capability to uniquely identify the elements/objects of the application.

Also, it should integrate smoothly with existing tools (e.g., CI/CD pipelines, defect tracking systems).
Example: If our team heavily uses Jenkins for CI/CD, I’d prefer a testing tools that seamlessly integrates with Jenkins.

3. Scalability:

Initially application will be small.
Then features will be added gradually. So as testing. The test scope keeps on increasing.
Therefore scaling is the important factor to be considered.

I assess whether the tool can scale with project’s growth. It should accommodate increasing test cases and evolving requirements.

Some freemium tools have limited functionalities in free version.
So, while selecting tool, I check the scope for scaling in tool.

Example:
A tool like Cypress.io can scale well for an e-learning platform that adds new features regularly and requires extensive end-to-end testing.

4. Community and Support:

Some tools have great functionality.
But, they lack in support. The documentation is limited, user base is limited.

This limitation becomes a challenge when I am stuck with something. I need to get some support from somewhere.

Therefore, I check the tool’s community and support resources.
Active communities often mean quick issue resolution and a treasure of knowledge.

Example:
Selenium has a large community, so if I encounter an issue during test automation, it is easy for me to find answers in forums or blogs.

5. Ease of Use:

Team usually is a mix of experienced people.
Some already have experience in using one or the other automation tools. Others are totally new to automation.

And if the tool’s usage is complex, then it needs lot of time investment.

Hence, I consider the tool’s learning curve.

Ideally, it should be easy for my team to adopt and use effectively.

Example:
TestComplete’s script less testing capabilities can be advantageous for a non-technical QA team testing a complex desktop application.

6. Test Environment:

Compatibility testing can pose some challenges.
Sometimes I need to execute scripts on different browsers, simulators etc. Hence I verify that the tool I am selecting support different environments to be tested.

Example:
Appium is a popular tool for mobile app testing. Because it supports a wide range of mobile devices and operating systems.

7. Reporting and Analytics:

Reporting test execution is very important.
Hence, robust reporting and analytics capabilities are essential. It helps in tracking test results and identifying issues.

For me, tool should have capability to generate execution report at summary level and individual test case level.

Should have capability to capture screenshot. And it should be attached to the failed step.

Example:
When testing a financial application for compliance, a tool like TestRail provides detailed reporting and traceability for audits.

8. Customization:

Some times same framework can be used for different projects.
So, I check if the tool selected has capability to customise.

I assess the tool’s flexibility for customizing test scripts and workflows to match my specific testing needs.

Example:
If I need to test a unique IoT device, a script-based tool like Robot Framework allows me to create custom test libraries.

9. Maintenance and Reusability:

The software products keep evolving.
There can be changes in UI, functionality, etc.

Our automated scripts should have capability to easily make the changes accordingly.

Therefore, I evaluate how easy it is to maintain and update test scripts. Reusable components can save time and effort.

Example:
Using Page Object Model (POM) with Selenium makes it easier to maintain and reuse test scripts as UI elements change.

10. Security and Compliance:

Some products are heavily regulated.
They need to be compliant with the different regulatory bodies.

If the product deals with sensitive data or regulatory requirements, I make sure the tool meets security and compliance standards.

The tool should not use our data for other purposes. It should be kept safe. Specially in case of SaaS tools.

Example:
An application in healthcare domain must adhere to HIPAA compliance. Testing with a tool like OWASP ZAP ensures security standards are met.

11. Pilot Project:

I always do pilot project.
This I do before I start automating the test cases. I select few important (high priority test cases) and try to automate them.
This I do with shortlisted tools to evaluate their performance in a real-world scenario.

This gives the clear and fair idea about the compatibility, scalability and other aspects of the tool.

Example:
Before committing to a tool, I run a pilot project using both TestNG and JUnit to see which better suits my team’s requirements.

12. Cost Analysis:

I first check for the open source tools.
If the free or open source tools do not pass my pilot project test, I look for licensed tools.

Since we may to buy the tool/license, I will calculate the cost involved.

I calculate the total cost of ownership, including licensing, training, development, maintenance, and support.

Example:
While Selenium is free tool, the cost of training and maintaining a large team might make a commercial tool like TestComplete more cost-effective.

13. Future-proofing:

Additionally, I check the scope of the tool in future.

I select a tool that aligns with industry trends. And is likely to be supported and updated in the future.

Example:
Opting for a tool that supports containerization, like Docker, aligns with industry trends and ensures portability.

14. Feedback from Colleagues:

Then I try to get reviews.
I discuss with my colleague from other teams, if they have used automation tools.

I gather input features, challenges faced by them while automating.

This saves my time in experimenting with different tools.

Example:
Colleagues who have experience with Cypress.io recommend it for its speed and ease of use in testing single-page applications.

15. Decision Making:

Finally, I make a well-informed decision.

This decision is based on above analysis and feedback.

Example:
After careful consideration, I would choose Rest Assured for automating regression tests for APIs due to its robust features.

16. Proof of Concept (PoC):

Once I finalize the tool, I do Proof of Concept.

This is the final check to make sure that tools selected is suitable for my requirement.

I document the steps to automate, findings of the PoC and share document with stake holders.

Example:
I conduct a PoC with both SoapUI and Postman to determine which tool best suits my REST API testing needs.

These are the steps or the activities I perform before I select any tool.

By this time, you might know that tool selection is not easy. Once the decision is made, it can be good decision or may prove costly if done wrong.

You can use my approach when you decide to automate and not sure where to start.

Follow me on Linkedin
Subscribe to my newsletter.

--

--

Jayateerth Katti

20 Years of experience in testing. I write about testing and growth.