Tips for Achieving Continuous Improvement in Software Testing
Success today means embracing continuous improvement, and your software testing process is no exception. Even if you already have a solid software testing operation in place, you should strive to find ways to make it better still.
In this article, I'd like to discuss one way of going about that by identifying five different ways to improve software testing. Some of these strategies involve organizational changes, while others are technical. All of them advance the goal of making testing faster, more efficient and more productive.
Optimization can happen on different levels
You will find optimization can happen on different levels — including code, technology, architecture, people, knowledge, and more. It's not unusual to recognize points where you require assistance and direction from experienced industry leaders. You will find numerous blog posts from thought leaders and gurus providing deep insight into software testing.
The following are my top five elements that can help optimize software testing.
#1 - Roles, responsibilities and a culture of quality
Roles and responsibilities could be the biggest challenges to efficient software testing. If some members of your team don't understand how their roles impact the software testing process, they're not in a good position to optimize the process.
Relatedly, your team members may lack a common understanding of what software quality means, and how testing supports it. This could simply be because they don't have prior experience with software testing, or it could be because your organization lacks a clear definition of what it prioritizes — performance, usability, accessibility, or something else — within "quality" software.
To solve this challenge, spend time communicating the vision, along with everyone’s quality roles and responsibilities, and how to optimize those roles and responsibilities. Creating a culture of quality ownership requires allowing time to share expectations and how to meet them, and ensuring that information is clear. (I wrote a great post about rethinking the “journey” in software testing, which can serve as an excellent starting point.)
#2 - Knowledge
Knowledge comes in several flavors, such as domain, application type, development, testing, technical, soft skills, and more. The key to success, in my opinion, starts with domain knowledge. How can anyone develop or test an application without the right amount of domain knowledge (such as banking, insurance, financial services, media, etc.)?
As an organization, you must understand how to invest in your resources, from new hire to seasoned employee, with documentation, continuous training, and setting smart goals.
Why do we need to optimize knowledge? Without the right understanding of testing, your overall processes, cost of testing, speed of development, feedback loop, and application consistency are affected. Creating a culture of quality requires time to evaluate everyone on the team to determine their testing knowledge level (from non-technical to technical).
Whatever technique you choose to build individual or team knowledge, a rule of thumb is: We need to invest in our resources as much or more than we invest in code optimization. A few ways to ensure this include:
- Training: internal and external
- Agreements: Create a service-level agreement for roles, responsibilities, and expectations
- Assessments: Conduct quality assessments to identify and eliminate dead code, bad practices, duplication, and process issues.
#3 - Duplication
You’re executing a series of steps that require a value to be used in more than one test. Is this duplication acceptable? There are ways to reduce the duplication of code and speed up updates or new development by centralizing the repetition into reusable code functions.
What does optimizing test code offer? It allows for a cleaner code base, better code readability, less technical debt, more manageable code maintenance, and leads to straightforward debugging with standards around code duplication.
#4 - Over-testing the system
Now let's get a little more technical, and talk about how "over-testing" can slow your software testing operation.
Is your release’s regression testing taking too long? It’s a common problem, and an area everyone should dedicate time to, with the goal of optimizing regression testing by eliminating it. (Yes, we need to remove the traditional way of testing release candidates, or at least dramatically reduce it.) We need to isolate each change and target the right tests to validate only release changes. But it doesn’t have to stop there. Think about implementing an automatic rollback process by monitoring production or using configuration flags (instead of a hotfix or automatic rollback), where it is possible to turn the feature on/off with a web-based application.
Why do we need to optimize over-testing of the system? The new, optimized process will subtract several minutes from the CI pipeline that is validating the release candidate, providing a faster feedback loop for developers, and only testing the changed code.
#5 - Speed
The three areas of speed for software testing are the creation of tests, continuous integration (CI), and a service-level agreement. Why do we need to optimize our software testing speed?
- The speed of software test creation starts with great user stories, acceptance criteria, best practices documentation, and a well-trained team that creates modular tests and keeps them simple.
- CI pipelines allow teams to be alerted more quickly when someone breaks something. Most importantly, you’ll be forced to plan out how to test code before the developer writes it. CI allows for running the more automated tests in parallel, which reduces the overall execution time. Take the time to improve your CI pipeline cadence.
- The service-level agreement (SLA) helps the organization reduce risk, define clear guidelines, and derive greater business value across the entire software development lifecycle.
You can always do better, no matter how well you're doing currently. In an organizational/cultural sense and a technical sense, there are likely changes that you can make to ensure that software testing is more efficient and leads to more accurate, more meaningful results.
Greg Sypolt, Director of Quality Engineering at Gannett | USA Today Network, maintains a developer, quality, and DevOps mindset, allowing him to bridge the gaps between all team members to achieve desired outcomes. Greg helps shape the organization’s approach to testing, tools, processes, and continuous integration, and supports development teams to deliver software that meets high-quality software standards. He's an advocate for automating the right things and ensuring that tests are reusable and maintainable. He actively contributes to the testing community by speaking at conferences, writing articles, blogging, and through direct involvement in various testing-related activities.
- Accessibility Testing
- Appium Resources
- Best Practices
- Continuous Delivery
- Continuous Integration
- Continuous Testing
- Cross Browser Testing
- Guest Blog Posts
- Load Testing
- Machine Learning
- Mobile Development & Testing
- News & Product Updates
- Open Sauce
- Open Source
- Performance Testing
- Product Updates
- Quality Assurance
- Quality Engineering
- Sauce Product Info
- Security Testing
- Selenium Resources
- Software Development & Testing
- The Story of Sauce