Bug Basics for Beginners: From Impact to Reporting in Jira

In the era of software development and testing, bugs are an integral part of everyday life. So, what exactly is a bug? A bug is an error or a flaw or an unexpected behavior that prevents the application or system from working as expected. Basically, it’s a discrepancy between the expected behavior and the actual behavior of the application. As testers, it’s our responsibility to find these bugs and at the same time to understand different types of bugs and report them effectively so the bugs can be fixed quickly.

Impact of Bugs Bugs are not always simple; they can cause serious impacts for both users and businesses. Some of the major impacts are:

·        Bad user experience

·        Drop in productivity

·        System crashes

·        Workflow disruptions

·        Time consuming processes

·        Delays in product release

·        High developmental costs

·        Loss of customers

·        Negative reputation for the company

·        Security issues

·        Risk of data loss and breaches

That’s why identifying and fixing bugs is an integral part of software testing. Because their impacts can be so serious, it is important to understand the different types of bugs.

Types of Bugs

Let’s have a look at the most common types of bugs testers encounter.

1.     Functional Bugs:

·        Functionality of the software or application is affected; a particular feature might not work.

·        Example: when the user clicks the “Register” button, nothing happens. 

2.     Performance Bugs:

·        Affects the performance of the applications such as speed or response time.

·        Example: a website takes 1 minute to load

3.     Compatibility Bugs:

·        The application will work in one environment but not in another. Not just environment, it can happen with different browsers, devices, operating systems etc.

·        Example: the application opens in Chrome but not in Firefox.

4.     Security Bugs:

·        The application can be breached or subjected to unauthorized access and risk while performing.

·        Example: Password is not masked while entering.

5.     UI/UX Bugs:

·        These are associated with design, layout etc. These may not affect performance but is not at all user friendly.

·        Example: Buttons are not aligned; texts are overlapping; fonts are too small/big etc.

6.     Integration Bugs:

·        Occurs when 2 or more components or APIs don’t work when combined.

·        Example: You updated the cart by adding the products, but on the payment page, the updated products are not showing.

7.     Logical Bugs:

·        Occurs when the feature in the application works but gives the wrong result due to bad logic.

·        Example: When you click the checkout button in the payment page, the system doesn’t show the correct total amount.

8.     Regression Bugs:

·        Happens after a new change in the software like a bug fix, update or addition of a new feature.

·        Example: You fixed the login button issue, but now logout button which was working previously stopped working.

9.     Workflow Bugs:

·        Occurs when a series of functions or steps doesn’t run in the expected flow.

·        Example: when you click checkout, the system asks for payment details but skips the address details and then directly displays the order confirmation.

10.  Unit-level Bugs:

·        As the name indicates, this bug is seen in a unit or a smallest piece of code.

·        Relatively, easy to fix.

·        Example: login is accepting empty username and passwords.

Why Bugs Happen?

Bugs can be caused by a single reason or a combination of reasons during the software development lifecycle. Below are some of the reasons:

·        Poor communication or miscommunication between team members.

·        No clear understanding about the requirements

·        Frequent changes in the requirements

·        Design flaws

·        Human errors

·        Poor coding

·        Shortage of time

·        Compatibility issues

·        Lack of quality assurance

·        Shortage of test environments or tools

·        Lack of proper testing methods

·        Regression issues

Why bugs should be reported?

Detecting bugs is only the tip of the iceberg. If the bugs are not reported properly, they cannot be reproduced and resolved. Bug reporting is an integral part of software development lifecycle. Here are a few reasons why bugs should be reported:

·        Improves overall software quality

·        Provides better understanding of errors

·        Time saving by avoiding ambiguity

·        Prevents recurrence of same errors

·        Ensures accountability

·        Builds improved team collaboration and rapport

How to write a good bug report in JIRA?

Jira is one of the most popular tools used in software development for bug reporting and tracking. Jira helps teams plan and track the work in a systematic way. It can be used for the entire software development cycle to reach the common goals set by the team.

In Jira, when you create a project, the board is created automatically. The board gives a visual representation of your works in columns named as ‘To Do’, ‘In Progress’ and ‘Done’ just like the screenshot given below. Additional columns also can be created. The items on the board can be a story, bug or a task.

Jira also allows to create an ‘Epic’ which represents a larger feature or piece of work. Under an epic, smaller tasks and bugs can be grouped and organized together across the ‘To Do’, ‘In Progress’ and ‘Done” columns. In the below screenshot, the board displays the epic names as well as the tasks.

Now let’s see how to create the bug in Jira

1. From the Jira homepage, we click ‘Create' from the top navigation bar.

2. A popup window opens up; choose the project where you want to log the bug.

3. Select the issue type as ‘Bug’.

4. Fill the Summary and Description tabs along with Steps to Reproduce; give clear detailed steps.

5. Add the Expected Result and Actual Result.

6. Select the Priority of the bug.

7. Add Labels, Environment and Attachments.

8. Optionally, add details such as Linked Issues, Issues, Assignee, Epic Link, Sprint.

9. Finally, click the ‘Create’ button.

Have a look at the below screenshots to visualize the above steps.

Now let’s jump into the main area, creating a bug report!

 Example of a Good Bug Report

Project: Shopping Cart Checkout

Issue Type: Bug

Summary: Login button not working on the login page

Description: the login button on the homepage is unresponsive. 

     Steps to Reproduce:

      1. Open the website (mention the website name)

       2. Click the ‘Login’ button on the top right of the homepage.

     Expected Result: 

     the user should be redirected to the login page to enter username and password

     Actual Result:

      the page is still the same, the ‘Login’ button is unresponsive.

Priority: High

Labels: Login, Critical, UI

Environment:

    Browser: Chrome v139 (Version 139.0.7258.68, 64-bit)

    Browser: Firefox v142 (Version 142.0.1, 64-bit)

    OS: Windows 11

Attachments: Screenshot of the error or video recording of the issue

Linked Issues: Choose one from ‘blocks’, ‘relates to’, ‘duplicates’

Issues: Not usually filled, can be filled as NA

Assignee: Mathew John

Epic Link: Shopping Cart Epic Sprint: Jan 15 – Jan 30

Conclusion

Bug reporting is not just about pointing out issues- it’s about communicating them clearly with the whole team faster and getting them fixed in a timely manner. A good bug report improves collaboration, saves time and money and ultimately can lead to delivering a high-quality final product.