What are Issue Types in Jira?

In this article, we’ve covered the fundamentals of Jira issue types. It also explains Jira’s parent-child issue relationships, Jira issue types at various hierarchical levels, and practical workflows for working with Jira issue types in a project. Let’s dive in!

Issues in Jira are individual work items, each containing information about a requirement to be completed in a project. Issues provide a structural workflow to the project, allowing you to track progress, assign responsibilities, and estimate the time required to complete work items. Issues can be features or requirements represented using Jira issue types, such as epics, tasks, or any custom issues a team might use.

Also Read: What are Components in Jira?

In Jira, issue types categorize issues in a project at various levels to create a structured hierarchy of work items. They help divide project requirements into manageable chunks of work for better project management.

What are the Issue Types in Jira?

Epics, tasks, stories, bugs, and subtasks are the five primary issue types in Jira. You can also add custom issue types to a project.

These issue types follow a parent-child issue relationship format (covered next) to create a hierarchical workflow in a project. 

Also Read: Automating Jira: How to Create Smart Workflows for Teams

Here’s an overview of each issue type:

Epic

An epic is a broader work requirement divided into groups of issues, such as stories, tasks, or bugs. It describes a significant feature or high-level requirement within a project and typically takes multiple sprints (in a scrum project) to complete. 

Example: If your team is working on an e-commerce application, an epic could be "Improve user experience for products page".

Story

A story is a user-centric description of a feature or requirement from the end user's perspective to outline what the user (or a stakeholder) wants to achieve and why it’s important. Stories typically come under epics and can often be completed within a single sprint. 

Example: For the above epic, the story: "Customers would want to see product reviews before making a purchase" describes a requirement from a user.

Task

A task is a standard issue type describing a piece of work to be completed. Tasks can cover a variety of actionable work item(s) often described in technical language that can be assigned to team members for completion. 

Example: For the above story, "Design and develop a product review section" outlines a task.

Bug

A bug is an issue type that represents bugs or defects in the product that need fixing. 

Example: "Fix the bug where review doesn’t display correctly on mobile devices" describes a bug.

Also Read: Bug Life Cycle: Explained 

Subtask

A subtask breaks down larger tasks into smaller, more manageable work modules. Subtasks aren’t exclusive to tasks and can also represent smaller work items for epics, stories, or bugs. 

Example: The task "Design and develop a product review section" can have one or more subtasks, such as:

• Add a star ratings section for reviews
• Implement an average star ratings section

Also Read: What are “Capabilities” in Jira Align?

Issues are associated in Jira with the parent-child relationship. An issue type in Jira can be either a parent or a child to other issue types. Here’s more on it.

Parent Issue 

A parent issue precedes a child issue. For example, if an epic is a parent issue, tasks, stories, subtasks, or custom issue types can be its child issues.

Child Issue 

A child issue follows a parent issue. For example, subtasks are the child issues for a parent task. 

Note that, subtasks can and will always be child issues for epics, stories, tasks, and custom issue types. That’s how Jira aligns subtasks in a project.

With the same analogy, there can be a grandparent followed by a parent and a child. If there are no subtasks for a task, an epic becomes a parent, and the task becomes a child issue type. 

Here’s an example picture that shows the relationship. 

Jira’s default issue hierarchy consists of three levels: Epic as the parent issue type, Story and Task as standard issue types, and Subtask as the child issue type. Custom issue types can be added at standard or child issue levels. Here’s a quick breakdown:

1. Epic (Parent Issue type) — A high-level representation of large work items or features.
2. Story/Task (Standard Issue types) — Issue types that fall under epics.
3. Subtask (Child Issue type) — Child issues that break down stories or tasks into smaller units.

A story describes user needs and functionality from an end-user perspective typically in a non-technical language aiming to outline information about what users want and why it matters. A task, on the other hand, focuses on internal processes or actions from the technical perspective required by team members without necessarily relating directly to user functionality.

Although both are standard issue types and might look similar in a project, the difference between stories and tasks lies primarily in their focus and how each outlines the requirements.

Example

• A Story might state: “Users would want to reset their account password to regain access if they lost or forgot their password.”
• A Task could specify: “Implement password reset functionality.”

In a Jira project, you often have to create a new issue or a subtask. Or maybe you want to change issue types at times in your project. Here is a stepwise guide covering some practical workflows for working with Jira issue types.

Step 1 - How to Create a Task

To create a Jira task,

1. Open a Jira project and click the blue colored “Create” button from the top navigation bar.
2. From the modal window, select a project from the “Project” dropdown.
3. Add “Summary” for the task. It’s a required field. You can optionally add other details for the task.
4. Hit “Create” from the bottom right. 

The task adds to your project’s backlog list.

Step 2 - How to Create a Subtask

 To create a subtask,

1. Open a task for which you want to create a subtask(s).
2. From the task window, click “Add a child issue”.
3. Enter text for what needs to be done in the subtask.
4. Hit “Create”.

Step 3 - How to Convert a Subtask to an Issue

Here are the steps to convert a subtask to a different issue type in Jira.

1. Open a subtask
2. From the breadcrumb menu below the top navigation bar, click on the “subtask icon” for the selected subtask. Click “Subtask” under Change Issue Type.

    3. From the “Operations Details” page, open the “Subtask” dropdown, and select “Story” as the new issue type. Click “Next”.

     4. Hit “Next” again.

    5. Press “Confirm” to approve the issue type change.

This successfully changes the subtask to a story issue type. 

Step 4 - How to Convert a Task to a Defect

1. Click open a task from a project
2. From the task slide window, click the “task icon” from the issue breadcrumb.

   3. Select “Bug” from the dropdown options.

   4. Check for the confirmation message.

It’s done. The task instantly gets converted to a defect.