January 28, 2021
Everything You Need to Know to Create a Test Automation Strategy
Test automation is about more than buying a few new tools. It’s a practice that involves running tests automatically, managing test data, and leveraging your findings toward improving software quality.
A strong test automation strategy allows organizations to bring products to market faster, reduce operating costs, and deliver a positive experience to customers.
While testing has traditionally been the exclusive domain of the quality assurance (QA) team, test automation now involves the entire team—developers, ops, product teams—and is implemented at every stage in the process.
In these next few sections, we’ll share some test automation best practices sourced from our internal experts.
What is a Test Automation Strategy?
A test automation strategy is a systematic approach for implementing, measuring, and improving test automation so that you can reap the rewards it promises.
According to 3Pillar’s Rodolfo Carmona, “the biggest issue with automation strategies is that most of the time, they don’t exist.”
He says, “companies tend to address the need for automation testing by implementing a known framework without providing existing teams with any definitive strategy for incorporating it into the development process without disrupting workflows.”
An automation testing framework is a set of standards, guidelines, features, and tools that help companies:
- Improve test efficiency
- Eliminate repetitive/error-prone manual processes
- Reduce maintenance costs
- Enable code reusability
- Increase test coverage
While there are many options to choose from, the most common are:
- Keyword-driven frameworks
- Library architecture test frameworks
- Linear frameworks
- Data-driven frameworks
- Modular automation frameworks
- Hybrid automation frameworks
Regardless of which framework you choose, test automation strategies tend to follow the basic structure of the “testing pyramid,” which breaks down as follows:
- Unit testing. Unit tests form the “base” of the automation testing pyramid and validate individual unit functionalities to ensure that the code word is anticipated in isolated conditions.
- Integration testing. Where unit tests aim to verify small components within a codebase, integration tests test how the code interacts with external elements like APIs, databases, and other features within the same applications. You’ll need to make sure you have a pre-production environment for running integration tests and, because they involve external services, integration tests take longer than your average unit test.
- UI Testing (E2E tests). At the top of the pyramid, you’ll find end-to-end (E2E) tests, which test whether the entire application aligns with end-user requirements. Here, you’re trying to find out if the app works as expected from start to finish. Staying laser-focused on the customer perspective is crucial here—i.e., how might they interact with the app? And—how can you write tests to replicate that interaction? E2Es take much longer to run that unit and integration tests and apply it to a wide range of user scenarios. Like integration tests, UI tests may also require the app to communicate with external services. If you’re not careful, it can cause bottlenecks or delays in the development process.
- Exploratory tests. Exploratory testing is an ongoing process to capture unstructured feedback about different parts of an app from the end-user perspective. Here, the aim is to uncover functional or usability issues you can use to drive future improvements.
Per a 2019 Capgemini report, more than half of IT teams face challenges when it comes to implementing test automation. There are a ton of tools to choose from and a variety of ways you might approach it.
Here’s a look at some test automation best practices businesses should include in their strategy:
Automation Best Practices in Software Testing to Know
While there’s no single one-size-fits-all test automation strategy that applies to every organization, we’ve outlined some test automation best practices you can use as a starting point.
Get Clear on What Can Be Automated—Or Not
It’s important to understand that not every process can be automated. Get a clear picture of when it is or isn’t appropriate to layer automation on top of an existing process.
Here are some general rules for dividing up testing tasks between humans and algorithms.
- Avoid automating tasks that require human creativity and soft skills. AI is ideal for processes where speed and accuracy are the primary objectives. Humans are better when it comes to things like critical thinking, empathy, strategy, and ethics.
- Don’t assume that if a machine detects something, it will be visible to a human (or make sense to them). Part of the core promise of AI-enabled analytics tools is, they’re really good at identifying and understanding patterns and trends within massive, seemingly unrelated data sets. There’s no way we can quickly analyze data spread across multiple channels and tools—much less interpret it correctly and take the appropriate action.
- If it can’t be executed manually, it can’t be automated. DevOps principle: you’ll need to master a process manually before applying automation.
- If questions come up while performing a manual test, they can’t be automated. This ties back to our first point: you can’t automate soft skills—problem-solving among them.
Get Developers, Ops, and QA Teams Involved from the Start
According to 3Pillar’s Denisse Vega, it’s crucial to “involve people from the beginning and identify clear requirements.”
This represents a critical step toward creating alignment early on. It allows teams to work together to build a cohesive strategy—resulting in fewer rounds of rework and a higher-quality end product.
Together, teams can decide which test cases to automate, how to distribute the work between teams, agree on what tools belong on their testing toolchain, and analyze the results of their efforts.
If you’re new to test automation, keep in mind that it may require some significant changes to your internal culture. For example, QA teams must shift into a more strategic role and learn to work with the development team. Developers, on the other hand, may need some guidance when it comes to implementing new processes/tools.
Define Test Case Scenarios
A test case refers to a series of steps that must be executed in order to verify a specific feature or function within a piece of software.
It typically includes:
- A step-by-step break down of the testing process
- Test data—including pre- and post-testing conditions.
- Specific variables/conditions that enable testing engineers to compare the anticipated outcome to the actual results. This helps determine whether a product meets customer requirements under different conditions.
Naturally, you’ll want to focus on automating high-impact areas first. All stakeholders need to make sure they’re on the same page as far as what “high-impact” actually means.
Jaime Salame says, “Since you can’t automate everything at the same time, you’ll need to perform an ROI analysis on each item on the automation agenda to identify which ones offer the biggest bang for your buck.”
How often you release new features to market also informs your test automation strategy.
The faster your release cadence, the more you should invest in new solutions.
Ultimately, the aim is to automate end-to-end testing on every deployment to reduce the potential for human errors or undetected bugs slipping through the cracks. Organizations that don’t have frequent release cycles make more sense to start adding more unit test coverage, then slowly building out the strategy.
Product maturity is a factor, too. Are you building from scratch or upgrading existing products?
When your team is working on a product that already has an established user base, you likely have some testing processes in place, as well as an established release cadence. In that case, you’ll want to focus on incorporating test automation into each stage in the development lifecycle—and crucially, incorporating test automation as early in the process as possible and filling any gaps in coverage.
If you’re building a new product from the ground up, there’s a huge opportunity to implement automated testing from the very beginning. Start by setting a goal for unit test coverage and defining end-to-end test cases for each feature.
It’s best to hold off on automated E2E testing until you’re close to release. This helps teams avoid potential test failures caused by last-minute UI changes. It’s critical to establish consensus between developers, operations, and the QA team. This allows everyone to work together to create tests that are resistant to various UI changes based on different perspectives of the end-user experience.
Select the Right Tools
Your test automation strategy lives and dies by proper tool selection and use. Identify your testing requirements based on the following criteria:
- Target use case/fit
- Testing environment
- Scripting language
- Compatibility with testing frameworks
- Licensing costs
- Maintenance costs
Use these requirements as your starting point for researching potential solutions and make a shortlist of tools that meet the requirements you and your team have decided are non-negotiable.
You’ll also need to make sure that the tools you choose integrate with your existing ecosystem. Remember to consider your source control tools like Git, planning tools like Jira, your collaboration environments, and so on.
Additionally, be mindful of the skills required for proper implementation and use and whether there’s a steep learning curve that may prevent teams from getting the desired results.
The easier your solution is to use, the faster the ramp-up time and the more accessible it will be to more people on your team—enabling better test coverage.
Have the team play an active role in evaluating the tools that make the shortlist. They should enable easy test creation and streamline existing workflows.
Set up Your Testing Environment
A stable, predictable environment is essential for effective test automation.
In many cases, unclean or poorly-organized environments are a barrier preventing organizations from introducing test automation earlier in the CI/CD pipeline.
As such, it’s essential to create a testing strategy that covers everything from internal workflows and communication processes to building a testing infrastructure that not only supports those efforts but makes them easier.
A few things to nail down:
- Identify requirements of the test environment. What will you need to support the use case and selected tools?
- Where will you store the data? What happens to it after testing?
- Consider using automated deployment tools as part of your CI/CD pipeline to help you maintain the test environments and generate them dynamically if needed.
Execute Your Test Case
At this point, it’s time to input the required test data and execute the scripts.
You can execute the scripts directly from individual tools or using test management software, which serves as a central hub for all testing activities and enables users to execute scripts across several machines at a time from any device.
Analyze the Results
Once you’ve executed your scripts, it’s time to analyze the results and share what you’ve learned with all relevant stakeholders.
The whole point of test automation is improving existing processes. So, before you get started, measure the results of your manual efforts. It will allow you to use them as a benchmark.
Metrics you might track:
- Customer satisfaction (CSAT, NPS, as well as unstructured feedback from reviews and communication records).
- Number of bugs/defects—does that number decrease over time?
- Productivity gains (number of deployments, velocity, hours worked, etc.)
- Time it takes to run end-to-end automated tests for every release cycle.
Whatever metrics you decide to track, the test automation framework needs to produce results that can be easily consumed and reported to stakeholders.
You’ll also want to map automated test scenarios to your application’s business logic of your application. This step will minimize the risk of producing false-positive results.
Implementing automated testing across a large share of the CI/CD pipeline is no small task. However, you can start small by implementing unit tests on specific processes and running those tests on a schedule.
New tools also make it easier for organizations of all sizes to automate testing and reap the benefits this strategy brings to the table—from faster release cycles and streamlined collaboration to happier customers and higher profits.