Bug template for Jira
Introduction
How much time do you take to track bugs? Maybe you’re tired of filling out the same details for every issue. Or perhaps you’ve got a growing team and want to ensure everyone is on the same page when reporting bugs. That’s why you should consider using a bug template.
If you’re someone who spends their day handling tasks, managing software bugs, or leading a team that relies on Jira, this is for you. We’ll walk you through everything you need about bug templates for Jira and how to create one step-by-step.
Here’s what you’ll learn:
- What a bug template is and why it’s helpful.
- How to create and customize bug templates in Jira.
- Common fields you should include in your template.
- Mistakes to avoid when setting up templates.
By the end, you’ll have a better way to manage bug reporting.
🗎 Bug template for Jira
Here is a ready-to-use issue template for Jira. Simply copy-paste the following in your Jira Issue creation window. If you encounter styling issue, we advise you to paste it first into a notepad and copy-paste again from there.
Try our Jira extension
We provide an easy-to-use add-on for Jira dedicated to creating issue template in Jira. Turn any ticket to a reusable template and standardize workflows today!
Preview
Description
We have identified a bug in [Software Name], which is impacting [customer name].
Steps to Reproduce
- [Step 1]
- [Step 2]
- [Step 3]
- [Step 4]
Actual Behavior
[Describe the issue in detail, including what is happening and where]
Expected Behavior
[Describe what should be happening instead]
Customer(s) Impacted
[Provide details on which customers are impacted by this issue, and the potential business impact]
Part of the Software Impacted
[Identify which part of the software is impacted by the bug (e.g. Login, Dashboard, etc.)]
Attachments
[Add any relevant screenshots or log files to help identify the issue]
Please address this issue as soon as possible to minimize the impact on our customers.
Wiki format
**Description**
We have identified a bug in [Software Name], which is impacting [customer name].
**Steps to Reproduce**
* [Step 1]
* [Step 2]
* [Step 3]
* [Step 4]
**Actual Behavior**
[Describe the issue in detail, including what is happening and where]
**Expected Behavior**
[Describe what should be happening instead]
**Customer(s) Impacted**
[Provide details on which customers are impacted by this issue, and the potential business impact]
**Part of the Software Impacted**
[Identify which part of the software is impacted by the bug (e.g. Login, Dashboard, etc.)]
**Attachments**
[Add any relevant screenshots or log files to help identify the issue]
Please address this issue as soon as possible to minimize the impact on our customers.
🗎 Bug template for Jira
Here is a ready-to-use issue template for Jira. Simply copy-paste the following in your Jira Issue creation window. If you encounter styling issue, we advise you to paste it first into a notepad and copy-paste again from there.
Try our Jira extension
We provide an easy-to-use add-on for Jira dedicated to creating issue template in Jira. Turn any ticket to a reusable template and standardize workflows today!
Issue Template
Preview
Description
We have identified a bug in [Software Name], which is impacting [customer name].
Steps to Reproduce
- [Step 1]
- [Step 2]
- [Step 3]
- [Step 4]
Actual Behavior
[Describe the issue in detail, including what is happening and where]
Expected Behavior
[Describe what should be happening instead]
Customer(s) Impacted
[Provide details on which customers are impacted by this issue, and the potential business impact]
Part of the Software Impacted
[Identify which part of the software is impacted by the bug (e.g. Login, Dashboard, etc.)]
Attachments
[Add any relevant screenshots or log files to help identify the issue]
Please address this issue as soon as possible to minimize the impact on our customers.
Wiki format
**Description**
We have identified a bug in [Software Name], which is impacting [customer name].
**Steps to Reproduce**
* [Step 1]
* [Step 2]
* [Step 3]
* [Step 4]
**Actual Behavior**
[Describe the issue in detail, including what is happening and where]
**Expected Behavior**
[Describe what should be happening instead]
**Customer(s) Impacted**
[Provide details on which customers are impacted by this issue, and the potential business impact]
**Part of the Software Impacted**
[Identify which part of the software is impacted by the bug (e.g. Login, Dashboard, etc.)]
**Attachments**
[Add any relevant screenshots or log files to help identify the issue]
Please address this issue as soon as possible to minimize the impact on our customers.
Good bug report vs. Bad bug report
Not all bug reports are created equal. Some reports make it easy for developers to identify and fix the issue quickly, while others can leave them scratching their heads, wasting valuable time figuring out what went wrong.
A good bug report is clear, concise, and complete. It provides all the necessary information in a structured format, leaving no room for guesswork. The goal is to give developers everything they need to understand, reproduce, and resolve the issue as efficiently as possible.
What makes a good bug report?
- Descriptive title
- Steps to reproduce
- Expected vs. Actual results
- Severity level
- Attachments
On the other hand, a bad bug report is vague, incomplete, or lacks structure. It leaves developers guessing about the issue, wasting time on follow-up questions instead of fixing it.
What makes a bad bug report?
- Unclear title
- No Steps to reproduce
- Missing details
- No severity level
- No attachments
What should I include in a bug report?
A well-documented bug report can make the difference between a quick fix and endless back-and-forth questions. It’s important to include the right details to ensure developers have everything they need to understand and resolve the issue.
Here’s what every bug report should have:
A clear and descriptive title
The title is the first thing developers will see, so it needs to summarize the issue in a straightforward way. Avoid vague phrases like “Something broke.” Instead, aim for a brief description of the problem.
Example:
- Bad: “App not working.”
- Good: “Error displayed when saving a draft email.”
Steps to reproduce
This is the heart of the bug report. Provide a step-by-step guide to replicate the issue so developers can see it themselves. Be as detailed as necessary, listing every action from start to finish.
Example:
- Log in to the application.
- Click on the “Settings” menu.
- Change the language to French.
- Observe that the text on the dashboard overlaps incorrectly.
Expected vs. Actual results
Explain what you expected to happen versus what occurred. This helps developers understand the gap between intended behavior and the bug.
Example:
- Expected Result: The file uploads successfully with a confirmation message.
- Actual Result: The file upload fails with no error message.
Severity Level
Indicate how critical the bug is to the project. Is it blocking users from performing a key action (critical), or is it a minor visual issue? This helps prioritize the fix.
Common severity levels:
- Critical: Prevents core functionality (e.g., login failure).
- Major: Impacts significant functionality but has a workaround.
- Minor: Cosmetic issues or non-urgent errors.
Attachments
Visuals can save a lot of time. Screenshots, videos, and error logs give developers more context and help them diagnose the issue faster.
Examples of Attachments:
- A screenshot of an error message.
- A video showing how the bug occurs.
- The exact text of a crash log or stack trace.
Environment details
Where and how did the bug occur? Include details like:
- Browser/device: Chrome, Firefox, iPhone, etc.
- Operating system: Windows, macOS, Android, etc.
- App version: Specify the version number or build.
Example:
- Browser: Google Chrome (v115.0)
- Operating System: Windows 10
- App Version: 2.3.5
Additional notes (Optional)
If you noticed anything unusual or think there’s extra context that could help, include it here. This could be related issues, recent changes, or potential causes.
Example:
“Bug started appearing after the last app update. Works fine in English but breaks in other languages.”
How to write a bug report
Writing a bug report might seem simple, but doing it well requires thought and structure. A good bug report should describe the issue and provide enough context and clarity so developers can quickly understand, reproduce, and fix the bug. Here’s how to write a bug report:
Understand the issue clearly before reporting
Before you even start writing, take time to fully understand the bug. Reproduce it yourself to ensure it’s consistent and not a one-time glitch. Observe how the issue behaves, where it occurs, and what might have caused it.
If you’re unclear about the problem, your report might lack critical details or include misleading information.
Choose the right bug-tracking system
The next step is to ensure you’re reporting the bug in the appropriate platform, like Jira. Bug tracking systems are designed to capture and organize issues efficiently, ensuring that nothing gets lost or overlooked. Each platform has its features, so familiarize yourself with the fields and requirements of your tool.
Reporting bugs outside the proper system (like in emails or chats) can lead to miscommunication or overlooked issues. Using the right platform keeps everything centralized and trackable.
Include background information
When writing the bug report, provide enough context to help developers understand the bigger picture. Mention what you did when the bug occurred and any relevant details about the situation. For example, explain if the bug appeared after a recent app update or only occurs in specific scenarios.
Write a short background paragraph at the beginning of the report. Include details like:
- Was this a new issue or a recurring one?
- Did it appear after making certain changes (e.g., an update, new integration)?
- Are there specific conditions where this bug is more likely to occur?
Here’s an example:
“This issue started appearing after the most recent update. It only occurs when a user tries to upload a file larger than 10MB on the desktop app. The mobile app works fine.”
Avoid assumptions
Stick to the facts. When describing the bug, focus on what happened rather than guessing the cause or providing solutions. Your role is to report what you observed, not diagnose or fix the issue.
If you include assumptions about the cause, it might mislead developers. For example, writing “The server crashed because of a timeout error” may lead the team down the wrong path if the issue is unrelated.
Collaborate with your team
If you’re unsure about how to write a certain part of the report, don’t hesitate to consult your team. Collaboration can help clarify details, fill gaps, or confirm whether the bug is already known. QA testers, developers, or project managers might have additional input to strengthen your report.
Test the bug
Before submitting the bug report, double-check that the issue is reproducible and that you’ve included all necessary details. Try reproducing the bug in different environments or with different inputs to confirm its consistency.
Steps to test:
- Try replicating the bug under the same conditions multiple times.
- Test it in different browsers, devices, or app versions (if applicable).
- Note any variations in behavior and include them in the report.
Bug reporting best practices
Writing a good bug report is about communicating the problem effectively so it can be resolved quickly and accurately. Here are the best practices to follow:
Keep bug focused on one issue
Avoid combining multiple bugs into a single report. Even if the issues seem related, it’s better to separate them so each bug can be tracked, assigned, and resolved independently. If you notice multiple issues (e.g., a login error and a broken link on the same page), write separate bug reports for each one, even if they seem connected.
Suggest a reproduction rate
If a bug doesn’t happen consistently, mention how often you’ve been able to reproduce it. Is it intermittent, or does it occur every time you perform the steps? Knowing whether a bug is consistent or occasional helps developers prioritize and troubleshoot more effectively. Intermittent bugs might require different debugging approaches.
Always include the date and time
Bugs can sometimes be linked to specific events, such as recent system updates or scheduled maintenance. Including the date and time when the bug occurred can provide valuable context. Add a note like: “This issue occurred on October 20th at 3:45 PM while testing the checkout page.”
Use visual aids wisely
While screenshots and videos are invaluable, make sure they’re clear and relevant. Highlight key areas of focus in the visuals, and avoid attaching excessive or unnecessary files that could overwhelm the developer.
How to apply this:
- Use annotations to point out the exact issue in a screenshot.
- Trim videos to focus on the relevant part of the bug.
- Include crash logs or error messages only if they’re directly related.
Follow your team’s bug reporting standards
Every team has its standards and workflows for bug reporting. Make sure you’re following the agreed-upon format, using the correct templates, and entering the report into the right system (e.g., Jira). Consistent reporting ensures your bugs are handled efficiently and aren’t lost in the shuffle. It also makes it easier for others to review and verify your report.
Bug report templates
Bug templates aren’t one-size-fits-all—they’re tailored to specific needs, workflows, and types of bugs. Here are the common bug templates:
Functional bug template
Functional bugs are issues that disrupt the core functionality of your software. These bugs prevent features from working as intended, such as buttons that don’t respond, broken workflows, or errors when performing basic actions.
Key details to include:
- A clear description of the function that isn’t working (e.g., “Submit button does not trigger form validation”).
- Exact steps to reproduce the issue in the simplest terms.
- Expected vs. actual behavior to pinpoint what went wrong.
- Severity level to prioritize the bug (e.g., “This issue blocks users from completing purchases”).
UI/UX bug template
User Interface (UI) and User Experience (UX) bugs focus on the appearance and usability of your application. These bugs might not block functionality but can still frustrate users or make your product feel unpolished. Use this template for visual misalignments, inconsistent spacing, broken layouts, or confusing user flows.
Performance bug template
Performance bugs relate to speed, stability, and responsiveness. These include crashes, slow load times, or laggy interactions that negatively impact the user experience. Use this template to document issues affecting how efficiently the system performs under specific conditions.
Security bug template
Security bugs are vulnerabilities or flaws that can threaten user data, system integrity, or application security. They require extra care because they can have serious implications.
Compatibility bug template
Compatibility bugs occur when software behaves differently on various devices, browsers, or operating systems. These are especially important for apps with a diverse user base. For example, a dropdown menu works perfectly in desktop browsers but fails to expand on mobile devices. This template lets you capture environment-specific details that help developers pinpoint compatibility issues.
Accessibility bug template
Accessibility bugs affect users who rely on assistive technologies or specific accessibility features to use your software. These issues can create barriers for people with disabilities and must be prioritized to ensure inclusivity.
Save time and focus on what matters
Need to save time and reduce manual work? With our easy-to-use Atlassian Jira extension, creating and using templates has never been simpler. Whether you’re managing bug reports, epics, stories, or tasks, our templates help you streamline your workflows and focus on what matters most.
Check out our full library of template options, including:
- Jira Epic Templates: Perfect for large-scale projects.
- Jira Story Templates: Streamline your user stories.
- Jira Task Templates: Simplify everyday task creation.
Take the guesswork out of Jira issue creation and make your processes faster and more efficient. Ready to try it out? Visit the Atlassian Marketplace and get started today.
We provide an easy-to-use Atlassian Jira extension that simplifies template creation and daily use.
