DEV Community

Cover image for Top 27 Best Practices For Selenium Test Automation
Vethee Dixit
Vethee Dixit

Posted on • Originally published at

Top 27 Best Practices For Selenium Test Automation

In recent years, you’d hardly see an organization who had not transitioned to Selenium test automation. After all, with quick feedback on new features, who’d want to miss out on automated browser testing. Even then, a few testers complain of the automation tests being unstable and unreliable. Trust me, that’s not true! A lot of the time the reason for your unstable tests is not following the right practices for Selenium test automation.

Although there are no hard and fast rules for writing Selenium test automation scripts, there are certain tips you can follow to write better test scripts.

Speaking of which, in this article, I’ll share 27 best practices for Selenium test automation, which will help you get the most value out of automation testing efforts. So, let’s dive right in.

1. Test Early and Test Often

One of the best practices for Selenium test automation is to test early and often. As organizations moved away from the waterfall model, it became important for testers to be more involved in the development, in contrast to keeping it as a one-off activity, as it had major implications on project deadlines, as well as cost.

This gave rise to the concept of shift left testing, this means to involve testers right from the requirement gathering phase. That way, they are able to come up with test cases in advance by understanding the expectations of the end-users. The primary idea here is to avoid encountering bugs after the development is done. Testers can provide their valuable input and help developers develop the product in a way that improves the user experience. Also, to help developers avoid any development practice which isn’t recommended for the product. For example, imagine your developer leveraging CSS Subgrid in a pricing page table of a subscription-based model. The cross browser compatibility of CSS Subgrid:


If your testing team is already aware of your developer using a CSS Subgrid, then they can go ahead and prompt the developer in advance before the development is complete. That way, you are saving time for both developers and testers. Not to mention, you are also saving yourself from a potential outage.

This is why you should start automated browser testing as soon as possible, and do it as frequently as needed. The earlier you start testing, the sooner you find bugs and bugs found earlier can help you save both time & resources in your SDLC(Software Development Life Cycle)..

2. Consider Using a BDD Framework

BDD or Behavior Driven Development, is a popular development approach while performing Selenium Test Automation. BDD enables testers to write Selenium test automation cases in simple English which can be understood by anyone without coding knowledge. This further helps in creating a bridge between the business and technical team to understand what’s really happening in the project, overall creating better collaboration.

By writing your Selenium test automation scripts with BDD, you create specifications, which will help your team to understand the test and requirements in a much better way. This allows you to save time, as you won’t have to explain the test to any stakeholder as they are self-explanatory now.

As the business team has more insights into the tests, they might be able to give some input on the basis of business benefits.

3. Use Selenium Wait Commands Instead Of Thread.sleep()

It’s quite often that your web application takes some time to load due to the network speed, server issues or various other reasons. To tackle this, you need to pause your scripts to wait for all the elements to load. This is a good way to ensure that all your web elements are there while you run your tests on them.

One way to pause your script is by using the Thread.sleep() function, it pauses your test script for the specified time. But there is a major flaw with this function, let’s say you want to open a web page, and you’ve chosen the time to wait to be 6s, in cases where your website loads much faster, you would’ve wasted a lot of time.

In the faster scenarios, you might have lost a lot of extra time running Selenium test automation, and in the slower ones, you’d get the result as a failure. So in order to avoid such situations, you need to incorporate implicit waits or explicit waits.

To know more about Implicit wait commands or Explicit wait commands you can visit our previous article on Selenium Waits.

4. Set Up Selenium test automation Reports

“You can’t improve, what you can’t measure.” This stands true for Selenium test automation as well, you can’t ensure better Selenium test automation results if you don’t keep a track of how your tests are performing. The automation testing report helps in improving the readability of test results and helps to minimize the time spent in maintaining the test data. In a previous blog, we’ve covered the importance of Selenium Reports, also you can learn more about how to generate Selenium test automation reports using pytest.

Selenium test automation report generation can do wonders for you, as you save precious time as you manage your test data in an organized manner. Due to this, you have better control over tests, as using this data you can analyze when the test scripts are failing.

You can keep a tab on your test scripts with the LambdaTest Platform. With LambdaTest, you can run your Selenium testing scripts over a cloud-based Selenium Grid of 2000+ desktop and mobile browsers.


5. Use Page Object Model

As the UI for a web application changes, so do the locators associated with it, with it all the tests need to be written again. But, there is a solution to this, by using Page Object Model, you don’t need to make changes to all your test scripts, again and again.

With POM you only need to change the page objects, as all the locators are in one central repository. In POM, every webpage has a separate page class, to find web elements on it as well as the page methods for these web elements. This makes the project more reliable as, the developer doesn’t need to scan the whole code and test scripts, just to incorporate a few UI changes.

6. Take Automated Screenshots For Failure Investigation

Your Selenium test automation script is bound to face some bugs, failures, somewhere down the road. In such cases, it is recommended to collect automated screenshots of your test script execution through a Selenium Grid.

If you’re running your Selenium test automation using our online Selenium Grid then you won’t have to worry about it. All you need to do is pass a simple capability through your Desired Capabilities class i.e. set the capability of the visual flag to true.

You can even refer to our Desired Capabilities Generator to turn on the button for generating step by step screenshots of your Selenium test script execution.


The Desired Capabilities Generator will provide you with the class in various programming languages as you turn on the toggle for Screenshot under the Advanced configurations.

7. Designing Tests Prior To Automating Them

Before you begin to automate tests, creating scenarios and test cases in advance is a good practice. Diving straight into automation without a proper test design can prove to be dangerous. This is why a test design along with strategy and planning is necessary for Selenium test automation success. You need to develop test architecture describing the structure of the test program and how the test program will be managed.

Automating tests without adequate design, indicates that you are only interested in ensuring that the script works. It’s important to think about different possible scenarios that can help you perform foolproof testing. After all, reducing the testing scope just to make sure that the test passes is not a wise move! Selenium test automation enables testers to create test scripts using multiple programming languages.

8. Not Completely Relying On An Automation Tool

Automation tools are vital components of different testing activities such as automated browser testing. But you should know that they don’t solve everything! We know that using the correct tools is an essential part of switching to an automated browser testing framework. But that’s just the beginning!

However, some managers live under a big misconception that if they choose the right tool, automating anything is possible. Well, no tool offers you everything. Even though they simplify the entire process, you can’t carry out testing without skilled resources.

Sometimes, when you try to use automation tools without any human intervention, they can get stuck while recognizing complex objects on software or application. But if you have skilled resources, they can make the tool move past complications and use them to the benefit of the company.

9. Identifying Which Tests To Automate

One of the best practices for automation testing is knowing what to automate. Before you head out to implement automated browser testing, it’s important to know what to automate first. The main reason behind automation is avoiding repetitive and mundane tasks. So, it makes sense to stick to the goals and know what kinds of tests you should automate.

For instance, it’s a good idea to automate tests that involve visual scenarios including fonts, colors, and layout structure. You can also automate testing of static content such as logo, title, policy, and terms. Of course, we know that they rarely change and thus, you can easily automate them.

10. Automating Most Frequent and Predictable Test Cases

Building on the gist of the previous point, there are some specific test cases that go really well with automation. So, what should be the next big step? You can choose the test cases with frequent occurrences and which are predictable.

For instance, when you click on a tab, an app starts to launch. This is a generic test with a condition. In other words, when we know that an event is sure to occur, the result is predictable. So, to avoid the repetition of executions, you can automate these test cases.

11. Choosing The Correct Selenium test automation Too

While switching to automated browser testing, every company has different factors to think about. Even though there is a wide array of Selenium test automation tools available in the market, choosing a tool is not a one-fit-for-all approach. You have to select the correct Selenium test automation tool according to the needs of your company.

For instance, check whether the tool supports the platform your firm works on. Some other questions to ask include the following. Do you need the tool to perform mobile application testing? What are the operating systems you work with? Do the tool support record and playback testing? Can you manually create automated tests?

12. Removing Uncertainty From Selenium Test Automation

As testers, what do you need the most from a Selenium test automation tool? I’m sure the most obvious answer is consistent results. Sometimes, tests fail even when nothing is wrong. On the other hand, a test might pass when there is something wrong. Now, you can imagine how dangerous both of these situations can be!

When there are any inconsistencies or false positives, it increases the amount of time we take to analyze results. Therefore, when it comes to regression packs, never hesitate to eliminate unstable tests. After all, you have got to keep reliable and consistent results as goals!

13. Hiring a Dedicated Team of Experts

A successful testing team comprises both manual and automation testers. Now, the biggest mistake companies make is think that a single entity can perform both tasks. However, automation testing is a full-time job in itself. The same goes for manual testing. It’s unreasonable to expect manual testers to carry out Selenium test automation.

But if you are hesitant to hire new staff for automating and leave the task to your experienced manual testers, first free them of manual testing and related responsibilities. They shouldn’t be automating with half of their focus on something else.

Or else, hire an automation engineer to do the job. Now, suppose your firm operates on a large scale. In that case, I suggest you appoint an automation architect. Then, hire automation engineers whom the architect can supervise. The number of engineers you hire can be according to your company’s production requirement.

14. Ensure Collective Selenium test automation Ownership

Sometimes, appointing a single automation engineer can prove to be a mistake. Mostly, in this situation, the rest of the team doesn’t really know what’s going on. But if the team’s collective knowledge in this area is up to date, the chances for success in implementing Selenium test automation increase.

Keep the involvement of all the team members equal for integrating automation in your workplace. This way, the automation testers also get a chance to impart their knowledge to the rest of the team. Hence, when everyone is aware of what’s going on, they can all contribute to the success of the company.

15. Dividing Efforts During Automation Testing

As we have already discussed, automated browser testing is a team-based task. Depending on the skill level of different employees, you have to divide automation related tasks. For example, a person who is an expert in scripting languages should write automated test scripts. On the other hand, the team members who are not well-versed with scripting languages might do well with writing test cases.

Even the non-technical staff can use keyword tests to create powerful and robust automated tests. Thus, when everyone in the team contributes according to their skills, finding defects becomes a lot easier.

16. Reviewing The Validity Factor For Selenium test automation

Sometimes, a team fails to plan well before implementing automation. This can cause a negative impact on the entire software. There are times when automated tests are not able to check for some verifications. The main reason behind that is those verifications might be outdated.

Therefore, it’s vital that you review validity for all automated tests. In other words, all the time, you need to ensure that the tests are up to date. It’s best to keep someone in charge of the validity and sanity of automated tests.

17. Selecting Automation Tools That Hold Familiarity With Company Resources

Suppose, your company resources hold the familiarity with a particular programing language. Let’s just say that the language is C#. Therefore, it makes sense to develop the application you are about to test in C#. In this case, if you select a tool that doesn’t support writing scripts in C#, it doesn’t really make sense. We understand that learning a new language calls for a lot of effort and is time-consuming. But you can totally avoid the learning curve if you opt for a tool compatible with your company resources.

18. Using Test Techniques

Using test techniques is one of the best practices for automated browser testing. If you are a tester, there must have been a time in your life when all your focus was on learning test techniques. Of course, manual testing is the field in which you can really apply those. But don’t let yourself believe that the valuable knowledge you have will go in vain with Selenium test automation. After all, test techniques are not merely for manual testing!

For instance, four test techniques, in particular, have a lot of benefits to offer if testers use them in test automation. The are Boundary Value Analysis, State Transition Testing, Equivalence Partitioning, Pairwise Testing.

19. Good Automation Equals Great Manual Test Case

There are some test cases that are easy to automate. But when it comes to finding defects, it turns out to be weak. In other words, if you don’t have a good design or manual test cases, automation won’t give you as much value as you might want. So, one of the best practices is to write manual test cases beforehand. Jot down the steps clearly and mention the expected outcome from each.

Also, keep the objective of each test case clear. Make sure that it doesn’t depend too much on other test cases. I suggest automation engineers run test cases manually at least one time. This will help them decide the navigation flow and which objects need identification. Another upside to this practice is that sometimes, you can even identify bugs before writing the automation script. Don’t you think it’s better to catch bugs in the development phase instead of in execution?

20. Not Automating Unstable Functionalities

It is common for things to go wrong during the development of new functionality. Sometimes, using the feature may no longer appear to be necessary just because the business owners changed their minds! Suppose you started automating during the development phase of a functionality. In that case, you need to update the tests many times. After all, the functionality is likely to keep on evolving!

We can say that keeping up with so many unexpected changes is quite exhausting. Moreover, if you can no longer apply a functionality, all that effort goes in vain! Therefore, a wise move is to automate a function only when it’s not subject to many changes and is stable.

21. Creating High-Quality Test Data

You can take data-driven automated browser testing to a whole new level by creating high-quality test data. A good automation tool has a good understanding of the data file content. Usually, testers can manually create test data and store it to the location the company prefers. However, some tools provide test data generators that enable users to create excel sheets and table variables to save test data.

It’s a good idea to invest significant time and effort into creating high-quality test data. This makes the writing of automated tests much simpler. This practice also helps in extending the existing automated tests and pacing up the application development process.

22. Creating Test Resistant To Changes In The User Interface

Changes in the UI can greatly affect test results, especially, during the initial phases of an application. When the application version upgrades, it can create obstacles in the way in which automated tests work. For example, some scripts find objects using location coordinates. But what if there is a change in the location?

If you run automation tests in such cases, the test will fail as test scripts won’t be able to find the object. To ensure the success of a test, you can add new names to replace the old ones. If names for the controls are unique, the changes in the user interface won’t impact test results.

23. Identifying Automation Opportunities

When you have a manual test case in hand, think about how you can expand its scope. Think of the different automation opportunities so that you don’t end up automating as it is. For instance, the most common test case is to log in to an application. You can make this particular test case data-driven if you expand it.

The login function has different possible scenarios. For example, invalid password, invalid username, blank username, invalid email, etc. List them out with the outcomes expected in an excel file. Use this as a source of data for your test case. So, when you automate this manual test, you can check different scenarios in a single go.

24. Avoiding GUI Automation If There Is Another Option

If we take a look at different automated tests, GUI automation is the toughest. But does that mean you completely say no to it? Of course not. But a wise move is to avoid GUI automation as much as possible, especially in cases when there is another alternative present. Skilled automation engineers can determine the necessary tests for the UI layer.

You should also know that it’s okay if you have to stop automating the GUI. Sometimes, when GUI is concerned, automation just stops making sense at some point. Too much GUI automation when unnecessary can make a really bad mess almost impossible to untangle.

25. Understanding The Context

Unit, Service, API, and GUI layers have different purposes for automated browser testing. Before automating, it’s important to understand the context of each test. For instance, unit tests involve testing of individual software methods or functions. API tests determining whether a set of classes or functions are able to work together. It also ensures that you can pass data to and from different classes. GUI testing checks screens, controls, windows, dialog boxes, etc. All in all, it ensures that the entire system works well according to common use cases and user scenarios.

26. Not Considering Automation As a Replacement For Manual Testing

Automated browser testing is not a replacement for manual testing. The technology is here to complement manual testing and make the task of testers easier. It’s important to understand that automation means having to run fewer tests. For instance, regression tests can take a long time to complete. You might also need to perform them often to ensure all the existing functionalities of an app work well. So, automating them makes sense.

But the newly added functionalities can interfere with the working of existing ones. So, blindly automating end-to-end testing won’t do you any good. Test automation can’t capture unforeseen circumstances. In this case, you might want to perform exploratory testing. Here, the testers have to use their own creativity. To sum up, automation is to prevent manual testers from doing repetitive work and focus on finding bugs and more test scenarios.

27. Targeting Quick Feedback

Quick feedback helps in spotting and fixing errors quickly. The whole purpose of automated browser testing is to pace up testing procedures while maintaining high-quality. Shorter release cycles results in a quicker time to market. This makes continuous feedback possible and leads to constant improvement.

Continuous feedback from stakeholders, functional Experts, Testers, and QA Analysts, ensures an error-free and speedy release. Feedback includes necessary information as well as actions to keep fixing issues as they come.

Summing It Up

that's all

That’s all for the best practices for Selenium Test Automation. There’s a lot that can be done to improve test automation efforts and I hope these practices would certainly help you improve. Finding bugs early in the development, that can do wonders while performing test automation. Also, it’s always to play smart and think over the test design and strategy before you start writing Selenium test automation scripts.

Liked the tips, or you have another to share, feel free to share them with us in the comment section down below. Meanwhile, share the article with your fellow automation testers! Happy testing.

Top comments (0)