Understanding What is Bug Life Cycle in Manual Testing

One of the most popular stories about the origin of the term "computer bug" relates to engineers from Harvard University who found that a moth stuck in the relays of the Mark II computer caused its malfunction.

Although this incident happened in 1947, the use of the word "bug" to describe the factor causing an incorrect result actually predates the era of electronics. Anyway, the life cycle of a computer bug is much different from the life cycle of an insect.

What is the bug life cycle in manual testing, and does it differ from the bug life cycle in automated testing?

Read this article and find answers to these questions.

Bug life cycle and its common stages in manual testing

The bug life cycle or the defect life cycle is an integral part of the manual testing routine, and it can be viewed as a multi-step process starting from bug identification to resolution. Below, you can learn more about the common steps of the bug life cycle.

1.   New

• The life cycle of a software defect starts from its identification by a tester, who then creates a bug report containing detailed instructions on reproducing the bug as well as the expected and actual results.

2.   Assigned

• When the report is ready, it is handed over for review to a designated person, for example, the team lead. After the review, this person further assigns the bug to a developer or an entire team, who will be responsible for fixing this defect. As a result, the bug is labeled as "assigned."

3.   Open

• When the designated person or team starts their work on resolving the issue, the bug gets the label of "Open."

4.   Fixed

• Once the developer or team finds a potential solution for the issue, they mark the defect as "fixed." At this stage, it is necessary to add the information on the code changes to the bug report. In this way, the bug is ready for retesting.

5.   Retest

• The retest step is required to verify whether the proposed issue resolution is indeed effective. Often, based on the retest results, testers mark the bug as either "Retest Passed" or "Retest Failed." The latter occurs if the proposed solution is not effective and the bug has to be reopened. Otherwise, the reopened stage is omitted, and the testing team moves to the Closed step.

6.   Reopened

• A retest failure of a bug requires assigning the issue back to the developer, who has to further investigate the issue and look for its resolution. The retest report provided by the testing team can supply the developer with useful information, which will guide them through the process of researching additional fixes and adjustments.

7.   Verified

• If the issues identified during the retest stage are resolved, and the effectiveness of proposed changes has been confirmed by the testing team, the bug is labeled as "Verified."

8.   Closed

• The bug is regarded as closed when the proposed defect resolution has been verified as effective. The resolution should be clearly documented.

Additional steps of a bug cycle

What is the bug life cycle in manual testing? As you can see, it is a sequence of stages involving defect identification, the search for the solution, retesting, and verification. However, there are many scenarios when the basic bug life cycle stages described above are expanded by additional steps. Here are some of them:

●     Pending review

• Often, the proposed solution for a bug has to be reviewed by a designated team member before it reaches testers. While the solution is still waiting for its review, the bug can be labeled as "Pending Review."

●     Reassigned

• Sometimes the developer who worked on the bug resolution is not available, or the bug might be handed over to another team. In this case, the bug should be marked as "Reassigned."

●     NMI (Need More Information)

• NMI is the abbreviation for Need More Information, which is a label used for a bug lacking sufficient information in its report and cannot be understood by the developer responsible for its resolution properly. In this case, the testing team is supposed to provide further information on the bug.
• Another common label used in similar scenarios is "Not Reproducible." Yet, the latter label is also used in scenarios when gathering more information on the bug is not possible.

●     Deferred and Known Issue

• Many teams enforce test prioritization to optimize their work and may refrain from resolving a certain issue right after its identification. In this case, the defect can be labeled as "Deferred" while its resolution is postponed for investigation during the preparation for a future release. It is also common to mark a deferred bug as a "Known Issue."

●     Duplicate

• The "Duplicate" label is used to mark issues that have already been reported more than once, aiming to avoid redundancy.

●     Withdrawn

• Not all of the reported issues are necessarily addressed. Sometimes, the reported behavior has been achieved intentionally by the development team and should not be resolved. In this case, the reported issue is often labeled as "Withdrawn" or "Closed by Design."

A bug life cycle: manual testing vs. automated testing

A bug life cycle is very similar to a bug life cycle in automated testing, especially when it comes to its stages. However, the ways some of the stages are executed can differ a lot.

Here are some of the major aspects of managing the bug life cycle in automated testing, which differentiate this process from manual testing:

• Automated and therefore faster bug identification and reporting;
• Enhanced bug reproducibility due to automated tests designed to be repeatable;
• High efficiency in repetitive and rule-based testing tasks like regression testing and ineffectiveness in detecting certain types of context-specific and complex issues that require human supervision;
• Requires updates to adapt to changes in the tested software or testing requirements;
• Usually featured with a substantial initial investment and has great potential for fast ROI.

Bottom line - what is the bug life cycle in manual testing?

The bug life cycle in manual testing is a well-structured and systematic process that guides testers and developers from bug identification to resolution and helps them optimize bug management.

Both basic steps and additional stages typical for manual testing are also used in automated testing. However, in this case, many of them are handled automatically, significantly speeding up the bug life cycle. On the other hand, certain tasks still have to be performed manually.