Plutora Blog - Test Case Management
Why Your Enterprise Software Testing is Failing and How to Fix ItReading time 5 minutes
Do you feel like everyone thinks your software testing team is the bottleneck slowing down development and delivery? Sixty-four percent of testers say time spent on side tasks and not doing actual testing is challenging.
Here are the reasons your enterprise testing is failing and how to fix it.
Poor Software Testing Productivity
Release cycles are speeding up as enterprise organizations strive to increase their agility through Agile and Continuous Delivery practices. While accelerating delivery has tremendous benefits, it exposes inefficient processes.
Software testing teams are finding that the manual process that used to be good enough can no longer keep up with the pace of delivery.
I’m not just talking about test automation; manual processes plague the entire software testing lifecycle. Communication, test management, documentation, and testing practices are all vulnerable to manual inefficiencies.
What’s Impacting Your Software Testing Productivity?
Here are the top things dragging down your enterprise software testing productivity.
Weak Test Prioritization
Are you prioritizing testing? How? Are you updating test prioritization based on feedback from development and testing?
Software development is an inherently unpredictable process, hence the popularity of Agile methodologies which focus on learning as you go and adapting. This is often confused with meaning that Agile teams are unpredictable. This is not the case. Bad Agile teams are unpredictable, as are bad Waterfall teams.
Focus on learning as you go. Adapting isn’t about giving up on being predictable; it’s about accepting that software development is unpredictable and must be managed as such to continually improve productivity. Whether you are Agile or not, learning as you go and adapting will improve the productivity of testing.
It is human nature to go after the low-hanging fruit, to get a few quick wins to show progress. Unfortunately, this just pushes off the hard stuff to later when you have less time to address the hard issues. It is more productive to tackle the hard stuff first, get it out of the way, and then start working on the easy stuff as time is running out.
You should prioritize testing the highest value and most risky stuff first. You should also not rely on your initial estimate of what the highest value and most risky things are. Feedback from Dev can help you focus on the right things first. Feedback from testing can help you even more. Defects tend to cluster, so as defects start popping up, reevaluate where you need to focus.
Poor Dependency Management
Perhaps software testing is so unpredictable and often unproductive because it relies on so many dependencies lining up. Of course, dependencies often do not line up and when mismanaged, result in unnecessary downtime. Software tests can be dependent on:
- Other tests
- Test data
- Test environments
- Development completion
- Quality of code
Productivity depends on understanding your team’s dependencies and how those dependencies are progressing, and managing those dependencies. For example, let’s say you have a team that is planning to test a feature that is three weeks behind schedule. You also have a testing team that is uncovering more defects than expected in a critical system. You should move resources from the project that is falling behind to the project that is more complex than expected.
That’s easy to say in this fairly straightforward example, but in the enterprise where multiple teams are working on multiple projects, it’s often not that easy. You have to have a process in place for tracking all your teams’ dependencies and highlighting the ones that may cause an impact.
This is difficult to do with spreadsheets or legacy testing tools, but a modern testing tool should provide you the traceability to track these dependencies.
You can’t be productive if you’re not communicating effectively. Email, calls, and meetings are ineffective forms of communication. A study described by the Harvard Business Review found that only a little more than half of the people were able to correctly ascertain the context and meaning of email.
Two studies found that humans consistently overestimate the ability of an email receiver’s ability to ascertain context, and that when we lack this information, we often fill in the gaps with stereotypes and potentially faulty guesses.
Even worse, research has found that only about half of your employees open internal communication emails. These studies make it clear that if you want your message heard and understood, you should find a channel other than email.
The ineffectiveness of email results in more meetings. Only 7% of information communicated comes from the actual words we are saying, according to Professor Albert Mehrabian at the University of California, Los Angeles (UCLA). The other 93% of communicated information comes through how we say the words, non-verbal cues, the tone of voice, context, and feedback.
Unfortunately, meetings tend to turn into a bunch of status updates because people aren’t getting the information they need from other channels. An hour-long meeting is a very inefficient way to get status updates.
Use a communication platform that captures everyone’s communications and stores them in a central location. Some teams may use tools such as Slack, while others may have collaboration built into their system. The important things are to ensure the tools your teams use to communicate are connected to the tools that planning stakeholders use.
As software releases become more frequent, we often find that the way we use to do things can’t keep up. Taking a fresh look at how you can help your team become more productive will ensure that software testing isn’t a bottleneck but rather a catalyst for delivering software faster.
Productivity is critical, but it is just one component of improving your overall enterprise software testing performance. Check out this blog on improving software testing predictability: How to Improve Enterprise Software Testing Predictability.