I am attempting to come to grips with the structure of the user-facing entities presented in Jira.

I am specifically not asking about how one might use Jira or its entities under any particular workflow or project management philosophy (such as Agile). Just about what entity relates to what structurally.

Among the items that crop up in Jira literature, or discussions about Jira:

  • Project
  • Epic
  • Story
  • Subtask
  • User Story
  • Task
  • Ticket
  • Issue
  • Issue type
  • Request
  • Label
  • Sprint
  • Theme
  • Initiative
  • Feature
  • Bug
  • Component
  • No doubt others

Among the questions I would like to understand:

  1. Which of these have a strict hierarchical relationship (one-to-many) to which others?

  2. Which of these are actually the same thing, just different ways that people name them for their particular workflow?

  3. Perhaps some of these appear as property values of some other entity?

  4. I see some documentation that the "task" hierarchy is just Epic-Story-Subtask. But then I see people referring to "Task". The level called "Subtask" sure implies that there is a level called "Task", but where is it? Or is Task commonly used to refer to "Story", or to incorrectly refer to "Subtask"?

  5. I see it stated in some places that the task hierarchy cannot be broken down below Subtask. Is this true, or am I missing something?

  6. How do all the other items relate?

It would be very nice to see an Entity-Relationship diagram laying out these relationships. Indeed there is an E-R diagram of the Jira database (https://developer.atlassian.com/server/jira/platform/database-schema/), but it's not very illuminating about the user-facing concepts I've listed here. Indeed, none of Epic, Story, (Sub)Task appear in it.

2 Answers 2


I'm most familiar with Jira Cloud. I believe that most of this applies to Jira Data Center as well, but there may be some minor differences.

There are multiple versions of Jira Cloud. Jira Work Management is a baseline tool to manage work for a team. Jira Software adds capabilities related to software development, such as integrations with development toolchains. Jira Service Management adds capabilities for IT management, such as help desk portals and asset management. Jira Product Discovery focuses on product management workflows, concepting, ideation, and roadmapping. Many concepts are shared across all of these versions of Jira, but some may introduce alternative terminology from the domains that they focus on.

A Project is a collection of Issues. Some people refer to Issues as tickets or requests, from terminology used by other tools. The Jira Service Management version uses "Request" in their customer portal. Project Templates are used to give base configurations as a starting point for future configurations. The Project Template also gives default feature configurations - for example, the Scrum Template enables Boards, Backlogs, and Sprints by default, since these are part of the Scrum framework.

Issues have attributes, such as an Issue Type, Labels, and Components.

The Issue Type hierarchy is configurable. Depending on your project configuration, you can edit this parent/child hierarchy. In some editions of Jira, you can even extend the hierarchy to many levels. A typical standard configuration has Epic as the parent type, Story and Bug and Task as the next level, and Subtask as the third level. Themes, Initiatives, and Features are ways of thinking about work hierarchies that some organizations may adopt and configure into their Jira instance.

Generally, an issue type configured as a parent type may have multiple children. However, a child may belong to only one parent. In the standard configuration, a Story may belong to one Epic, but an Epic may have many Stories and Bugs and Tasks.

Workflows can be assigned based on Issue Type. This allows you to have specific statuses and transitions based on this attribute.


Understanding the structure of user-facing entities in Jira can be complex due to the flexibility and customization options it offers. Let's break down the entities you've listed and explore their relationships:

  • Project: A project in Jira represents a collection of issues. It's a container for issues and is often used to organize work around teams, products, or departments.

  • Issue: An issue is a task, bug, or request tracked in Jira. It's the most fundamental entity in Jira.

  • Issue Type: An issue type categorizes the kind of work being tracked (e.g., Task, Bug, Story). Each project can define its own set of issue types.

  • Epic: An epic is a large body of work that can be broken down into smaller tasks or stories. Epics are used to organize work within a project.

  • Story/User Story: A user story describes a feature from an end-user perspective. It's typically used in Agile methodologies.

  • Task: In some contexts, "task" might be used interchangeably with "issue" or "subtask." However, in Jira's default hierarchy, there's no separate entity called "Task." Tasks are usually represented as subtasks or stories.

  • Subtask: A subtask is a smaller unit of work that contributes to completing a larger task or issue. Subtasks can be created within stories or epics.

  • Ticket: Often used interchangeably with "issue," a ticket refers to an item that needs to be tracked and managed within Jira.

  • Request: A request typically refers to a user-generated request for support, help, or information. In Jira, requests are often represented as issues.

  • Label: Labels are used to categorize and organize issues. They provide additional metadata for filtering and searching.

  • Sprint: A sprint is a fixed time period in which a specific set of work is completed. It's a container for tasks or stories to be worked on within a defined timeframe, commonly used in Agile methodologies.

  • Theme/Initiative/Feature: These terms are often used to categorize and organize work at a higher level than epics. They represent broader goals or objectives for a project or product.

  • Bug: A bug represents an issue or problem in software that needs to be fixed.

  • Component: A component represents a part or module of a software system. It's used to categorize and organize issues within a project.

In terms of hierarchical relationships:

  • Project contains issues.
  • Epics contain stories and subtasks.
  • Stories and subtasks are issues.
  • Subtasks are children of stories or epics. The terminology and usage can vary depending on the specific workflow or project management methodology being followed. While Jira provides a default hierarchy (Epic-Story-Subtask), it's highly customizable, and organizations can adapt it to suit their needs. Additionally, the terminology used within Jira may differ based on organizational preferences or specific project requirements.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.