Top 10 Test Automation Anti-Patterns and Ways To Avoid Them

Timothy Joseph
Timothy Joseph | January 25, 2022

Top 10 Test Automation Anti-Patterns and Ways To Avoid Them

What Is an Anti-pattern?

In software development, an anti-pattern solution may initially appear desirable but ultimately produces more problems than it solves. Anti-patterns can range from mundane issues such as lack of documentation around automated tests to organizational structures that inhibit change and innovation. This is a list of the most common anti-patterns that have been seen in test automation efforts, along with suggested remedies.


Test Anti-patterns That You Should Be Aware Of

As software development becomes more complex and automated, it's essential to be aware of the different anti-patterns that can occur during the testing process. Test anti-patterns can lead to several problems, including missed test cases, incorrect results, and even software failures.

  1. Anti-pattern - Starting Testing Too Late

    One of the most common anti-patterns seen in software testing is starting testing too late. Many developers and organizations do not begin testing their code until it has already been written, which leaves some risks unaddressed before the code goes live.

    The Good Practice

    One of the best ways to avoid this problem is by starting testing early in the development process, ideally before even writing any written code. That way, testers can examine requirements and designs to determine whether or not they are testable or if any changes need to be made before developers start coding.

  2. Anti-pattern - Hardcoding Test Data

    Another standard testing anti-pattern is hardcoding test data into scripts, automated tests, and production code. Developers tend to create static test cases by writing in specific values or expected results in the code too early before a system has been deployed. However, in reality, what happens is that these static values will often change over time. This means that even simple defects can go unnoticed for some time because the new values aren't reflected in the test cases. This also wastes developers' time since they need to modify these values manually whenever they are changed, which can be quite often if not appropriately managed.

    The Good Practice

    One of the best ways to avoid anti-patterns like this is by using TDD anti-pattern testing, which allows tests to run with different values that can be changed automatically. This means that testers no longer need to hardcode specific values into their test cases but instead write a general test case and provide the relevant information at runtime. This also helps make tests more readable, repeatable in different scenarios, and much more reliable in general.

  3. Anti-pattern - Hardcoding Environment Configurations

    Another standard testing anti-pattern is hardcoding environment configurations, leading to additional problems. Developers often create their test cases with specific hardware and software installed on the machine they are using to run the tests - even if these configuration values often change. In reality, though, teams may use different devices with different hardware and software configurations, which can cause issues during the testing process. This means that tests may fail for no apparent reason or give false results, which results in wasting time trying to identify the source of the problem.

    The Good Practice

    One of the best ways to avoid anti-patterns like this is by configuring test fixtures to configure the entire testing environment with a straightforward command. This means that testers no longer need to install multiple packages themselves, ensuring that tests are much more reliable and repeatable in different scenarios. It also makes test cases much easier to maintain since they'll be independent of the machine they're run on, which helps make them much more reliable in general.

  4. Anti-pattern - Running Manual Tests for Regression

    A typical anti-pattern testing is running manual regression tests, which requires a lot of time and effort. This means that testers spend a lot of time going through the same test cases again and again simply because these tests haven't been automated yet. In reality, though, all this functional manual testing can take up a lot of resources and time that could be used in more beneficial ways. This means that testers spend a lot of their time running the same tests repeatedly, which can become very costly when scaled up to hundreds or even thousands of test cases per application or release.

    The Good Practice

    One of the best ways to avoid anti-patterns like this is by creating and maintaining a library of automated test cases for regression. This means that all the repetitive manual testing work can be done in record time, ensuring that teams can run thousands of test cases overnight with perfect accuracy. It also helps make tests much more reliable and repeatable, which makes them much more efficient to run in general.

  5. Anti-pattern - Overloading Automation

    Another standard testing anti-pattern is overloading automation, leading to several problems. In such cases, teams often try to automate more than they can handle, which usually results in inadequate test coverage at best. What happens in reality, though, is that some teams try to automate too much and end up with unreliable or even worse tests. This means that the tests don't provide enough coverage and fail more often than they succeed, which wastes time trying to fix issues after tests run.

    The Good Practice

    One of the best ways to avoid anti-patterns is by creating a specific test automation strategy that outlines what types of tests should be automated. This means that testers can select the right tools for automation based on what's available and suit their needs in general, which helps make tests much more reliable. It also makes the testing process more straightforward to maintain, ensuring that teams can automate everything in record time with perfect accuracy.

  6. Anti-pattern - Neglecting Test Environment

    Establishing a perfect test environment is the first step to staying away from an anti-pattern. There are often difficulties in creating suitable and dependable test environments. Many organizations end up using "outdated" OSes, patch levels, and software versions, resulting in errors that lie both on the application and infrastructure side of the development lifecycle. This can be very time-consuming to debug, especially with large test environments.

    The Good Practice

    The best thing to do when setting up a productive test environment is to go for something that you can easily replicate in the future. Suppose the testing team cannot reproduce the same results. Even if they are using similar tools and technologies, it will make it difficult for them to repeat failures in similar environments. This also makes it easy to rebalance the testing capacity across different domains.

  7. Anti-pattern - Running Very Similar Tests

    Tests are meant to be executed on the same objects until they pass. If the new object behaves in a way that is different than what was expected, it can cause errors and regression issues while executing tests later on. These types of problems lead to wasted time, effort, and resources.

    The Good Practice

    The best way to ensure that tests are accurate is by executing them on similar objects. This ensures that the results from earlier tests can be reused later on. This effectively saves a lot of time and effort if there aren't many changes made in between test executions. The more changes that happen throughout the lifecycle of a project, the more difficult it becomes to run tests and reproduce results.

  8. Anti-pattern - Using Unclean Data

    Unclean data can have a lot of different forms, but the impact on automation testing is always the same. What happens is that it leads to errors in the test results and makes it difficult for anyone trying to reproduce them later on.

    The Good Practice

    When there are changes between test executions, you need to run tests with clean data. This means that you should never run tests with legacy data because it will influence how a test executes and propagates errors. It is essential to go back and clean up previous test results so that regression errors can be prevented from occurring when running new tests.

  9. Anti-pattern - Conditional Assertions

    Conditional assertions are a form of flaky tests. This means that the test will pass if an assertion is correct or fails based on whether or not the criteria has been met so far. Over time, as more and more tests are executed with conditional assertions, too many errors occur due to false positives, which can lead to delays and a decline in successful test results. This often leads to the need for a rework, something that will require even more time and effort.

    The Good Practice

    Conditional assertions should never be used because they cannot give accurate results without proper analysis. Instead, you should either use different testing types or determine if a change of strategy is worth the cost. This allows for more accurate and reliable test results that can be easily repeated in future test environments.

  10. Anti-pattern - Not Sufficiently Training Developers

    It's imperative to make sure that everyone involved in test execution understands how it works and what the results truly mean. This increases the productivity of the testing team and allows for better software development, which in turn, means more automated tests that can be run with fewer errors and faster turnaround times.

    The Good Practice

    People responsible for test execution need to have a better understanding of what happens when tests are run and why they're being done. This allows them to create more accurate and reliable tests that can be used as building blocks for more complex scenarios in future projects. When there is a better understanding surrounding the benefits of automation, it's possible to leverage this for improvements in many different areas.



Several patterns can arise when it comes to testing automation, and it's essential not to fall into any of the traps mentioned above. What ends up happening is a waste of time and money which can be avoided by simply knowing these pitfalls and how they impact testing efforts. The 10 test automation anti-patterns described here expose how they can be avoided so that future efforts will be more successful.

With QASource's 20 years of experience in the Automation Testing industry, we can help you avoid these automation test anti-patterns. What's more, QASource provides customizable training courses on Agile Automation Testing and Test Management for companies of all sizes. To learn more about our services, visit us here. Schedule a call today for your FREE Quote!

Frequently Asked Questions (FAQs)

What is anti-pattern testing?

Its standard testing anti-pattern is hardcoding test data into scripts, automated tests, and production code. Developers tend to create static test cases by writing in specific values or expected results in the code too early before a system has been deployed.

What is an example of an anti-pattern?

Poltergeist: A poltergeist is an anti-pattern involving a pointless class that is used to call methods of another class or simply adds an unnecessary layer of abstraction.

What are common anti-patterns?

Let's discuss the six most common types of anti-patterns in software development:

  • Spaghetti Code
  • Golden Hammer
  • Boat Anchor
  • Dead Code
  • God Object and God Class
  • Copy and Paste Programming
What are the anti-patterns for agile testing?

Agile QA Anti-patterns are:

  • A testing team is not part of scrum meetings
  • Testing as a phase within Sprint
  • Testing efforts are not taken into account for estimates
  • Creating too many test cases too early
  • Manual regression pack takes too long to run
  • Definition of Done not clear for testing activities or not being met


This publication is for informational purposes only, and nothing contained in it should be considered legal advice. We expressly disclaim any warranty or responsibility for damages arising out of this information and encourage you to consult with legal counsel regarding your specific needs. We do not undertake any duty to update previously posted materials.