Open In App

Jira Bug Life Cycle

Last Updated : 19 Sep, 2023
Like Article

The life cycle of a bug refers to the stages that an issue goes through within the Jira issue tracking system. Jira is a used tool, among software development teams for managing and resolving issues such as bugs, enhancements, and tasks. The bug life cycle in Jira typically consists of stages each serving its own purpose and involving specific actions.

Below I will provide an overview of the bug life cycle in Jira explain each stage in detail and include a diagram to visually illustrate the process.


Jira Bug Life Cycle

Stages of Jira Bug Life Cycle:

1. Open/New:

When a bug is reported it enters the system as an “Open” or “New” issue. At this stage, the issue has been. Has not yet been assigned or prioritized. In the phase called the “stage a bug is essentially just an observed issue or problem that has been reported. These reports can come from sources such, as end users, testers, customer feedback, or automated testing tools. During this stage certain characteristics become important:

  • Bug Report Creation: A detailed report is created which contains information about the symptoms of the bug how it affects the software, where it was observed and any necessary steps to reproduce the issue.
  • Severity and Priority: At this stage severity and priority are often assigned to the bug. Severity indicates how much impact the bug has on the functionality of the software (critical major minor) while priority determines how urgently it needs to be fixed (e.g. high, medium-low).

2. Assigned:

The bug is then assigned to a developer or team to resolve it. This assignment indicates that someone is actively working on addressing the issue. The assigned developer or team actively works on fixing the bug during this stage. Activities may include investigating the problem identifying its root cause and developing a solution.

Moving on to the stage in which a developer or development team takes charge of addressing the bug. Key aspects include:

  • Assignment: The bug is allocated to a developer or team based on factors like their expertise in that area of development their availability and current workload.
  • Ownership: The assigned developer takes ownership of the bug. Becomes responsible for resolving it. They carefully review the bug report in order to fully understand both its nature and its impact.

3. Open

The “Open” phase is when the developer starts analyzing and working on the bug. It involves aspects:

  • Analysis: The developer thoroughly examines the bug report carefully reviewing the steps to reproduce it checking the environment details and attempting to replicate the issue in their development setup.
  • Identifying the Root Cause: The developer investigates what’s causing the bug by going through resources, like codebase, database, logs, and other relevant information.
  • Planning: Based on their analysis the developer creates a plan for fixing the bug. They determine what changes are needed in the code to resolve the issue effectively.


Once the developer believes they have fixed the bug the issue moves into the testing or review stage, for evaluation. This may involve conducting unit testing undergoing peer review and engaging in quality assurance practices. After a testing and review process the bug is labeled as “Resolved” or “Fixed.” This signifies that the issue has been resolved and the suggested solution is prepared for verification.

Finally comes a stage where the developer has made necessary changes, in code to address and rectify the identified bug. Some important aspects to consider are:

  • Modifying the Code: The developer makes the adjustments, to the code in order to fix the bug. This can involve rectifying errors tweaking configurations or implementing any required modifications.
  • Testing while Fixing: In the process of making code changes developers may also conduct unit tests to verify that their modifications are functioning correctly and not introducing any issues.

5. Retesting

Once the bug has been fixed the testing team carries out a round of retesting to confirm if the issue has indeed been resolved. During this retesting process the focus is, on the bug in question isolating it from the broader software environment. If it is confirmed that the issue has been resolved the bug moves forward to the stage. However, if it is found that the problem persists it is. Sent back to the developer for attention. Once the bug is fixed it’s time for testing teams role, in verifying that resolution. This involves aspects:

  • Focused Testing: Testers perform tests specifically targeting the fixed bug. They follow steps used to reproduce it and check if it no longer exists.
  • Regression Checks: During retesting testers ensure that fixing one issue hasn’t caused any problems or negatively affected parts of the software.

6. Reopened:

In cases we can reopen the bug. Then it goes back, to being “In Progress” or “Testing/Review.” Reopening a bug is crucial to ensure that no issue is overlooked prematurely. If after fixing a bug it still persists or introduces issues then it gets reopened for consideration:

  • Detailed Reassessment: The testing team conducts an analysis to gain insights, into the reasons, behind the reappearance of bugs or the emergence of issues.
  • Communication: A continuous loop of communication exists between the testing team and developers to discuss any problems encountered during retesting.

7. Verified:

After a retest where it’s determined that the bug has truly been resolved it is labeled as “Verified.” This indicates that the solution has been validated and assures us that there are no longer any traces of this bug in the software. Once a fix for a bug has been confirmed through retesting it undergoes verification. The main aspects of this verification process include:

  • Confirmation: The testing team confirms that not was the bug fixed but also ensures that it no longer affects or impacts any functionality within the software.
  • Documentation: Any pertinent details regarding this verification are documented for reference and record keeping purposes.

8. Closed:

When we validate and confirm that the fix meets all criteria set by our team, we mark the bug as “Closed.” This indicates that the problem has been resolved and is now considered closed for the phase of development. However even though a resolved bug may no longer be active it could still be referred to for reasons or future problem-solving purposes. Finally we reach closure with regards to resolving and addressing this bug through its stage:

  • Resolution Confirmation: A thorough review of all steps undertaken throughout this process ensures that everything was followed correctly and completed as required.
  • Documentation: It is practice to summarize information about both the bug its resolution steps are taken and details about its verification process for proper documentation, within project records.
  • Communication: Depending on the way the organization operates they may send a notification, to the stakeholders to inform them that the bug has been officially resolved.

Like Article
Suggest improvement
Share your thoughts in the comments

Similar Reads