Turn your manual testers into automation experts! Request a DemoStart testRigor Free

Which Tests Should I Automate First?

Automation testing has become a crucial element in the software testing industry. If you’ve decided to incorporate automation testing into your workflow, but are unsure where to begin, you might wonder, “Which tests should I automate first?” Especially when dealing with a full-fledged application that’s heavily used by customers, and facing the time constraints inherent in Agile methodologies and from stakeholders, navigating automation can seem like a daunting task. This post aims to provide guidance to help you get started with automation testing.

Why Should I Automate My Tests?

Developing and launching an application is just the beginning. It also needs to be thoroughly tested. Manual testing, while still valuable, can’t keep up with the demanding pace set by methodologies like Agile, which promote faster deliveries. Manual testing alone can’t sustain the full burden of quality assurance. Why is this? For starters, due to shorter cycles, there’s less time for both development and testing. If a human tester is expected to cover a significant number of scenarios within this tight timeframe, the chances of oversights and errors increase. Automation alleviates the burden of repetitive tasks, such as testing the same set of features every cycle. By employing machines, we can anticipate higher accuracy, which frees up human testers to focus on tasks that require cognitive skills or human intervention.

It’s important to carefully choose your test automation framework. Selecting the right framework can help you avoid many potential problems, and certain tools can make adoption straightforward. Tools like testRigor provide this ease of adoption, along with many other advantages. With testRigor, you can dive into automation without worrying about setup or compatibility with your development framework, as it interacts with the UI and is agnostic of what’s running under the hood of your application.

Which Tests Should Be Automated?

When initiating automation, it’s crucial to identify which tests are the best candidates for automation.

  • Repetitive tests: Automation excels at handling repetitive tasks. These tasks, which remain unchanged and are performed regularly, like a smoke test suite after every release, are prime candidates.
  • Relatively stable tests: ‘Stable tests’ refer to tests that are unlikely to change and can be easily automated. For instance, testing the login functionality of your application can typically be automated, as this functionality is unlikely to change frequently.
  • Tests prone to human error: Tests that require checking many combinations in a single scenario or validating large amounts of textual data are also good candidates for automation.
  • Data-driven tests: If your tests involve multiple datasets or variations, consider automating them using data-driven testing techniques. This method enables you to execute the same test logic with different input values, enhancing test coverage and efficiency.
  • Time-consuming or labor-intensive tests: Automating these tests can reduce the testing cycle duration and free up testers to focus on more critical, exploratory tasks.
  • Frequently executed tests: Automating tasks like regression tests, or tests performed as part of each software release, can save a significant amount of time and effort in the long run.
  • Cross-platform and compatibility tests: If your software needs to be tested on multiple platforms, operating systems, browsers, or devices, consider automating them. Automation can help streamline the testing process across different environments and configurations.
  • Business-critical workflows: Some scenarios guide you through critical user journeys and crucial modules. Bugs in these areas could harm the business, potentially causing legal issues. Automating these tests can mitigate this risk.

How to Prioritize Test Automation?

Now, let’s address the million-dollar question – how should you prioritize your automation backlog? There isn’t a single ‘correct’ approach, but you can utilize several strategies to help guide your decision-making process.

Firstly, Understand the Testing Scope of the Application Under Test To start, you need to clearly define the scope of testing. For example, if your focus is on the catalog page and the checkout cart, your test cases should center around these functionalities.

Begin with a Smoke Test Suite A smoke test suite is a compact set of critical test cases aimed at quickly ascertaining whether the fundamental functionalities of the software operate as expected after a build or release. The goal is to identify significant failures or major issues early on. This is an ideal starting point, as these tests can run after every release, providing a high level of assurance that the application functions correctly.

Next, Create a Regression Test Suite Following the smoke test suite, you should move on to creating a more comprehensive regression test suite. This suite should contain test cases designed to ensure that modifications, updates, or fixes to the application do not introduce new defects or disrupt existing functionality. It should include a subset of test cases from previous testing cycles that are re-executed to validate the system’s stability.

Expand to Other Forms of Testing Once your smoke and regression suites are in place, you can branch out to other types of testing, such as integration testing, performance testing, load testing, and end-to-end testing. Use the pointers mentioned in the previous section to identify the test scenarios that should be automated.

Prioritize Efforts by Categorizing Test Cases Regardless of the type of testing for which you’re creating test cases, prioritize which ones are mission-critical and should be addressed first. You can establish different levels of priority to organize the automation efforts. Categorize your test cases into these various buckets, and then proceed with automating them.

The Importance of Identifying Good Test Cases

At this point, you should realize that without meaningful test cases, organizing automation efforts is akin to running on sand – quite challenging. Depending on the type of testing approach you choose to automate, you need to develop substantial test cases that validate the intended scenarios. For instance, if you’re considering automating functional testing, the test cases should adequately cover the pertinent characteristics and features of that specific functionality. Similarly, if you’re planning on automating user acceptance tests, selecting the appropriate user journeys for automation is vital.

Writing test cases can often be challenging, especially if the framework requires you to do so via code. This demands skilled resources who can write code, which not only raises costs but may sideline manual testers whose system knowledge is invaluable. Collaborating with other team members like product owners and business analysts can also be complex, particularly when working on user-centric test cases. With frameworks like testRigor, writing test cases becomes far simpler, as you can create them using plain English statements.

These test scripts look like instructions written in English, which allows manual testers to contribute to the quality assurance process via automation as well. In fact, testRigor is so powerful that it uses AI to eliminate the need to write locators to identify UI elements. Simply mention the relative position of the UI element, and testRigor takes care of the rest. Here’s an example wherein a timesheet table is being sorted and the visibility of certain elements is checked:

click "Timesheets" to the right of "Projects"
check that table "timesheets" at row "2210" and column "Name" contains "Mark Twain"

As demonstrated, writing test cases with this tool is a user-friendly experience, without the hassle of coding or extensive setup.

Key Considerations

Automating test cases can add immense value to your quality assurance efforts. However, many teams rush into this process without considering the full scope of the task, leading to a host of issues down the line. Here are some key points to help guide you through the test automation process and prevent you from becoming overwhelmed.

Identify What Requires Automation This may be the most important step and cannot be overstated. Just because you’re using automation for testing doesn’t mean every single test scenario needs to be automated. Carefully decide what benefits from automation and what necessitates manual testing.

Test Maintenance Contrary to what you might think, automation testing isn’t a one-and-done task. Test cases often require regular updating due to failures caused by UI changes, functionality modifications, or issues within your test automation framework that lead to flaky tests. It might seem helpful to automate every single feature, but you may find yourself swamped with test cases. Be strategic about what should be automated to avoid wasting repeated efforts on test maintenance.

Documentation It’s beneficial to map test cases to requirements, bug IDs, or features. If you’re using a test case management system, this mapping can aid in creating useful documentation for later reference.

Choosing a Test Automation Framework The right tool can simplify even the most complex tasks. Choose an automation framework that meets your specific needs. There are many on the market, each offering different features and targeting various types of testing. Frameworks like testRigor are excellent choices, as they use AI to address test maintenance issues, simplify test creation, and expedite test execution.

Which Tests to Avoid Automating?

Despite its benefits, automation isn’t always the best approach.

  • Ad-hoc and Exploratory Testing: These types of testing rely heavily on human judgement to uncover unexpected issues and potential problems. They’re not easy to automate due to their spontaneous and expert-dependent nature.
  • User Experience and Usability Testing: Evaluating user experience, aesthetics, and usability requires subjective assessment and feedback from human testers. Automated tests may not capture and evaluate these aspects accurately.
  • One-time or Infrequent Tests: If a test case is rarely executed, the time and effort required to automate it may outweigh the benefits. Automation yields the greatest ROI when tests are executed frequently.

Using Modern Test Automation Frameworks

Your choice of test automation framework will significantly influence your testing process. It’s crucial to opt for a system like testRigor, a state-of-the-art tool for end-to-end testing. Thanks to its AI-powered engine and Generative AI test creation feature, it is user-friendly, offers stable test executions, and reduces test maintenance time by 99.5%.

With testRigor, you can automate tests across web, mobile, and desktop platforms. It can handle functional tests, end-to-end tests, and user acceptance tests, including complex interactions with UI elements like table data manipulation, email and SMS content manipulations, 2-factor authentication during login, audio testing, file uploading, accessibility testing, and visual testing. You can even write loops, create reusable rules, and save data in variables.

For those working with datasets, testRigor offers robust solutions. The tool can integrate seamlessly with various other frameworks and test management systems, making it an excellent choice for organizing test cases.

So, in a nutshell, testRigor is the only tool you need to simplify every aspect of test automation, from initial setup to writing your tests, and maintaining them. Our case studies speak for themselves and provide great insights.


Before deciding to automate a test case, it’s crucial to evaluate its nature, purpose, and requirements. Striking a balance between automated and manual testing can optimize the overall testing process. Ultimately, automation testing should provide a return on investment. If it’s not doing so, then the purpose of automation is defeated.

Related Articles

Top 5 QA Tools to Look Out For in 2024

Earlier, test scripts were written from a developer’s perspective to check whether different components worked correctly ...

Best Practices for Creating an Issue Ticket

“Reminds me of the awesome bug report I saw once: Everything is broken. Steps to reproduce: do anything. Expected result: it ...