If you're using agile methodologies, it’s likely that:

• You're a CTO, Development Manager, or Senior Developer, and
• You spend a majority of your time actually managing your development team’s workflow

Today, I'll share four ways that software teams can adapt current agile practices to make bug resolution easier and faster.

Allocate time in sprints for fixing errors and prevent bug overwhelm

If a development team pushes code into production and relies on tests and a QA processes before deployment, it could be falling on your customers to find and report problems they encounter.

Unfortunately independent research found that only 1% of users actually report issues.

The best thing we can do to prevent revenue loss from errors is to have processes in place to both find and respond to errors before users even notice. How do most companies achieve this?

Rigorous testing before deployment is certainly one of the best ways to maintain a company culture of producing quality code at all times.

Buggy software means customers are having a poor experience – and as team leaders it’s our job to make sure that doesn’t happen.

We can make the process a little easier by using our agile processes together with a continuous deployment strategy. For example, our friends at Raygun, discovered that “when a team gets locked into a sprint it can become much harder to recognize and fix bugs”.

We actively avoid locking all but the lowest priority errors into sprints – rather we have time set aside inside our sprints to allow us to find errors and fix them on the spot. This way, it doesn’t affect our sprint work, and issues get addressed as soon as they come up, rather than waiting for an end user to find them.

The most important takeaway is to always keep your code deployable. By always keeping your master branch matching your production code, you can fix a bug and deploy knowing that other ongoing fixes and features aren’t creeping into a bug fix deployment.

Improve communication between support and dev teams to keep customer relations strong

Errors do slip through the cracks. Understanding how best to manage these errors and the customers who become affected is an important part of the error handling process.

It’s not always easy for developers to replicate issues for customers so they can be fixed quickly. So sometimes errors do get lost in communication.

This is especially true for last minute fixes and changes. When we ‘tweak’ code, inadvertently introducing errors becomes much more likely. Especially when there are strict deadlines to be met.

Keeping your whole team looking at the bigger picture (from coding right through to how the user is experiencing the software) helps the dev team communicate with support so they can get information to customers quickly and effortlessly.

Get as much contextual information on errors as possible for faster fixes

In agile methodology, traditionally bugs may appear on issue tracker backlogs or within your agile management tool as tickets/tasks.

When tickets get assigned, the error can remain unsolved until deeper diagnostics on the issue are discovered.

Getting full contextual information on an error is extremely difficult unless you have crash and error reporting software.

Hands down, this is the biggest time saver and the best way to resolve errors in your current agile methodology.

Most crash and error reporting software will pull extremely detailed information on location and damage caused by errors that slip through the testing process. Using a tool like Assembla to deliver that information to a team member cuts the time in the communication process.

If you have allocated time in your sprint to errors rather than locking in fixes, there’s still hard work to be done by your team. However, having the correct tools in your toolkit will greatly improve.

Prioritize fixes (without leaving out the non critical bugs)

Because of the flexible nature of agile practices, lots of small, last minute changes can be introduced into a developer’s workflow.

This usually means two things:

• Common bugs make repeat appearances (meaning minor recurring bugs get through the cracks);
• Bug fixes can become stagnant under high priority tasks.

Unfortunately, recurring bugs and ‘minor’ fixes are still affecting end users – someone is still getting a poor experience of your application.

Staying on top of the errors inside your agile workflow is critical – which comes back round to practicing test driven development.

Every bug is a chance to build a test. If you find a bug, write a test! This prevents recurring bugs and keeps the culture of producing quality code in your team strong.