Getting everything ready for you…

Loading courses, problems and your progress. This takes just a moment.

0s

Guides › Software Testing & QA

Bug Reporting and Defect Life Cycle

Learn how to report software bugs, write effective defect reports, understand severity and priority, track defect life cycles, and follow QA best practices.

Bug Reporting and Defect Life Cycle

Bug reporting is an essential skill in software testing and quality assurance. When an application behaves differently from its requirements or expected behavior, testers need to document the issue clearly so that developers can reproduce, investigate, and fix it.

A well-written bug report saves time, improves communication, and helps teams deliver more reliable software.

In this guide, you will learn what bugs and defects are, how to write effective bug reports, understand the defect life cycle, distinguish severity from priority, use bug-tracking tools, and practice with real-world examples.

Table of Contents

  1. What Is a Bug?
  2. Bug vs Defect vs Error vs Failure
  3. What Is Bug Reporting?
  4. Why Is Bug Reporting Important?
  5. Anatomy of a Good Bug Report
  6. How to Report a Bug Step by Step
  7. Bug Report Template
  8. Real-World Bug Report Examples
  9. Defect Life Cycle
  10. Defect Statuses Explained
  11. Severity vs Priority
  12. Bug Tracking Tools
  13. Bug Triage and Prioritization
  14. Common Bug Reporting Mistakes
  15. Bug Reporting Best Practices
  16. Practical Exercises with Solutions
  17. Interview Questions and Answers
  18. Frequently Asked Questions
  19. Conclusion

1. What Is a Bug?

A bug is a problem in software that causes the application to behave differently from its intended or specified behavior.

Bugs can affect functionality, performance, security, compatibility, accessibility, or the user interface.

Examples of Software Bugs

Not every unexpected behavior is necessarily a software defect. First compare the observed behavior with the requirements and agreed expectations.

Types of Bugs

Functional Bug: A feature does not work as required.

Example: Clicking Add to Cart does not add the selected product.

UI Bug: A visual element appears incorrectly.

Example: A button overlaps another element on a supported screen size.

Performance Bug: The application does not meet its performance requirements.

Example: A search request takes longer than the agreed response-time target under the specified workload.

Compatibility Bug: The application behaves incorrectly in a supported browser or device.

Security Bug: A weakness allows unauthorized access, data exposure, or another security violation.

Usability Bug: An interaction is confusing or difficult to complete.

Data Integrity Bug: Information is lost, duplicated, or incorrectly stored.

Integration Bug: Connected components or services do not exchange or process information correctly.

2. Bug vs Defect vs Error vs Failure

These terms are related, but they describe different concepts.

Error

A human mistake made while understanding, designing, coding, or configuring a system.

Example: A developer uses the wrong calculation formula.

Defect

A flaw in a requirement, design, code, or other software artifact.

Example: The source code contains an incorrect calculation.

Bug

A commonly used informal term for a software defect.

In everyday QA work, "bug" and "defect" are often used interchangeably.

Failure

An observable situation in which the software does not perform a required function.

Example: The application displays the wrong total when a customer checks out.

Simple Relationship

A human error may introduce a defect, and that defect may cause a failure when the affected software executes under particular conditions.

However, not every error causes a defect, and not every defect causes an observable failure in every situation.

3. What Is Bug Reporting?

Bug reporting is the process of documenting a software issue so that the development team can understand, reproduce, investigate, and resolve it.

A bug report should describe:

Example

Suppose a user clicks the Login button after entering valid credentials, but the page displays an unexpected error.

A useful report includes the login page, test environment, steps to reproduce, expected behavior, actual behavior, and a screenshot or relevant log.

A report that only says "Login is broken" is not sufficiently detailed for efficient investigation.

4. Why Is Bug Reporting Important?

4.1 Clear Communication

A report provides a shared description of the issue for testers, developers, product managers, and other stakeholders.

4.2 Faster Reproduction

Precise steps help developers reproduce the issue without repeatedly asking for missing details.

4.3 Better Prioritization

Severity, priority, affected users, and business impact help teams decide what to address first.

4.4 Traceability

Bug-tracking systems maintain issue status, ownership, comments, related commits, and resolution history.

4.5 Improved Software Quality

Tracking defects helps teams identify recurring problems and improve development and testing processes.

4.6 Better Release Decisions

An accurate defect summary helps stakeholders understand known issues and remaining risks before a release.

5. Anatomy of a Good Bug Report

A bug report contains several useful fields. The exact template depends on the team and tracking tool.

5.1 Bug ID

A unique identifier generated by the tracking system.

Example: BUG-1042.

5.2 Title

A short, specific description of the problem.

Poor title: "Cart problem."

Better title: "Cart total does not update after quantity increases."

5.3 Environment

Records where the issue occurred.

Examples:

5.4 Preconditions

Conditions required before reproducing the issue.

Example: A test user is logged in and an available product is in the cart.

5.5 Steps to Reproduce

The ordered actions that cause the problem.

Steps should be specific and repeatable.

5.6 Expected Result

What should happen according to requirements.

Example: The cart total should update based on the selected quantity.

5.7 Actual Result

What happened during the test.

Example: The displayed total remains unchanged after the quantity increases.

5.8 Severity

The impact of the defect on the application or users.

5.9 Priority

How urgently the issue should be addressed.

5.10 Reproducibility

Indicates whether the issue occurs consistently, intermittently, or only under specific conditions.

5.11 Evidence

Useful supporting material can include:

Evidence should help explain the issue without exposing passwords, access tokens, or sensitive user information.

5.12 Status and Assignee

The status describes the issue's current workflow state. The assignee identifies the person or team responsible for investigating it.

6. How to Report a Bug Step by Step

Follow this process when you discover a possible defect.

Step 1: Confirm the Expected Behavior

Review the requirement, acceptance criteria, design, or documented behavior.

If the requirement is unclear, ask for clarification rather than assuming the application is wrong.

Step 2: Reproduce the Issue

Repeat the steps to confirm that the behavior can be observed.

Record any conditions that affect reproduction.

Step 3: Check the Environment

Note the application build, browser, operating system, device, and other relevant details.

Step 4: Check for Existing Reports

Search the bug tracker to determine whether the issue has already been reported.

If it is a duplicate, link it to the existing issue according to team policy.

Step 5: Write a Specific Title

Describe the affected feature and observable problem.

Example: "Password reset link remains usable after successful password change."

Step 6: Document Reproduction Steps

Write numbered steps that another tester or developer can follow.

Avoid vague instructions such as "use the website normally."

Step 7: Define Expected and Actual Results

Describe the difference between the required behavior and what was observed.

Step 8: Assess Severity and Priority

Estimate the impact and urgency based on available evidence and team guidelines.

The final priority may be decided during defect triage.

Step 9: Attach Evidence

Add screenshots, recordings, logs, or relevant request details when useful.

Sanitize confidential data before sharing.

Step 10: Submit and Track the Report

Assign or route the issue according to the team's workflow.

Respond to follow-up questions, help reproduce the issue, and update the report when new information becomes available.

Step 11: Retest the Fix

When a fix is provided, repeat the original steps and verify the expected behavior.

Step 12: Perform Regression Testing

Check related functionality to ensure that the fix has not introduced another issue.

7. Bug Report Template

Use this template to create a bug report.

Copyable Template

Bug ID: [Generated by tracking tool]

Title: [Short, specific description]

Environment: [Application version, browser, OS, device]

Preconditions: [Required setup]

Steps to Reproduce:

  1. [First action]
  2. [Second action]
  3. [Third action]

Expected Result: [Required behavior]

Actual Result: [Observed behavior]

Severity: [Critical / High / Medium / Low, according to team definitions]

Priority: [Urgent / High / Medium / Low, according to team definitions]

Reproducibility: [Always / Sometimes / Rarely / Unable to Reproduce]

Evidence: [Screenshot, recording, logs, or link]

Assignee: [Responsible person or team]

Additional Notes: [Relevant context]

Tips for Using the Template

8. Real-World Bug Report Examples

Example 1: Login Failure

Bug ID: LOGIN-BUG-001

Title: Login fails with valid credentials on the staging website

Environment: Staging website, Chrome browser, current test build

Preconditions: An active registered test account exists.

Steps to Reproduce:

  1. Open the login page.
  2. Enter the valid test email.
  3. Enter the correct test password.
  4. Click Login.

Expected Result: The user should reach the dashboard.

Actual Result: An unexpected error appears and the user remains logged out.

Severity: Major, depending on the scope of affected users.

Priority: High if login is a critical user journey.

Evidence: Attach a sanitized screenshot and relevant error details.

Example 2: Shopping Cart Total

Bug ID: CART-BUG-002

Title: Cart total does not update after product quantity increases

Environment: Staging website, supported desktop browser

Preconditions: A product is available and already added to the cart.

Steps to Reproduce:

  1. Open the shopping cart.
  2. Record the displayed quantity and total.
  3. Increase the product quantity.
  4. Review the updated total.

Expected Result: The total updates according to the product price, quantity, and applicable charges.

Actual Result: The quantity changes, but the displayed total remains unchanged.

Severity: Potentially major because it affects price information.

Priority: High if checkout calculations may be affected.

Evidence: Attach a screenshot showing the quantity and total.

Example 3: UI Alignment Issue

Bug ID: UI-BUG-003

Title: Submit button overlaps the consent text on a supported mobile screen

Environment: Staging website, supported mobile browser, specified screen size

Preconditions: The registration page is open.

Steps to Reproduce:

  1. Open the registration page on the affected device or viewport.
  2. Scroll to the consent section.
  3. Observe the consent text and Submit button.

Expected Result: The consent text and button should remain readable and usable without overlap.

Actual Result: The button overlaps the consent text.

Severity: Low to medium depending on whether the overlap prevents registration.

Priority: Depends on affected users and release requirements.

Evidence: Attach a screenshot showing the affected viewport.

Example 4: Duplicate Order Submission

Bug ID: ORDER-BUG-004

Title: Repeated submission creates duplicate orders

Environment: Authorized checkout test environment

Preconditions: A valid test cart exists and the test payment method is configured.

Steps to Reproduce:

  1. Prepare an eligible test order.
  2. Submit the order using the approved test flow.
  3. Repeat the submission under the documented test conditions.
  4. Inspect the resulting order records.

Expected Result: The system should prevent unintended duplicate orders according to its idempotency and submission rules.

Actual Result: Two orders are created for what should be one purchase.

Severity: Potentially critical or major, depending on financial and operational impact.

Priority: Usually high if the behavior is confirmed and affects users.

Evidence: Include sanitized test order identifiers and timestamps.

Only perform this test in an authorized environment using approved test payment methods.

9. Defect Life Cycle

The defect life cycle is the sequence of workflow states an issue may move through from reporting to resolution.

A common workflow is:

  1. New
  2. Assigned
  3. In Progress
  4. Fixed
  5. Retest
  6. Closed

Some teams also use statuses such as Reopened, Rejected, Duplicate, Deferred, or Cannot Reproduce.

There is no single mandatory workflow used by every organization.

Stage 1: New

The tester submits a defect report.

The issue is reviewed to check whether it contains sufficient information and appears to describe a valid problem.

Stage 2: Assigned

The issue is assigned to a developer, QA engineer, or responsible team for investigation.

Stage 3: In Progress

The responsible person investigates the cause and works on a solution.

The issue may require clarification, additional evidence, or collaboration with other teams.

Stage 4: Fixed

A code or configuration change has been made and the fix is ready for verification.

A status of Fixed does not automatically mean QA has confirmed the issue is resolved.

Stage 5: Retest

The tester repeats the original reproduction steps in an appropriate build and environment.

If the expected behavior is restored, the tester can proceed according to the team's workflow.

Stage 6: Closed

The defect is marked resolved after the required verification and approval.

If the issue still occurs, the tester may reopen it instead of closing it.

Simplified Workflow

New → Assigned → In Progress → Fixed → Retest → Closed

Possible alternate paths:

These paths depend on the defect-tracking process.

10. Defect Statuses Explained

New

A defect has been reported but not yet fully reviewed or assigned.

Assigned

An owner has been identified.

In Progress

Investigation or implementation work is underway.

Fixed

A change intended to resolve the defect has been completed.

Retest

QA is verifying whether the fix resolves the reported problem.

Reopened

The issue still occurs, or the original behavior has not been correctly restored.

Closed

The required verification is complete and the issue is considered resolved.

Rejected

The report has been determined not to represent an actionable defect under the team's rules.

The reason should be documented.

Duplicate

The same underlying issue has already been reported in another ticket.

Link to the existing report where possible.

Deferred

The team has decided to postpone addressing the issue.

The remaining risk and reason should be recorded.

Cannot Reproduce

The issue could not be reproduced under the conditions tested.

Before using this status, the team may need to gather more information, compare environments, or investigate intermittent behavior.

11. Severity vs Priority

Severity and priority are important but different concepts.

Severity describes how seriously a defect affects functionality, data, security, or users.

Priority describes how urgently the team should address it.

Severity Levels

Exact definitions differ between organizations.

Critical: A major service is unavailable, serious data corruption occurs, or a severe security issue is confirmed.

High: Important functionality is significantly affected.

Medium: Functionality is partially affected, or a workaround may exist.

Low: A minor issue has limited impact.

Priority Levels

Urgent: Immediate attention is required.

High: The issue should be addressed soon, often within the current release process.

Medium: The issue should be scheduled according to available resources and risk.

Low: The issue can usually wait until higher-impact work is completed.

Example Comparison

Severity Priority Example
High High Checkout is unavailable to many users
High Lower Serious issue in a rarely used legacy feature
Low High Typo in a critical launch announcement
Low Low Minor spacing issue in a low-traffic area

These are illustrative combinations, not universal classifications.

A cosmetic issue can have high priority if it affects a major public announcement. A serious issue in a rarely used feature might be scheduled differently, depending on risk and obligations.

12. Bug Tracking Tools

Bug-tracking tools help teams record issues, assign owners, track progress, and maintain a history of decisions.

Jira

Commonly used for issue tracking, workflows, assignments, comments, and reports.

GitHub Issues

Useful for tracking defects and tasks associated with software repositories.

GitLab Issues

Supports issue tracking and collaboration within GitLab development workflows.

Azure Boards

Provides work-item tracking and development workflow capabilities.

Linear

Used by teams to organize issues, priorities, and development work.

Spreadsheet-Based Tracking

A spreadsheet may be sufficient for a small learning project, although it becomes harder to manage as the number of issues grows.

What to Include in a Bug Tracking System

Choose tools according to the team's needs, workflow, and access-control requirements.

13. Bug Triage and Prioritization

Bug triage is the process of reviewing reported defects and deciding how they should be handled.

Participants may include QA engineers, developers, product managers, project managers, and other stakeholders.

What Happens During Triage?

  1. Confirm that the report is understandable.
  2. Check whether the defect is reproducible.
  3. Look for duplicate reports.
  4. Evaluate severity and user impact.
  5. Determine urgency and priority.
  6. Identify the responsible team.
  7. Decide whether to fix, defer, reject, or investigate further.
  8. Record the decision and relevant reasoning.

Factors That Affect Priority

A defect's priority should be based on evidence and agreed criteria rather than personal preference.

14. Common Bug Reporting Mistakes

Vague Titles

Poor: "Website not working."

Better: "Product search returns no results for an existing product name."

Missing Reproduction Steps

Developers may be unable to reproduce the problem.

Solution: Provide numbered, specific actions and necessary preconditions.

Unclear Expected Results

A report may not explain what the application should do.

Solution: Reference the relevant requirement or state the expected behavior precisely.

Missing Environment Details

An issue may occur only in a specific browser or build.

Solution: Record relevant version and environment information.

Incorrect Severity or Priority

Overstating or understating impact can delay important work.

Solution: Use team definitions and explain the observed impact.

Duplicate Reports

Multiple tickets can fragment investigation and reporting.

Solution: Search existing issues before creating a new report.

Unsupported Assumptions

A tester may assume a behavior is a bug without checking requirements.

Solution: Confirm the expected behavior and separate facts from assumptions.

Missing Evidence

Useful screenshots or logs may be absent.

Solution: Attach relevant evidence when it helps reproduce or understand the issue.

Sensitive Information in Reports

Screenshots may contain passwords, tokens, personal details, or confidential data.

Solution: Use test data and sanitize evidence before sharing.

Closing Without Retesting

A defect may be marked resolved without confirming the fix.

Solution: Follow the agreed verification and closure process.

15. Bug Reporting Best Practices

  1. Write a short, descriptive title.
  2. Provide reproducible steps.
  3. Include relevant preconditions and test data.
  4. State expected and actual behavior separately.
  5. Record the environment and build.
  6. Include screenshots or logs when useful.
  7. Use severity and priority consistently.
  8. Search for duplicates before reporting.
  9. Keep comments objective and professional.
  10. Update the ticket when new evidence appears.
  11. Retest fixes in an appropriate environment.
  12. Perform regression checks where needed.
  13. Document deferred issues and unresolved risks.
  14. Protect credentials and confidential information.
  15. Follow the team's defect workflow.

16. Practical Exercises with Solutions

Exercise 1: Write a Bug Report

A tester finds that the cart total does not update when product quantity increases.

Suggested Solution:

Title: Cart total does not update after quantity increases.

Preconditions: An available product is already in the cart.

Steps:

  1. Open the cart.
  2. Record the current quantity and total.
  3. Increase the quantity.
  4. Observe the displayed total.

Expected Result: The total updates according to the quantity and applicable pricing rules.

Actual Result: The total remains unchanged.

Severity/Priority: Assess after confirming the impact on displayed pricing and checkout.

Evidence: Attach a screenshot or recording.

Exercise 2: Identify the Status

A developer has fixed an issue and QA is checking the new build.

Which status might apply?

Solution: Retest, if that is the status used by the team's workflow.

Exercise 3: Retest Failure

The developer marks a defect Fixed, but the original problem still occurs.

What should QA do?

Solution:

  1. Confirm the correct build and environment.
  2. Repeat the original reproduction steps.
  3. Record the observed result.
  4. Attach evidence.
  5. Reopen the defect or return it to the appropriate state.
  6. Explain why the fix did not meet the expected behavior.

Exercise 4: Severity or Priority?

A minor typo appears on the main launch page a few minutes before a major public release.

How might severity and priority be classified?

Solution: Severity may be Low because the issue is cosmetic, while priority may be High because the page is highly visible and the release is imminent. The actual classification depends on team policy.

Exercise 5: Duplicate Bug

You discover that a colleague has already reported the same underlying issue.

What should you do?

Solution: Verify that the reports describe the same issue, then link to or mark the new report as a duplicate according to the team's process. Add any new reproduction details to the existing report when appropriate.

Exercise 6: Cannot Reproduce

A bug occurs intermittently, but you cannot reproduce it during a short retest.

Should you immediately reject it?

Solution: No. Record the conditions tested, investigate relevant logs and timing, and gather additional evidence. Intermittent defects may require more investigation before the team decides how to classify them.

17. Interview Questions and Answers

Q1. What is bug reporting?

Bug reporting is the process of documenting a software defect so that the responsible team can reproduce, investigate, and resolve it.

Q2. What should a good bug report contain?

It should include a descriptive title, environment, preconditions, reproduction steps, expected and actual results, severity, priority, and useful evidence.

Q3. What is the defect life cycle?

It is the workflow a defect follows from reporting through investigation, resolution, verification, and closure.

Q4. What is the difference between severity and priority?

Severity describes the impact of a defect. Priority describes how urgently it should be addressed.

Q5. What does Reopened mean?

It means the issue has not been resolved as expected or the problem still occurs after a proposed fix.

Q6. What is a duplicate defect?

A duplicate defect is an issue that has already been reported in another ticket.

Q7. What is bug triage?

Bug triage is the review process used to assess defects, decide priorities, assign ownership, and determine next steps.

Q8. What should QA do after a defect is fixed?

QA should verify the fix using appropriate reproduction steps and perform relevant regression testing.

Q9. What is the difference between a bug and a failure?

A bug is commonly used to describe a software defect. A failure is the observable incorrect behavior that occurs when the system does not meet an expected requirement.

Q10. Can a low-severity bug have high priority?

Yes. A cosmetic issue may require urgent attention if it affects a critical release or highly visible user experience.

Q11. What should happen if a bug cannot be reproduced?

Record the conditions tested, gather more evidence, investigate possible environmental or timing differences, and follow the team's workflow before deciding the final status.

Q12. Why are screenshots useful in bug reports?

They can show the observed behavior and help the team understand the issue. However, screenshots may need logs or reproduction steps to provide enough evidence.

18. Frequently Asked Questions

Is bug reporting part of manual testing?

Yes. Reporting and tracking defects are common responsibilities in manual testing and broader QA work.

Is a bug always caused by a developer's coding mistake?

No. Defects can originate in requirements, design, code, configuration, integration, or other parts of a system.

Can a bug be closed without a fix?

Some teams close or disposition issues as Duplicate, Rejected, or Deferred. The reason should be recorded, and the status should accurately represent the decision.

Who decides bug priority?

The decision depends on the organization's process. QA, development, product, and project stakeholders may contribute.

What is the difference between Retest and Regression Testing?

Retesting checks whether a particular defect has been fixed. Regression testing checks whether changes have affected existing functionality.

Should every bug report include a screenshot?

No. Screenshots are helpful when they provide evidence, but API issues, backend defects, and some technical problems may require logs, requests, or other evidence instead.

What is the best bug tracking tool for beginners?

Start with a tool that lets you create issues, document reproduction steps, set status, and track progress. A spreadsheet may work for a small learning project; larger projects often use a dedicated issue tracker.

How can I practice bug reporting?

Use an authorized demo application, identify a reproducible issue, compare the observed behavior with its requirements, and write a complete report using the template in this guide.

19. Conclusion

Bug reporting is more than describing something that does not work. It is a structured communication process that helps teams reproduce problems, understand their impact, prioritize fixes, and verify solutions.

To improve your bug reporting skills, practice writing precise titles, clear reproduction steps, measurable expected results, and accurate descriptions of actual behavior.

Learn the defect life cycle, understand severity and priority, use a bug-tracking tool, and always retest fixes before marking them resolved.

These skills are essential for manual testers, QA engineers, and anyone working to improve software quality.

More guides