Indigo.Design announced the public preview of Indigo.Design App Builder.
Throughout the software development and delivery process, each team plays a pivotal role in ensuring that the end result is exactly what is needed. However, all too often the software testing team, who come in towards the end of the cycle, is labeled as a bottleneck that slows down the process. But it is always important to see both sides of an argument and understand the pressures put on the testing team.
The challenges are varied, but also point towards a more efficient future. In a recent survey by PractiTest and Tea-Time with Testers, 47 percent of test teams said they found coping with development timeframes very challenging.
Additionally, more involvement in the work of the company outside of testing was a big challenge to 41 percent of respondents, and 44 percent said team size was their biggest issue.
These top responses show the pressures facing test teams in a highly productive dev organization. But why are they feeling these pressures and how can it be fixed? These are the big questions that organizations should be asking themselves.
Poor Software Testing Productivity
Release cycles are speeding up as enterprise organizations strive to increase productivity 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. And although 85 percent of respondents indicated that their company uses automation, only 19 percent use automation for more than 50 percent of test cases.
These figures speak specifically to test automation, but manual processes plague the entire software testing lifecycle. Communication, test management, documentation, and testing practices are all vulnerable to manual inefficiencies.
What's Impacting Software Testing Productivity?
The first step to fixing testing bottlenecks is identifying exactly what is slowing down enterprise software testing productivity. The biggest areas that impact this are often weak test prioritization, poor dependency management and bad communication.
Weak Test Prioritization
How is testing prioritized? How is test prioritization being updated based on feedback from development and testing?
It is human nature to go after the low-hanging fruit, to get a few quick wins to show progress, and testing is no different. Unfortunately, this just pushes off the hard tests to later when there is less time to address any issues that arise.
In any situation, it is beneficial to prioritize testing the highest value and most risky pieces first. Also, not relying on initial estimates of what the highest value and most risky things are is important. Feedback from development can help teams focus on the right things first while feedback from testing can help guide the process as it moves forward. Remember, defects tend to cluster, so as defects start popping up, re-evaluate where the focus needs to be.
Poor Dependency Management
Part of what can make software testing unpredictable is the reliance on so many dependencies lining up at the same time. Of course, this often doesn't happen and when dependencies are mismanaged it can result in unnecessary downtime and a significant slowdown of the whole process.
Some of the things that software tests can be dependent on, include:
■ Other tests
■ Test data
■ Test environments
■ Development completion
■ Quality of code
Productivity depends on knowing a team's specific dependencies, understanding how those dependencies are progressing, and managing those dependencies.
Mapping out and managing dependencies is fairly straightforward to talk about, but in an enterprise where multiple teams are working on multiple projects, it's often not that easy. There needs to be a process in place to track all teams' dependencies and highlight the ones that may cause an impact.
This is difficult to do with spreadsheets or legacy testing tools, but a modern testing tool that includes testing design, planning, manual and automated execution, defect tracking, and progress reporting into a single interface should provide the traceability to track these dependencies.
Nobody can be productive if they are not communicating effectively. Email, calls, and meetings are ineffective forms of communication.
In fact, a study 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.
Additionally, it has been 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 employees open internal communication emails. These studies make it clear that to get a message heard and understood, email is not the right channel.
The ineffectiveness of email results in more meetings. Only 7 percent 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 percent 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.
So, it's important to use a communication platform that captures everyone's input and stores it 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 the teams use to communicate are connected to the tools that planning stakeholders use.
As software releases become more frequent, the way things used to be done is just not keeping up. Productivity is critical, but it is just one component of improving overall enterprise software testing performance. Taking a fresh look at how teams can work better together will ensure that testing isn't a bottleneck, but rather a catalyst for delivering software faster.