Skip to content
99tests Blog

Bugs Report Template with Fields, Steps and Examples

Copy this bugs report template with reproduction steps, expected and actual results, environment fields and evidence for web and mobile teams.

Bugs Report Template with Fields, Steps and Examples
In this article
  1. Copy-Ready Bugs Report Template With Core Fields
  2. Fields that deserve an explicit answer
  3. How to Write Steps and Expected Versus Actual Results
  4. Preserve state-changing actions
  5. Filled Example Report for One Bug
  6. Identification and setup
  7. Execution and evidence
  8. Environment Fields for Web and Mobile Bug Reports
  9. State the tested scope honestly
  10. Severity, Priority and Confidence Grading Rubric
  11. Grade impact without inventing certainty
  12. Preserve the grading decision
  13. Evidence and Duplicate Checks Before You File
  14. Check for an existing issue
  15. Reporting AI-Generated and Unexecuted Test Cases
  16. Add fields that establish execution
  17. Assign a status without upgrading assumptions
  18. Common Template Mistakes and How to Fix Them
  19. Separate diagnosis from observation
  20. Review in separate passes
  21. Run the Template on Your Next Build
  22. Execute the matrix and preserve the comparison

Duplicate rates exceeded 25% for both VS Code and Thunderbird in the GitBugs dataset study of more than 150,000 reports across nine open-source projects. A report can describe a genuine failure and still give the team no new work to act on. The useful question isn't just what broke, but what was executed, under which conditions, and what the evidence establishes.

A bugs report template should capture that execution record. It should let a developer repeat the test, distinguish observations from assumptions, and understand how much of the affected environment has been checked. A template can't guarantee reproduction or identify the root cause, but it can make missing evidence visible before triage begins.

Copy-Ready Bugs Report Template With Core Fields

FieldWhat to enterExample
IdentificationSearchable identity and gradingIllustrative checkout defect
IDTracker-generated number linked to the test caseBUG-2041, linked to CHK-014
TitleOne sentence naming the feature, the condition and the symptomCheckout does nothing after coupon applied on Android 14
SeverityImpact if the defect exists, graded against the rubricCritical
PriorityUrgency and scheduling set by the release ownerP1 before release
ReproductionSetup, actions and observationsRecorded execution
PreconditionsAccount state, app version and data needed before step 1Logged-in test account; app 5.4.2; one eligible item in cart; coupon SAVE20 active
StepsNumbered, one user action per line, with exact values1. Open cart.
2. Enter SAVE20.
3. Tap Apply.
4. Tap Pay.
ExpectedThe behavior the specification or prior version promisesDiscount applied and payment screen opens
ActualWhat was observed, with error text copied verbatimSpinner for 10 seconds, then no response and no error shown
Repro rateHow many attempts reproduced the failure5 of 5 attempts
EnvironmentConfiguration actually testedNamed target and build
EnvironmentStructured device, OS, browser, network and localeGoogle Pixel 8; Android 14; native app 5.4.2, build 5420; browser not applicable; Wi-Fi; en-IN
EvidenceInspectable execution artifactsAttachments stored with the ticket
EvidenceScreenshot, screen recording, log or minimal test caseCheckout recording and timestamped logcat excerpt attached
TrackingOrigin and verification historyTraceable test outcome
Test case IDThe case from the plan that produced the findingCHK-014
First seen buildEarliest build where the failure appeared5.4.0, build 5412
Verification statusReproduced, not reproduced, intermittent or not tested, with verifier nameReproduced by QA lead Maya on 2 devices; configurations recorded

The values above are a hypothetical example, not findings about an actual application. Copy the table into Jira, Linear, a spreadsheet or a test management tool, then replace every example with execution facts. In a spreadsheet, split the environment components into separate columns so they're filterable.

The title names the feature, condition and symptom. It doesn't assert that the coupon service or payment gateway caused the failure. That restraint keeps the ticket useful before anyone has investigated the implementation.

Fields that deserve an explicit answer

Repro rate needs a numerator and denominator, not just an always label. First seen build means the earliest affected build you've observed, not necessarily the build that introduced the defect. Verification status records what another tester established, rather than repeating the reporter's confidence.

For localized form testing, resources such as Kiwiform's multilingual lead generation forms provide context for cases where language is part of the setup. Record the selected form language and application locale separately rather than assuming they're identical.

The separation of steps, actual behavior and expected behavior follows Mozilla's bug-writing guidance. Keep these fields distinct even if your tracker combines them inside one description.

Copy the template for an open bug. Ask a colleague unfamiliar with the application to follow it without a spoken explanation, and record every clarification they need.

How to Write Steps and Expected Versus Actual Results

In a 2023 study of 180 reproducible Android bug reports mined from GitHub, 92% didn't include all steps required to reproduce the failure. Even a report associated with a reproducible bug can omit essential setup or actions.

Write the sequence as an executable procedure, not a recollection of the testing session.

  1. Write preconditions first. Specify the installed build, login state and required test data. Don't hide account setup inside an instruction to open checkout.
  2. Use one action per numbered line. Name controls exactly as the interface labels them. An instruction to complete checkout conceals the actions the developer needs to repeat.
  3. Include exact input values. Record the coupon, search term or selected option. If sensitive data is involved, provide an authorized test fixture rather than a real customer's details.
  4. Stop where the failure first appears. Remove unrelated actions only after checking that the shorter sequence still reproduces it. A long navigation history isn't automatically a necessary reproducer.
  5. State the expected result independently. Identify the specification, acceptance criterion or confirmed previous behavior that establishes the expectation. Don't turn a personal preference into a requirement.
  6. Describe the actual result without diagnosis. Copy visible error text verbatim. If nothing happens, say which screen remains visible and whether a spinner, message or navigation appeared.
  7. Read the procedure as a stranger. Replace vague references to some data with the actual fixture. Replace works sometimes with a counted result, such as a hypothetical failure in three of ten attempts.

This visual summarizes the sequence from setup to comparison.

A numbered guide for writing bug reports, detailing steps from setting preconditions to comparing expected and actual results.

Preserve state-changing actions

Suppose a dashboard fails only after a second login. The procedure must include the first successful sign-in, sign-out, return to the login screen and second sign-in with the specified account. Starting from the second sign-in assumes the state that triggers the defect.

Practical rule: Minimize the steps, but never minimize away the condition that makes the bug happen.

When assessing inherited codebases and release reliability, Grail Computer Labs provides a useful broader context for examining engineering quality. A precise reproduction record contributes something concrete to that assessment: another engineer can check behavior without relying on the original tester's memory.

Filled Example Report for One Bug

Consider this hypothetical completed report. Its build identifiers, timings and outcomes illustrate what a filled ticket should look like.

Identification and setup

  • Title: Checkout does nothing after coupon applied on Android 14.
  • ID and source case: BUG-2041, from CHK-014.
  • Build history: Executed on app 5.4.2, build 5420; first observed on 5.4.0, build 5412. Introduction point not established.
  • Severity: Critical under the team's rubric because payment can't complete and no viable workaround was found in the tested workflow.
  • Priority: P1 before release, assigned by the release owner.
  • Preconditions: Logged-in test account, one eligible cart item, active SAVE20 coupon and en-IN locale.

Execution and evidence

  1. Open cart.
  2. Enter SAVE20 in the coupon field.
  3. Tap Apply.
  4. Tap Pay.

Expected: The discount is applied and the payment screen opens, as required by the checkout acceptance criterion.

Actual: A spinner appears for 10 seconds, then disappears. The cart remains visible, with no response and no error shown.

  • Reproduction rate: 5 of 5 attempts on Google Pixel 8.
  • Environment: Pixel 8, Android 14, Wi-Fi, en-IN; native app, browser not applicable; battery saver off.
  • Evidence: Attached 0:42 screen recording and timestamped logcat excerpt, associated with this execution.
  • Verification: QA lead Maya reproduced it on Pixel 8 and Pixel 7, both running Android 14 and build 5420. Verification date: 2026-02-12.
  • Confidence and scope: High confidence in the observed failure; platform-wide impact not established.

The developer can identify which build, which actions, how often and which targets without asking the reporter. The report still doesn't claim to know why payment failed.

Environment Fields for Web and Mobile Bug Reports

An environment note that says fails on Android doesn't identify a rerunnable configuration. It also overstates the scope if the reporter tested only a particular handset.

Record the configuration as structured fields. That lets a verifier match the original setup and a release manager distinguish tested targets from assumptions.

PlatformRequired fields
Android phoneManufacturer, model, Android version, app build, network type, locale
iPhoneModel, iOS version, TestFlight or App Store build, Low Power Mode state
Desktop browserBrowser name and exact version, OS and version, screen size, zoom level, extensions state
Web appFull page path, account type, permissions granted, viewport width

For Android, the manufacturer and model distinguish hardware targets that share an OS version. For iPhone testing, record the installed build rather than only the marketing version, and capture whether Low Power Mode was enabled.

A desktop browser's screen size isn't the same as its viewport. Browser chrome, zoom and window dimensions can change the available layout area, so capture the actual viewport when investigating responsive behavior. For web apps, record the page path without exposing access tokens or sensitive query parameters.

State the tested scope honestly

Across platforms, include network conditions, battery saver state, account state and permissions. A denied permission or expired session can change the result without any change to the application binary.

Use a bounded statement:

Observed on Google Pixel 8 with Android 14 under the recorded account and network conditions. Other Android targets have not been tested.

Keep these outcomes separate:

  • Not reproduced: The specified procedure was executed, but the failure didn't occur.
  • Not tested: No execution evidence exists for that target.
  • Reproduced intermittently: The failure occurred during some recorded attempts, with the attempt count preserved.

A nearby control helps isolate the scope. Run the same case on another device or browser while keeping the build, account and input constant, then record both outcomes. Don't call the control a pass if the tester couldn't complete the procedure.

The guide to testing an app on real devices helps teams plan those target-specific checks. When device access is limited, document the missing targets instead of expanding a narrow observation into a platform-wide claim.

Missing configuration fields give the developer a legitimate reason to return the ticket for clarification.

Severity, Priority and Confidence Grading Rubric

LevelMeaningExample
BlockerPrevents core use, release or test executionApp crashes on launch for all users
CriticalCrash, data loss, security or payment failure, or no viable workaroundPayment fails on iOS 18 for every card type
MajorImportant function materially brokenSearch returns no results on Firefox for Windows only
MinorLimited functional degradation with a workaroundSort order resets after page refresh
TrivialCosmetic or wording issueButton label reads Submited

These are proposed operational definitions, with illustrative examples, not a universal grading scheme. IEEE 1044-2009 establishes a uniform approach to classifying software anomalies but doesn't prescribe a required report format. Publish your team's definitions so reporters and verifiers apply the same criteria.

Severity measures impact if the defect exists. Priority measures urgency and scheduling. The release owner can prioritize a visible wording error without pretending that it causes functional damage.

The diagram separates those judgments from confidence.

An infographic defining the differences between severity, priority, and confidence when grading software bug reports.

Grade impact without inventing certainty

Use an observable acceptance test for each grade. Ask whether the failure prevents the workflow, whether a viable workaround exists, and which tested configurations are affected.

A payment failure confined to a browser version may still be critical if affected users can't complete payment. Conversely, reproducing a cosmetic defect on every tested target doesn't make it a blocker. Scope and frequency inform the decision, but neither substitutes for impact.

Record confidence separately. A high-impact failure observed during a single execution deserves attention, but its impact doesn't prove repeatability. Confidence should reflect the strength of the evidence and remaining uncertainty, not whether the tester feels sure.

Preserve the grading decision

Keep the following beside the grade:

  • Reproducibility and scope: Attempt counts and affected configurations.
  • History: Regression status, first observed build and known workaround.
  • Traceability: Duplicate linkage and reporter or test-session identity.
  • Verification: Verifier, verification date and retest evidence.

At 99tests, we grade severity against a published rubric with a confidence score. When a verifier changes a tester's grade, the report records the change and why it was made.

That explanation matters when someone later compares release results. A grade lowered because a workaround was confirmed means something different from a grade lowered because the original impact claim wasn't supported.

Treat a grade without an observable acceptance criterion as a guess.

Evidence and Duplicate Checks Before You File

Evidence lets a developer inspect the failure rather than rely entirely on the description. Different artifacts establish different facts, so attach the smallest useful set rather than an unfiltered archive.

Evidence typeWhat it establishesWhat it doesn't establish
ScreenshotVisible screen state, layout and displayed messageThe preceding actions or repeatability
Screen recordingAction order, transitions and timing-dependent behaviorFrequency across separate attempts
Timestamped log or console excerptEvents associated with the executionRoot cause merely because an error appears nearby
Minimal test caseA reduced input or procedure that triggers the symptomImpact outside the tested configuration

For serious defects or timing-dependent behavior, capture a recording from the relevant setup through the failure. Align logs with that execution using timestamps and timezone, and retain enough surrounding context to interpret the event. Remove secrets and personal data before sharing attachments.

Check for an existing issue

In a study of 576 non-reproducible Firefox and Eclipse reports, duplication accounted for 26.83% of Firefox cases and 31.33% of Eclipse cases. Those figures describe that study's non-reproducible reports, not a universal duplicate rate, but they explain why duplicate checks belong in the filing workflow.

Before creating a ticket:

  • Search the component and screen: Include alternate names used in older tickets.
  • Search distinctive error text: Use a meaningful fragment rather than generic words such as failed.
  • Compare conditions: Check affected builds, inputs and configurations before deciding the reports match.
  • Record the outcome: Add the matching issue, or record that no match was found and what you searched.

If the match is uncertain, use a possible duplicate of field. Preserve the new execution evidence until a verifier confirms whether the symptoms have the same cause.

For customer-reported failures, Sift AI's guidance to define escalation triggers and owners is relevant to routing urgent findings without bypassing technical verification.

At 99tests, we reject incomplete reports, merge duplicates and grade severity against a published standard. The explanation of what a testing report looks like provides context for keeping the reporter's claim beside the verification outcome.

Before submitting, confirm that the title, evidence and duplicate-search outcome are present.

Reporting AI-Generated and Unexecuted Test Cases

A longer report isn't necessarily a better report. A generated procedure can sound precise even when nobody has run it against the affected build. More description doesn't close that evidence gap.

The analysis of reporting and AI-assisted reproduction emphasizes precise components, release or commit identifiers, minimal failing inputs and exact execution commands. Use those requirements as a gate between a proposed test and an observed defect.

A workflow should preserve the origin of each case alongside its execution outcome.

A woman sketching a test case workflow with a checklist and QA-related notes at her desk.

Add fields that establish execution

  • Case source: Human-written, AI-generated or adapted, including the originating tool or artifact when useful.
  • Execution proof: Timestamp, build, commit, device, OS, browser, locale, network and permission state.
  • Result status: Passed, failed, blocked or not run.
  • Confidence: Evidence-based assessment with unresolved uncertainty stated.
  • Minimal reproducer: Required fixture, setup and exact invocation.
  • Independent verification: Whether another person executed the reproducer and what they observed.

For an illustrative Playwright case, an invocation might be npx playwright test tests/checkout-coupon.spec.ts --project=chromium. Include the repository revision, dependency setup and authorized fixture instructions needed to run it unchanged. A command without its required context isn't a complete reproducer.

Assign a status without upgrading assumptions

Passed means the case ran and met its expected result. For example, the discount appeared and the payment screen opened on the recorded target.

Failed means execution produced an observed discrepancy. Blocked means a prerequisite prevented the intended check, such as unavailable test credentials. Not run means execution never started, perhaps because the required handset wasn't available.

A generated case that nobody executed is neither a pass nor a confirmed bug.

Don't paste a model's predicted actual result into the observation field. Leave it unexecuted until a tester or runner produces evidence.

For release review, every planned case should have a status against its intended target. Any case not run needs a reason, so the release manager can distinguish uncovered behavior from verified behavior.

Common Template Mistakes and How to Fix Them

When a developer returns a report, diagnose the missing decision rather than adding more prose. The table below identifies common faults and the field that resolves them.

MistakeEffectFix
Steps such as Login failsDeveloper cannot repeat the failureNumber each action with exact inputs, using the steps procedure
No build or commit recordedTeam cannot tell whether a fix shippedRecord build, commit and first seen build in the execution record
Severity chosen by feelingCounts inflate and release gates disagreeGrade against the severity rubric and log changes
Environment as free textFinding cannot be rerun on the same setupUse the structured fields in the platform table
Root cause written as the actual resultGuess and fact get mixedKeep hypotheses in a separate speculative field
No duplicate search before filingSame bug is triaged twiceSearch by component and error text using the evidence checklist

Separate diagnosis from observation

A statement that the session cache is corrupt is a hypothesis unless evidence establishes it. The actual result should describe what the tester could inspect, such as returning to the login screen after submitting valid test credentials.

Use a field labeled Speculative root cause for a possible explanation. Include the observation that prompted it and a check that could disprove it. Developers can use the lead without mistaking it for a confirmed finding.

These mistakes interact. Vague steps combined with an unknown build can make an already-fixed defect appear open, or make an unresolved defect appear fixed because the verifier followed a different path.

Review in separate passes

  • Facts pass: Can each observation be tied to an execution or artifact?
  • Hypotheses pass: Are proposed causes clearly separated from observed behavior?
  • Completeness pass: Are required fields filled, or explicitly marked unavailable with a reason?

A missing value is easier to address when the reporter names it directly. Don't replace an unknown build with the current release number.

The guide to improving collaboration between software testers and developers complements this review habit. Keep the discussion focused on what another person needs to reproduce and evaluate the finding, not on who wrote the original ticket.

Run the Template on Your Next Build

Start with an open bug rather than redesigning the entire QA process. Fill the template, hand it to a colleague who didn't write it, and ask them to reproduce the failure without coaching.

Use the dashboard view as a reminder to review execution alongside individual findings.

Screenshot from https://99tests.com

For a release, extend that check across the test plan. Record each case against each intended device or browser, with a reason wherever execution was blocked or not run. That view tells the release manager what was checked and where uncertainty remains.

Execute the matrix and preserve the comparison

If internal device access limits execution, 99tests is an option for running the plan on real phones and browsers. Our reports contain a coverage table, reproducible findings, a verification record, a device and browser matrix, a session log and a coverage note. The coverage table identifies each case as pass, fail, blocked or not run, with reasons for incomplete execution.

Every report also supports a one-click re-run of the same plan against a new build, using the same devices and cases to show whether the fix worked. Keeping those targets constant makes the comparison more useful than an unrelated retest.

The video provides additional context for the testing workflow.

Copy the template today, complete it for an open bug, and review it with the developer responsible for the fix. Resolve the missing execution details before expanding the method to the rest of the release.


99tests executes customer-supplied test cases on real phones and browsers, turning failures into verified reports with reproduction evidence and explicit coverage gaps. Visit 99tests to arrange execution of your next test plan and check which cases passed, failed, were blocked or weren't run.