How to Use Spike Notes as a Bug Tracker for Software Teams

Modern software is complicated, really complicated. It requires layers of tech and numerous teams to bring any software to market, and having such a complex process with so many people involved opens up the opportunity for errors and mistakes to creep in.

This is where bug tracking comes in! Also called defect tracking or issue tracking, it is the process whereby these errors are logged, monitored, and fixed during software development. It is an essential part of software project development, ensuring that everything is running as expected, without fault or issues. As such, software teams need robust, reliable tools to help them keep track of bugs and get them resolved as quickly and efficiently as possible.

We’re going to take a look at the key elements of building a good bug-tracking workflow before exploring how Spike Online Notes can be used for bug tracking in your software team.

Building a Bug-Tracking Workflow

Bugs are bad, but also normal, so don’t think that building out a solid bug-tracking workflow is “aiming for failure” – it is a vital part of ongoing software development. When building out a good bug-tracking workflow, you need to think about three things: evaluating, prioritizing, and managing.

Evaluating Bugs

We’ll start with evaluation since this is the first step to prioritizing and managing bugs. In software development, it comes down to severity, i.e. the impact a bug has on the software. It can be classified in numerous ways but generally falls into a structure such as:

• Catastrophic (S1). total failure of the software – it does not work. For example, the software crashes on start-up.
• Critical (S2). A business-critical feature is impacted, making the software as a whole not up to standards.
• Major (S3). The overall software is still usable, but the bug significantly impacts the application.
• Minor (S4). A bug that does not affect critical systems but causes unwanted behavior. User Interface bugs will often fall here if they don’t impede a user’s ability to operate the software.
• Trivial (S5). There is a workaround, or there is little to no visible impact of the bug.

Prioritizing Bugs

Priority is probably more familiar to most people and will generally fall into:

• High (P1). The bug must be fixed as soon as possible.
• Medium (P2). The bug should be fixed during the normal scheduled development.
• Low (P3). This bug can be fixed when/if developers have time.

Having both severity and priority may seem redundant (surely all Catastrophic bugs are also High Priority?) but they are actually vital for a good bug-tracking workflow. They allow the software team to develop a priority/severity matrix by which to judge and sort incoming errors at the start of their bug tracking.

For example, when a bug is submitted by the testing team, it could fall into one of several categories:

High Priority, High Severity

High Priority, Low Severity

High Severity, Medium Priority

Etc.

While it is true that most High Severity bugs will also be High Priority, it’s not always the case. For example, if a bug is discovered that crashes the software, this would be considered “Catastrophic”. However, if it only happens when a very specific, unlikely, series of commands is given, it might be classified as “Medium Priority” so the development team can focus on more pressing issues. Similarly, there could be a bug that is “Trivial” on the surface (e.g., the wrong image is shown on a website) but is actually very “High Priority” (that image is a sponsor’s logo).

Managing Bugs

So, you can evaluate and prioritize, now it’s time to look at how to manage your software team’s bug tracking! Each bug has a lifecycle and will go through several stages, from when it is reported to when it is no longer an issue. The exact stages will depend on your team but will generally look like:

• Active: The bug is being investigated & classified using your priority/severity matrix.
• Active (with priority/severity): A team member is working on the fix.
• Test: The bug has been fixed and needs to be tested.
• Ready to commit: Testing has shown that the bug is fixed or is no longer an issue.
• Closed: Any necessary patches have been committed, and the ticket for that bug is closed.

Bugs may go through the first few steps in the process several times before finally being closed, or it may be a simple fix that’s done in a jiffy. The most important thing to figure out is how you’re going to manage bugs as they move through this process. That’s where bug-tracking software comes in, and Spike Notes can be used for just that.

What Are Spike Notes?

Spike Online Notes are private or collaborative notes accessed right from within your inbox. You can create, edit and share notes without leaving your inbox, making for a fast, efficient and productive workflow.

Online Notes can be accessed anywhere, anytime, with any one of your devices thanks to them being automatically saved and synced across mobile, desktop, and the web. They can be used for anything, from a simple personal shopping list to a self-syncing shared board to map and manage entire projects.

Thinking beyond just text, Online Notes allows you to add images, videos, files, and code snippets so you can record your thoughts, ideas, and actions in a way that works for you. What’s more, Online Notes have been built with collaboration in mind – you can share a note with anyone, whether or not they use Spike, and then create and edit in real-time with your team.

To stay on the same page, Online Notes have chat and comments built in so you can collaborate seamlessly. What’s more, you can add to-dos and set reminders, with notifications automatically sent to the top of your Inbox, so you always know what’s happening.

Can Spike Notes be Used for Bug Tracking?

Spike Online Notes are a versatile solution for numerous personal and business needs, and in the right hands, can be used for bug tracking in a couple of different ways. How you use Spike Notes to track, manage and deal with your bugs will depend on several factors such as your existing workflow, size, and product stage.

Spike Notes could be used for bug tracking by creating one note for each incoming bug. This note would then contain written information on the specific error, screenshots of any visual manifestations of the bug, and any relevant files attached. The bug could then go through your priority/severity matrix, using tags to classify where the bug falls. Once this is established, you can add the relevant team members to the note, assigning it to whoever can fix the issue.

If the bug doesn’t need to be dealt with immediately, you can set a notification for some time in the future or get on with the fix by quickly chatting to your colleague from within the note itself. As the bug passes through the various stages, you can edit the tags to keep track while passing it to different team members to do their part (from a developer to Q&A, for example).

Alternatively, you could use one collaborative Spike Note to manage all incoming bugs. You could simply create a note, add the relevant developers and testers, then using Spike’s rich text features create a running list of bugs, their urgency, where they’re at in their lifecycle, and all the relevant information. Within the note, developers and testers can discuss each bug in real-time while updating its status via a simple and easy-to-use interface.  Here’s a sample template we’ve created.

These are just two of the possible methods for bug tracking using Online Notes – part of the beauty of Spike Notes is the flexibility they offer to set up your management workflow in a way that suits you.

What’s more, Online Notes are just one of the numerous features in Spike that can help your software team’s productivity and overall workflow. From built-in Video Meetings to simple Voice Messages and Spike’s powerful email tools, this all-in-one productivity software can help far beyond bug tracking for any software team.