These days every company is software-centric one way or another. If you’re not building apps or portals for your customers, at the very least you’re probably developing tools to help your employees work more efficiently. That means that as a business, you’re under constant pressure to develop new software, push out new releases and give your internal and external stakeholders what they want.
All of this creates a need for speed. Software development has to be a fast process so that you’re able to quickly get new products to market or update existing ones so that they remain competitive. And while everyone can agree that it’s important to be timely, the reality is that rushing to delivery can be a costly mistake. If you fail to adequately test your software, for example, you can wind up with bugs in production that have the potential to completely undermine your business.
The Pitfalls of Delivering Too Soon
Production bugs can be the Achilles’ heel of any organization. In the best scenarios, they result in minor glitches or inconsistencies that your end users may never even notice. In the worst-case scenarios, by contrast, they can degrade the customer experience, erode consumer confidence and ultimately have a negative impact on revenue. Of course, rushing software into production only increases your chances of bugs slipping by.
“When testers aren’t given the time to understand the impact of changes, it can have disastrous consequences,” says Adam Satterfield, a 20-year veteran of the quality assurance industry. “Just take a look at high-profile examples like Knight Capital Group to see what can happen if you don’t fully comprehend the downstream effects of the changes you’re making in the rush to push a new release out the door.”
In 2012, Knight Capital lost $440 million in a single day as a result of a glitch in the trading software it had just installed. The glitch led the firm’s computers to “rapidly buy and sell millions of shares in over a hundred stocks for about 45 minutes after the markets opened,” according to reports from The New York Times. The trades drove up the value of the stocks, which led to massive losses when the company had to sell them back into the market at a lower share price. The experience so imperiled the once-thriving trading firm that it was ultimately acquired the following year.
Of course, bugs in production can lead to all kinds of problems. Customers can be locked out of their accounts. E-commerce platforms can fail to process millions of dollars in transactions. Airline system outages can wreak havoc in airports and strand thousands of passengers. The result in any of these scenarios is lost revenue, reputational damage and a PR nightmare.
And it’s not just that bugs slip by testers when you rush to production. They’re more likely to fester in code that’s been written too quickly. That’s because rushed code is often more complex than it needs to be, making it a breeding ground for issues.
Let’s Not Jump the Gun
To avoid scenarios like these, it’s important to have controls in place to help ensure that software is adequately tested prior to release. Satterfield recommends adopting a risk-based approach that looks at both the probability of a particular issue and at the potential impact that it could have on the business. He suggests measuring the overall risk, using a five-point scale.
“It’s a helpful technique not just for directing QA teams in terms of where they should focus their attention, but also for communicating risks to the rest of the business,” he says. “It takes the emotion out of the equation and gives testers a quantitative way in which to approach business leaders about potential issues so that they can reach an informed decision about whether or not to delay a release.”
Another effective tactic companies can use is ensuring that only their quality assurance teams have the ability to push code into production. Doing so eliminates the possibility of developers accidentally pushing out new software that hasn’t been properly tested. Satterfield says he’s seen organizations reduce their production bugs by as much as 60 percent just by taking that one simple step.
It’s also important to make sure that your company views production issues as a team sport. Everyone from the product owner to the developer and tester needs to feel a sense of responsibility for creating the best software possible. Practically speaking, that means that while QA owns quality, everyone is responsible for bugs. This is a small but critical change because it can shift your company culture from one where QA takes all of the blame to one in which everyone feels a greater sense of empowerment and trust.
Fostering Transparency and Alignment
For everyone in your organization to be aligned about the importance of testing and not rushing software to delivery, there needs to be a high level of transparency about what’s going on. At small startups with just a handful of scrum teams, transparency is pretty easy to maintain. Teams are generally more closely knit, and communicating potential issues often requires little more than a walk down the hallway.
At larger organizations, on the other hand, the best way to foster transparency and alignment is by having the right tool in place to ensure that everyone has access to the data they need. Having quick, automatic access to the right data ensures that people stay well informed about what’s going on. Better still is when teams define their strategic needs within a QA platform, ideally one which integrates with the application lifecycle management tool your development team is using, to foster alignment. Both of these tactics can go a long way toward helping ensure that everyone from the C-Suite down is on the same page and that critical bugs never find their way into production.
While speed is imperative in today’s competitive market, without quality it will get you nowhere fast. When it comes to developing software, it’s better to let QA do its job than to simply rush your product out the door.
Tricentis’s solutions help embed testing within the development lifecycle and create a continuous feedback loop with developers, which helps testers catch bugs earlier, eliminate testing bottlenecks and balance speed with quality.