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
- What Is a Bug?
- Bug vs Defect vs Error vs Failure
- What Is Bug Reporting?
- Why Is Bug Reporting Important?
- Anatomy of a Good Bug Report
- How to Report a Bug Step by Step
- Bug Report Template
- Real-World Bug Report Examples
- Defect Life Cycle
- Defect Statuses Explained
- Severity vs Priority
- Bug Tracking Tools
- Bug Triage and Prioritization
- Common Bug Reporting Mistakes
- Bug Reporting Best Practices
- Practical Exercises with Solutions
- Interview Questions and Answers
- Frequently Asked Questions
- 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
- A login form accepts invalid credentials.
- A shopping cart displays an incorrect total.
- A search feature fails to display matching products.
- A button does not respond when clicked.
- A page crashes when a user submits a form.
- An application exposes information to an unauthorized user.
- A website layout breaks on a supported mobile screen.
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:
- What went wrong.
- Where the issue occurred.
- How to reproduce it.
- What should have happened.
- What actually happened.
- How seriously it affects users.
- Any relevant evidence.
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:
- Staging environment.
- Application build or version.
- Browser and version.
- Operating system.
- Device and screen size, when relevant.
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:
- Screenshots.
- Screen recordings.
- Sanitized application logs.
- Console errors.
- Network request details.
- Relevant timestamps.
- Test data identifiers.
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:
- [First action]
- [Second action]
- [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
- Fill in fields that are relevant to the issue.
- Avoid inventing details that have not been verified.
- Keep reproduction steps focused.
- Separate observed facts from assumptions.
- Follow your team's severity and priority definitions.
- Never include credentials or secrets in plain text.
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:
- Open the login page.
- Enter the valid test email.
- Enter the correct test password.
- 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:
- Open the shopping cart.
- Record the displayed quantity and total.
- Increase the product quantity.
- 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:
- Open the registration page on the affected device or viewport.
- Scroll to the consent section.
- 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:
- Prepare an eligible test order.
- Submit the order using the approved test flow.
- Repeat the submission under the documented test conditions.
- 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:
- New
- Assigned
- In Progress
- Fixed
- Retest
- 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:
- Retest → Reopened → In Progress
- New → Duplicate
- New → Rejected
- New → Deferred
- Retest → Cannot Reproduce, after appropriate investigation
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
- Unique issue ID.
- Title and description.
- Reproduction steps.
- Expected and actual results.
- Severity and priority.
- Status and assignee.
- Environment.
- Evidence.
- Related requirements or code changes.
- Comments and resolution history.
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?
- Confirm that the report is understandable.
- Check whether the defect is reproducible.
- Look for duplicate reports.
- Evaluate severity and user impact.
- Determine urgency and priority.
- Identify the responsible team.
- Decide whether to fix, defer, reject, or investigate further.
- Record the decision and relevant reasoning.
Factors That Affect Priority
- Number of affected users.
- Impact on critical business workflows.
- Security and privacy risks.
- Data integrity.
- Availability of a workaround.
- Release deadlines.
- Frequency of occurrence.
- Dependencies on other features.
- Regulatory or contractual obligations.
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
- Write a short, descriptive title.
- Provide reproducible steps.
- Include relevant preconditions and test data.
- State expected and actual behavior separately.
- Record the environment and build.
- Include screenshots or logs when useful.
- Use severity and priority consistently.
- Search for duplicates before reporting.
- Keep comments objective and professional.
- Update the ticket when new evidence appears.
- Retest fixes in an appropriate environment.
- Perform regression checks where needed.
- Document deferred issues and unresolved risks.
- Protect credentials and confidential information.
- 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:
- Open the cart.
- Record the current quantity and total.
- Increase the quantity.
- 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:
- Confirm the correct build and environment.
- Repeat the original reproduction steps.
- Record the observed result.
- Attach evidence.
- Reopen the defect or return it to the appropriate state.
- 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.
Related Guides
- Software Testing: Complete Beginner to Advanced Guide
- Manual Testing: Complete Guide with Examples
- Software Testing Life Cycle (STLC): Complete Guide
- How to Write Test Cases: Examples and Templates
- Functional vs Non-Functional Testing
- Automation Testing: Complete Beginner Guide
More guides
- How to Use Codify: A 7-Day Start Plan — New here? Pick a roadmap, make a study plan, start the DSA sheet, revise with notes, practise for placements and test yourself — one step a day, then a daily routine.
- Infosys Preparation Guide: Online Test, Pseudocode and Interview — Roles (SE, DSE, SP), what each section of the Infosys online test checks, how to crack pseudocode and reasoning, a 4-week plan and the interview.
- Wipro Elite NLTH Preparation: Aptitude, Essay and Coding — The Wipro fresher test round by round — quant, logical and verbal, the written essay, two coding problems — plus a 3-week plan and interview tips.
- Accenture Preparation Guide: Cognitive, Technical, Coding and Communication — Every Accenture round explained — cognitive, MS Office/networking/cloud technical MCQs, pseudocode, coding and the spoken-English test — with a 4-week plan.