Best Agile Strategies for Managing Bugs and Feature Requests

Introduction

According to many seasoned software developers, bug-free software doesn’t exist. As annoying and frustrating as bugs can be, they are an integral part of software development, which is why it’s so crucial to know how to manage them effectively.

Strategies for managing bugs and feature requests must keep up with the rapid evolution of development methodologies and knowledge of testing practices. Simply put, agile mobile app developers and web app developers need agile strategies for managing bugs and feature requests, which is exactly what this article is all about.

The cost of bugs

On a small scale, we perceive bugs as annoyances that slow down software development and leave users with a negative impression of the product. But when we zoom out, the real cost of bugs becomes obvious. According to a report issued by the Austrian software testing firm Tricentis, software failures cost the worldwide economy over $1 trillion annually, which is about as much as the GDP of South Korea.

What’s more, the report found out that software failures have caused more than 315 years of lost time and have affected approximately 4.4 billion customers. Software failures also have a massive negative impact on the reputation of companies. The companies surveyed by Tricentis lost an average of $2.3 billion of shareholder value just on the first day after announcing a software failure. No wonder that so many companies keep quiet about bugs.

If we zoom back in, we can see that bugs become more expensive to fix the longer it takes to uncover them. According to IBM, bugs found after product release are 4 to 5 times costlier than bugs uncovered during the design phase, and as much as 100 times costlier than those identified in the maintenance phase.

When companies get stuck with outdated strategies for managing bugs and feature requests, they risk releasing buggy software and paying the steep price for it. The good news is that teams can now enjoy greater flexibility than ever when adding features, making changes, and checking for bugs thanks to Agile’s incremental approach to software development.

Agile strategies for managing bugs

If you’re familiar with the traditional waterfall approach to software development, you know that scope on waterfall projects is rigidly managed and not flexible at all. On the other hand, agile software development is all about change and achieving customer satisfaction with frequent iteration.

Instead of fitting outdated strategies for managing bugs and feature requests into an Agile model of development, it’s recommended to start with an Agile strategy from the get-go.

Make your bugs visible

“Keeping a database of bugs is the hallmark of a good software team,” believes Joel Spolsky, CEO of Stack Overflow. While it’s entirely possible to track bugs using Microsoft Excel, the benefits of using a bug tracking and issue tracking system are too great to ignore.

Many Agile teams live inside Pivotal Tracker, an Agile project management tool with support for real-time collaboration around a shared, prioritized backlog.

Pivotal Tracker integrates with leading issue tracking solutions, including:

• Redmine – a free and open source project management and issue tracking tool that allows users to manage multiple projects and associated subprojects,
• Bugsnag – a stability monitoring solutions that makes it easier to decide whether you should be building features or fixing bugs,
• Bugzilla – a widely used defect-tracking system originally developed and used by the Mozilla project and licensed under the Mozilla Public License.

A good bug tracking and issue tracking system ensures that known bugs are fixed by allowing companies to keep a record of detected bugs, brings the whole team together by providing better communication through chat interfaces, allows end users to report bugs and make feature requests directly on their applications, and, above all else, makes it easy to prioritize bugs and assign issues.

Prioritize your bugs

When Agile teams allow the backlog of reported bugs to grow organically, it can spiral out of control and become completely unmanageable. That’s why it’s paramount to prioritize bugs, and do it the right way.

Typically, bugs are prioritized according to their priority (P), which is based on business needs, and severity (S), which indicates the degree of negative impact on the quality of software. Bugs with the highest priority and the highest severity are critical and must be resolved first, while bugs with the lowest priority and the lowest severity don’t need immediate attention.

• Critical bugs cause complete failure of a feature and don’t have a workaround. They must be fixed as soon as possible, typically within 24 hours. Bugs that cause significant memory leaks are sometimes classified as a priority -1, which means that they prevent the entire software from functioning.
• High-priority bugs affect major features or major data, and they may or may not have a workaround. If a workaround is available, it’s difficult to implement or is not obvious. All high-priority bugs should be resolved before the release is made, but only after all critical bugs are fixed.
• Medium-priority bugs affect minor functionality or non-critical data, and there may even be simple workarounds. Sometimes, even cosmetic errors are classified as P3 bugs, depending on how severely they affect the overall user experience. It’s not necessary to resolve all medium-priority bugs before the release is made, but they should be resolved only after all high-priority bugs are fixed.
• Low-priority bugs have no effect on functionality or data. They are merely small inconveniences, such as spelling errors and layout discrepancies, that can be fixed in the future and don’t need immediate attention.

Conclusion

Agile isn’t just about speed. It’s about speed and quality. To deliver quality software faster, teams need the right strategies for managing bugs and feature requests, such as those outlined in this article. Modern bug tracking and issue tracking systems play an important role as well, bringing visibility and making it easy to prioritize bugs and assign issues.

Resources

• http://servicevirtualization.com/report-software-failures-cost-1-1-trillion-2016/
• http://blog.celerity.com/the-true-cost-of-a-software-bug
• https://www.joelonsoftware.com/2000/11/08/painless-bug-tracking/