Issue Types in Jira: Understanding the Basics | Jira Guru

[#1]

Hi Everyone! 👋

Welcome again to Weekly knowledge growth with Jira Guru! 

Today's topic is Issue Types in Jira.

What are the issue types?

Issue types in Jira are used to distinguish different types of work in unique ways, allowing teams to identify, categorize, and report on their work across their Jira site. They help teams build more structure into their working process and enable them to search and sort work, track progress, and estimate how well their team responds to bugs or completes initiatives. Jira comes with default issue types, but teams can customize them to match any method of project management they want.

In Jira, issue types are used to categorize and track different types of work items. Jira comes with a default set of issue types, but these can be customized to fit the needs of your organization. 

The default issue types in Jira Software include:

• Epic: An Epic issue type in Jira is used to track and manage large pieces of work that can be broken down into smaller, more manageable pieces called stories. Epics are typically used to represent a group of related stories that together will achieve a specific goal or deliverable.

Example: Project to revamp the user interface of a software application. The Epic would include details such as a description of the project, acceptance criteria, estimated story points, and the priority level. The Epic would then be broken down into smaller stories, such as "Update login page UI", "Redesign main navigation", and "Improve search functionality".

• Bug: The "Bug" issue type is used to track defects or problems with the software or system. A bug is a coding error, a mistake or a flaw in the system that causes it to behave unexpectedly or not as intended. Bugs can be discovered during testing, production, or even after the software has been released. Once a bug issue has been created, it can be assigned to a developer or team member responsible for fixing it. As the bug is worked on, updates can be added to the issue to track progress, such as when a fix is tested or deployed.

Example: A bug could be something like a broken link on a website.  For: "When the user clicks on the 'Submit' button, nothing happens." The Bug is: "Button does not work"

• Story: A Story issue type in Jira is used to describe a small, self-contained unit of work that contributes to the completion of an Epic or project. Stories are used to track and manage the implementation of specific features or requirements.

Example: A story could be something like "As a user, I want to be able to view my account balance." This issue would be assigned a medium or high priority, depending on how important it is to the users.

• Task:  Task issue type in Jira is used to track a piece of work that needs to be completed within a project, but doesn't necessarily correspond to a new feature or bug fix. Tasks are typically smaller pieces of work that contribute to the overall progress of a project, such as documentation, testing, or code refactoring.

Example: The project needs to be updated to include documentation about the project. This task includes updating the project description, installation instructions, and any other relevant information for users.

• Sub-task: A Sub-task issue type in Jira is used to represent a smaller, more specific piece of work that is part of a larger Story or Task. Sub-tasks allow teams to further break down and organize work within a Story or Task.

Example: a specific task related to the implementation of a new payment method on an e-commerce website, such as "Integrate new payment API". The Sub-task would be linked to the larger Story or Task, and would include details such as a description of the task, estimated time to complete, and the person responsible for completing the task.

Additional issue types in Jira Software:

In addition to these default issue types, Jira also allows for custom issue types to be created. This can be useful for organizations that have unique workflows or types of work items that don't fit into the default categories. Custom issue types can help you further categorize and track work items beyond the default issue types provided by Jira.

Create a new custom issue type

To create a new custom issue type in Jira Software, you will need to have administrator permissions. Here are the basic steps to create a new issue type:

1. Go to the Jira administration menu and select "Issues".
2. Under "Issue Types", click on "Add Issue Type".
3. Give your new issue type a name and description that accurately reflects its purpose and function.
4. Choose an icon to represent your new issue type.
5. Configure any additional settings, such as whether the issue type should be visible to specific projects or users.
6. Save your new issue type.

Here are a few additional issue types that you might find useful in Jira

1. New Feature: New Feature issue type in Jira is used to track the development of new functionality or features that are being added to a software system or application. It is one of the default issue types available in Jira and is commonly used in software development projects to manage the development of new features or enhancements to existing functionality.
2. Improvement:  An Improvement issue type in Jira is used to track and manage changes that improve the functionality, performance, or user experience of a software system or application. Improvements are typically changes that are not related to fixing bugs or adding new features but rather to optimize or enhance existing functionality.
3. Change: The change issue type is used to represent a significant change to an existing system or process. It is typically used in IT service management to track change requests and approvals
4. Sub-bug: A sub-bug is a smaller issue that is part of a larger bug. Sub-bugs can be created within parent bugs to help break down the issue into smaller, more manageable pieces.
5. Test case: A test case is an issue type used to represent a specific test scenario that needs to be executed to verify a software feature. Test cases can be associated with specific user stories or epics to ensure that all functionality is tested.
6. Spike: A spike is an issue type used to represent a short, focused effort to research or investigate a particular technology or approach. Spikes are often used in agile development methodologies to help teams explore new technologies or approaches before committing to a larger effort.
7. Support request: This issue type is used to represent a request for technical support from users or customers. It can be used to track and manage support tickets, and to ensure that support requests are responded to in a timely manner.
8. Technical debt: Technical debt is an issue type used to represent technical issues that need to be addressed to improve the long-term quality and maintainability of a system. Technical debt issues are typically prioritized and addressed as part of ongoing maintenance and improvement efforts.
9. Research: The research issue type is used to represent a specific research project or investigation that needs to be completed. Research issues can be used to track and manage research projects, and to ensure that results are shared with relevant stakeholders.

What are parent and child issues?

Parent and child are terms that describe a type of relationship between issues:

• A parent issue is an issue that sits above another issue e.g. a story that’s made up of subtasks.
• A child issue is an issue that sits below another issue e.g. a subtask that belongs to a task.

This means that the parent and child relationship isn’t limited to specific issue types. Rather, any issue type can be both a parent and a child issue — the only exception being subtasks, which can only be a child since there aren’t any issue types below it in the hierarchy.

For example, if you have this issue hierarchy:

• Epic
• Story, Task, Bug
• Subtask

Then:

• As a parent issue, an epic can have stories, tasks, and bugs as child issues.
• As a parent issue, a task can have subtasks as child issues.
• A subtask can’t have any child issues.

Tips for Issue Type in Jira

1. Choose issue types that align with your team's workflow and process. Issue types should reflect the types of work items that your team needs to track and manage, and should be customized to suit your team's specific needs.
2. Limit the number of issue types you use. Having too many issue types can make it difficult to manage and track work items effectively. Consider consolidating similar issue types or using subtasks to break down larger issues into smaller, more manageable pieces.
3. Ensure that issue types are consistently used across your team or organization. This can help ensure that all work items are properly categorized and that you can generate accurate reports and metrics on your team's performance.
4. Use issue types in conjunction with other Jira features, such as workflows, fields, and statuses, to create a cohesive and effective system for managing work items.
5. Regularly review and update your issue types as needed. As your team's needs and processes evolve, it may be necessary to add, remove, or modify issue types to better align with your current workflows and priorities.

Understanding the different issue types in Jira is essential for effectively tracking and managing work items. Each issue type has its own set of characteristics and priorities, and it is important to use them appropriately. By utilizing the default issue types and creating custom ones as needed, teams can ensure that their work is organized and tracked efficiently. With the right use of issue types, Jira can be a powerful tool for project management and collaboration.

--------

Learn more about Jira, Confluence and Atlassian with Jira Guru

👉 Visit Atlassian Marketplace

💬 Questions? Use the comment section!

🙌  Please like, and share this article to new beginners

[Andy Gladstone]

Great post. This one was a lot to take in, probably could have been 2-3 posts instead of just one.  

[Collista Lewingdon]

@Teresa_DevSamurai thanks for teaching me something new today. I had no idea we could great new issue types. 

[Teresa_DevSamurai]

Thank you, I will consider writing more posts on this topic.

[John Stock]

Can I ask why "New Feature" is the only one that uses the "New" qualifier?   Typically Jira schema just traditionally uses the "Feature" issue type, right?   "New" implies the state in the issue type; but states should be reflected in the workflow; after a while it may not be a new feature anymore but an existing feature; e.g. similar to a Bug - it's not created as a "New Bug" but just a bug, with the "new" implied by the state.  Eventually it becomes a not-new-anymore closed Bug, but the Jira artifact remains; likewise after a feature is implemented it would not be new anymore, however the JIra artifact would still be a "New Feature" and thus misleading.

[Ann Lu]

1. Is there a recommendation for defects? For example, a defect could be logged when an application runs slower than expected. That wouldn't count as a bug, so would that be a custom issue type? 
2. Is there a recommendation for tech debt?

I would like to leverage these issue types in both Jira and Jira Align to ultimately track how much effort is spent on new features vs bug fixes vs defects vs tech debt. 

[valkis]

"In the company where I work, there is also the issue Type 'change request.' What does this issue mean?"