epic vs story vs task Edited

17 answers

1 accepted

30 votes
Accepted answer

Hi Brian,

             If you are looking for difference between these three 

Epic is An epic captures a large body of work. It is essentially a large user story that can be broken down into a number of smaller stories. It may take several sprints to complete an epic. 

  • There is no true difference between a Story or a Task in JIRA Agile.
  • If you need to break certain Stories up into items that have to be assigned to different teams I would advise you to convert this Story into an Epic and make new Stories of the sub tasks, these Stories can then be assigned to different teams.
  • Otherwise I would simply advise you to use sub tasks underneath stories (these are not viewable in the plan mode, but they are viewable in the work and report mode of your Agile Board).

Regards

Chander Inguva

Mike Howells Atlassian Team May 24, 2017

When you say there's no difference between Story and Task I guess you mean that there's no technical difference in that they're both "issues" as far as JIRA is concerned. So they get shown the same way on a board, for example.

There definitely could be a semantic difference in that a Story could be about something of value to users, whereas a Task could be something of value to the team. The two are likely to have different workflows and different fields to reflect those purposes, depending on how the project has been configured. 

Like 3 people like this

Thanks, @Mike Howells and  chander inguva for your kind update.

Best Regards

Chandler  there a diagram of the structure?

Epic is a large story, and not much difference between story and task

Hi Avdhesh ,

Can you please give day today example that explains what epic story and task.

Homepage (epic)        

- Carousel (story)            

- Backend development to load carousel images (task)             - Layout and styling of carousel (task) 

 

             like above

 

Thanks,

Like 1 person likes this

Our team adds tasks as "technical tasks" that are large enough to be stories (bigger than a sub-task), but do not directly add value to the customer.  Using a different issue type lets me create a customer focused dashboard for stakeholders and another one with all issues for the team.

@Robin Surland, do you assign Story Points to the "technical tasks" or the User Stories or both (or something else)?

I like your approach and plan to use it on a project I am about to start. Just need to figure out some of the details and how to fit them with our team.

Our team estimates the tasks, but we had a historic problem with our internal customers trying to hold the team to large story estimates made six months in advance. I have been thinking about adding a T-Shirt size field and using that for stories and keeping the points attached to actually work we know enough about to estimate. I know a lot of teams would say that the stories were simply not broken down enough to begin with, which is probably true. If we had more layers of Epics, like themes maybe, we wouldn't have to use stories in this way. In the end, anyway you can simplify the customer's view so their asks don't get lost in projects with thousands of issues, the better. 

+1 on making it easy to see which backlog items deliver value to users!

I would avoid quoting estimates in person-hours for the very reason you found: stakeholders will hold you to them. 

Story points are intended to be used on items for which you want to be able to estimate delivery times, which usually means those that deliver value to users or the business. By getting a measure on how many points a team can deliver per sprint, and putting points on the user stories, you can estimate how many sprints it will take to get everything you want to users. 

The points are meaningless to anyone outside the team, but if you know the team's "velocity" (points-per-sprint) you can estimate by which sprint they'll deliver the stories required. That way you can give the customer a time-box, but of course priorities will change so you reserve the right to change which stories get done to get them what they need. 

Mike Howells Atlassian Team Feb 06, 2018

The idea of Scrum/Agile is to break down deliverables into small, incremental pieces that each give some value to users. By small I mean can be done in one sprint. If it’s not sprint-sized then it’s an Epic, and you need to think hard to break it down further into smaller pieces of value, tracked as Stories. 

I recommend going on a Scrum training course. Kane Marr does an excellent one. 

Agreed, stick to story points and avoid the agile trap of tasks, I would only use tasks if teams are offshore and you don't have transparency of teams and their work, or teams that like to go to the detail then let them use tasks... 

 

But story points should be measured on stories and burn downs or burn ups should all be based on the progress of the story would be my suggestion. 

Agile is a philosophy and as such is implemented with vary degrees of rigidity. I teach JIRA classes to many students who use Agile. To date I have not found 2 companies that use Agile in the same way.

JIRA is a software that attempts to facilitate the Agile philosophy. As such, JIRA provide a fairly broad approach to agile terms and functionality.

In general, Epic, Story & Task are all Issue Types in JIRA and therefore can be organized in any heirarchy the users wishes (via linking and advance workflow rules). For example, JIRA would even allow you to make an epic dependent on a task - though no one would likely ever want that.

Once you get to scrum boards (and also JIRA portfolio), Epics do have some unique functionalities that you do not have with any other Issue Type. 

This is how we use Epics, Story & Task ..

Epics are used as functional classifications (verticals) of our product, it makes more sense if we need to do some kind of measurements... Epics in this case will live as long the project exists.

Story is a kind of work that directly or indirectly affects our end user experience.

Task is a kind of work that is pure technical, mostly NFRs, deployments, optimisation, code level, configs, etc ...

I think we must use these issue types to best suite our requirements ...

Why can't you leverage labels on stories/tasks for what you want to achieve currently through epics?

Hello @David Heller

Epics are the vague, large clouds far back on the horizon. Once you get closer to them you will notice more and more details, usually sorted into Stories.

The stories are the actual items for getting things done, the epics are the grouping tool to keep an overview to allow hierarchical relationship. 

Grouping, you could surely do via labels, but labels are just a bunch of strings, get mistyped, might be attached anywhere and cannot be classified. With epics, you can actually work with them and have them 

  • have fields to enter structured information
  • have descriptions for freeform information
  • have attachments
  • have workflows 
  • assign responsible person
  • link other items incl. classification like "blocks, inherits, relase, relates, makes fun of ..."

I agreed some places use Features to group stories in order to understand the feature they are delivering and the value associated with that feature and the collective stories.

To break down the work to implement a user story I use Technical Task sub-tasks under the Story issue if we want to assign them to different people, for example. This makes it easy to keep them in the context of the story and to see when they've been completed. Sub-tasks are similar to issues but always live under another issue.

For ambitious user stories that are too large to estimate reliably, I use an Epic issue and break it down in to separate Story issues that each deliver some value to users but are small enough to estimate reliably. 

For work that needs to be done but is not releated to a user story, such as setting up build automation or upgrading a library, I use Task issues so we can easily see which backlog items are delivering value to users and which are for the team. A Task doesn't get story points, for example.

The way I've been approaching the distinctions of issue types is this - I'd LOVE some feedback or alternative suggestions to consider:

  • Epic - A general use case that is a collection of features (user stories). (Use Fibonacci numbers to estimate.)
  • User Story - Represents a user feature. (Use Fibonacci numbers to estimate.)
  • Sub-Task - Represents development tasks to accomplish the user story. (No story point estimates.) Generally no more than 1-day tasks. You can either count the number of sub-tasks or time estimate in days in your retrospective to evaluate if your story point estimate for the User Story was accurate and adjust accordingly - assuming you have some velocity history to compare to.
  • (Engineering) Task - We used to call these "Dev Stories" (in a pre-Jira project) - represents a set of engineering work that is not directly related to a user story. The team should try to anticipate "Dev Stories" and add them to the backlog sooner than later with estimates (Use Fibonacci numbers to estimate) so the PO can plan milestones.

An example of these distinctions could be:

  • Epic: User Authentication.
  • User Stories:
    • User Login screen.
    • Forgot Password workflow.
    • Lock account after too many failed attempts.
    • Google login support.
    • Facebook login support.
  • Sub-Tasks:
    •  User Login screen:
      • Design login page.
      • Cut SVG icons and images.
      • Implement login page HTML/CSS/JS.
      • Create SQL scripts to create tables.
      • Create SQL scripts for stored procedures.
      • Create web service REST API for user resource.
      • Hook up login page to web service REST API.
    • Forgot Password workflow:
      • ...
  • (Engineering) Tasks:
    • Setup GitHub project repo.
    • Setup GCP (or AWS) account, containers, and services.
      • (There might be Sub-Tasks for these too)
      • ...
    • Setup Jenkins CI pipeline.
    • Design overall (high-level) system architecture.
    • Research and decide on unit test and mocking framework.


What do you all think?

I agree on the Epic, Story and Sub-Tasks.

Why not write those "Engineering" tasks as stories with sub-tasks?  They can be associated with an appropriate epic.

I ask, what is the value that these tasks are bringing?  The value should be defined at the story level.

In Jira, (User) "Story" and (Engineering) "Task" are at the same level, so you can have sub-tasks under both, and both can be assigned to epics. We use both to make the distinction between a user-facing/requested feature and something the team needs to do.

So what is the difference between task (not a sub-task) via story?

When you first install JIRA Software, the Story issue point has the Story Points field. This numeric field can be used as an estimation statistic on JIRA Software Boards, and if you're using a Scrum board then you can see Story Point info rolled up to the Epic. You'll also see it on various JIRA Software Reports.

You can modify the field context so the Story Points field is available on other issue types, and once you do that, there's really no difference between a Story and any other issue type. I like having different types of stories (so they can have different workflows), so under my epics I have issue types like Course Development and Video.

If I add the Story Points field to Tasks, will any estimations be reflected in the Velocity report?

Yes, as long as your "task" issue type is at the same level as Story in the Epic -> Story -> Sub-task hierarchy. 

i.e it is Epic -> Tasjk -> Sub-task

Velocity is supposed to tell you how many sprints it will take to deliver a set of user stories, so you can tell your users/customers when they'll get what they need. So I would only put points on Story issues, not Tasks. 

If you put points on Tasks then the team's velocity does not reflect how many stories they can delivery per sprint, so you can't use it to estimate the number of sprints required to reach a delivery milestone. 

It's important to show Tasks and other things that don't deliver value to users on the team's backlog, but they should reduce velocity not increase it. The team has to make a call as to how much of that "drag" they include in sprints. 

That's a really weird way to look at it.  Sprint points should be used to gauge an amount of assigned work per sprint, regardless of whether its delivering value internally or externally.  Not assigning points to tasks seems to be breaking a fundamental feature of the process.  If you want velocity on stories, then report on stories and not tasks, but failing to estimate tasks is throwing the baby out with the bath water.

It is a debatable point (groan, sorry) but the way I see it if you put points on all items, even those that don't deliver customer value, then how do you estimate when your backlog items with customer value are going to be delivered?

I'm assuming the team uses their velocity to tell the Product Owner when a set of customer backlog items will be delivered. So the velocity needs to be a measure of how much the team can deliver to customers per sprint. If you include internal team tasks in velocity then you've basically ruled out any future team tasks, because you're estimating delivery dates on the assumption that the team is only working on customer stories.

Bug fixes is another interesting case. I prefer not allocating points to bugs because your giving the team's velocity a boost. Why would you give a higher velocity for introducing more bugs? Bugs actually slow the team down, so having to fix a lot of bugs in a sprint should reduce their velocity, because they'll take longer to deliver the customer value in the backlog. Giving points to a story and then giving more points to the bugs that got into the story implementation seems like double counting. 

So IMHO it comes down to how you are using velocity. If you are using it to estimate when customer stories get delivered then points should only be put on customer stories. If velocity just says how much work the team can do per sprint then delivery estimates will assume the team never works on team tasks or bug fixes, which seems bad. 

Sure it's debatable, but I don't think you're not delivering customer value per-sprint just because it's not a feature that's immediately visible to them.  Anything you do should be delivering value whether it's releasing a new feature, or improving job processing, or just resolving technical debt so developers can do their job faster (i.e. deliver more "customer-perceived value" faster) in the future.

Regarding velocity and bugs, on my instance we actually don't have an option to assign points to bugs, so there's no velocity boost or "reward" from adding bugs to a sprint.  

Honestly, I think leaving points off of your backend tasks is probably hindering the reporting aspect of this hypothetical project.  If "points on customer-facing items" is a facet you want to evaluate on your sprint, then perhaps you can look at story points delivered on stories, instead of story points delivered on stories and tasks combined.  I think it all comes down to how you set it up, but my main point/opinion is that not counting units of work on backend tasks is, frankly, bad practice.

Adam, Mike, great debate on the topic. 

We have got one item settled. No story points for bugs!

IMHO, the product owner has to understand all the work involved in the making of a product release. If he determines that 'direct customer value' appears minimal, than he can weigh it against technical debt, and occasionally influence decision making to even defer technical dept. Else, you end up with no one being interested in the long term technology evolution of the product and an overemphasis on delivering 'direct customer value'. Its a fine balance.

As a best practice, we tend to clearly state value of technical debt to explain why it has to be taken up now vs later. And we use technical leads as sprint owners, to ensure that sprint owners can effectively influence decision making, as well as have grasp to be able to understand the product owners business perspective, to take/understand the decisions.

Ultimately, finding the balance involves technical folks keeping a fair business perspective and the p.o. keeping a fair technical perspective. Somewhere between, lies the balance!

Velocity has to point to the net additional value the team is adding to the product (direct as well as indirect). 

Hi All,

Bottom line is - JIRA schema could be set different and its setup adaptable to the company needs.

I have worked with different JIRA schemas with different companies in the past.

Out of all of them the best one (and the one that make most sense to utilize JIRA's options) is this:

1. Epic (organizational break down, something that only one part of organization is working on and the other don';t need to see. For example different software type - core team and customization team could have different epic. or 2 different apps)

2.  Under Epic goes your Project - whatever is your PM tries to implement - usually driven or created by PM.

3. Under Project goes  - your Stories - those are driven or created by BA pr Product manager and they are cover your Requirements (user stories) - what they want to see once project implemented.

4. Under Stories go Tasks, they are Engineering tasks - what Dev will do to fulfill the Story/requirement. 

5. Under each engineering Task go sub-tasks (for example QA specific). And if QA cannot complete Sub-tasks because issue is found - they link it to this specific sub-task. That way Dev sees what his tasks blocked by, as he cannot close the task without close all sub-tasks first. 

In this setup everyone under the same Epic working on the same product or client or whatever you setup. It is easy to find your specific project and everything else cascade down from the project, so it is easy to see truck, find and analyze through JIRA tools.

I am answering this from a coaching point of view. This is how I try to explain in my sessions. I use the SAFe structure . Epic is something that you cannot touch and feel, Feature is something that you can touch and feel and experience, Story is we all know which abides by 3Cs and INVEST and finally task is technical nature to achieve the story. 

Mike Howells Atlassian Team Jun 24, 2018

Note that there are two flavours of "task" in Jira by default (although you can configure more):

  • Task issue type.
  • Technical Task sub-task type.

The latter is intended to be used to break down a Story into multiple technical implementation tasks assigned to different people. Sub-tasks are a special kind of issue in Jira that can only live as children of a parent issue. On an agile board you can chose whether or not to show sub-tasks.

There is some debate here on when to use the former. I advocate for using a Task to represent work by the team that doesn't relate directly to a specific user story, e.g. implementing tools that help the team work better. 

The tasks of Scrum are best represented using Technical Task sub-tasks as that works best with current Jira features.

The problem with sub-tasks is that you can't include sub-tasks in a Sprint independently. Suppose if your story has a bunch of sub-tasks and not all of them can be included in one sprint, you can't choose some of the sub-tasks for adding these to a sprint.

For our team we had to decide on one of two options to deal with this:

  1. Split the User Story into two and Move the unfinished sub-tasks from the original to the new "part deux" User Story. (Granted that Jira UI isn't the friendliest about moving multiple sub-tasks to a new parent Story.)
  2. Just move the entire User Story over to the next Sprint if it's not done - you don't get the story points in the sprint if it ain't done.

What we've ended up doing is option #2, unless we anticipate before the sprint starts that a User Story is definitely way bigger than can fit in one sprint and preemptively break it up into smaller stories.

>The problem with sub-tasks is that you can't include sub-tasks in a Sprint independently.

That's not a problem, it's correct.  A sub-task is part of the story you are telling people you are going to complete during the sprint.  You do not commit to doing part of a story in a sprint, it's either going to be done or it is not.

@Mars Tanumihardja- your approach is pretty much right, except that you should emphasise doing point 1 before you draw anything into the sprint!

The literal meaning of those three words are also actually what it means in JIRA - their meaning and their features.

Take an epic from a history - it will be formed of many stories - and each stories may have their own events ( tasks)

I understand it as simple as that.

Here is a really nice article to help answer this question: https://moduscreate.com/blog/jira-using-epics-vs-components-vs-labels/

Most Agile teams I've worked with will map their requirements as follows:

  • (Epic) User Story = Epic (in JIRA)
  • (Sprint-Ready) User Story = Story (in JIRA)
  • Task = Sub-task (in JIRA)

The intent...

The intent behind this is, when requirements are first created, they are nebulus and Epic in size (i.e. they take longer than your Sprint/Iteration to complete. Once you begin to break this down into pieces that can fit within a Sprint, these requirements become Sprint-ready. To track and monitor progress within the Sprint itself, as well as to help with forecasting a team's capacity, you can break down these requirements into individual tasks or technical steps required to resolve them.

How this works in JIRA...

How this works in JIRA is, you create Epics first, then you break these epics into Stories which you link back to the Epic. When you're monitoring progress in your Sprint, you break down the Stories into Sub-tasks and track progress via these on a Scrum board. Of course, this is an optional approach, but one I've seen most Scrum teams undertake.

Remember, it's all just a name...

In JIRA, you can have as many Issue Types as you like and you can call them whatever you like. If you prefer the naming convention of Requirement over User Story, feel free to use that instead.

So procedural question about breaking down Epics...who typically does this? I've worked at companies before where the PO was responsible for getting down to the Story level. My current company we seem to be getting Epic level only. That doesn't seem like the correct process

Mike Howells Atlassian Team Feb 06, 2018

The team does it, and the PO/PM is part of the team. 

The PO must be involved as they represent the user. Otherwise developers working on their own tend to break it down into technical tasks rather than incremental value to users. 

So keeping with the hierarchy: Epic -> Story -> Sub-task. What is the most efficient way to track sub-tasks during a Sprint if they cannot be seen in the backlog? Meaning if I break a story into smaller sub-tasks, but not all the sub-tasks are completed prior to the end of the Sprint and has to be rolled over.. how would you account for that? It's not like you can see them in the backlog... 

Mike Howells Atlassian Team Feb 19, 2018

You can configure a Scrum board to show sub tasks under Stories.

You might want a separate board for stand-ups where you only see the stories, so you can focus on updates relating to deliverables. 

Question about estimating Epics vs Stories:
If, in the beginning of the project, user stories are typically of Epic proportions, do you use the same scale of story points between Epics and User Stories (be it T-shirt sizes or fibonacci numbers)?

In other words, would Epics be in the say 8, 13, 21, 34 range while user stories should fall within the 1, 2, 3, 5 range?

Or, do you use the same fibonacci range 1, 2, 3, 5, 8 for both Epics and User Stories, but assume that they are at a different scale when used at the different hierarchical level?

How do these two approaches affect Jira reports and velocity calculations, if different?

How would you organize the following scope of work in JIRA? What type of issue would you use?

 

Example:

Graphic of expenses

  • Design for web. Graphic of expenses.
  • Design for mobile. Graphic of expenses.
  • Back-end. Logic for Graphic of expenses.
  • Back-end. API for mobile. Graphic of expenses.
  • Back-end. API for web. Graphic of expenses.
  • Web. Graphic of expenses.
  • Mobile. Graphic of expenses.

Ill interpret it in the following manner.

The product owner wants to add a capability to visualize expense in the product.

Id treat his need as a Feature, and capture it as an Epic, and explain the high level need for this feature.

Task 1

  • Back-end. Logic for Graphic of expenses.

User Story 1 - Web

  • Design for web. Graphic of expenses. - Sub Task.
  • Back-end. API for web. Graphic of expenses.
  • Web. Graphic of expenses.

User Story 2 - Mobile

  • Design for mobile. Graphic of expenses.
  • Back-end. API for mobile. Graphic of expenses.
  • Mobile. Graphic of expenses.

Ill next add the task and stories to a Sprint to track delivery to production :)

Team,

Thanks for you varied answers to a basic question -- As an Agile practictioner for many years, I too am struggleing to get a consistant glossary of JIRA terms vs Agile terms -- and being able to transition from other tools to JIRA -- (not so simple).

I also am struggleing to uncover how to map deliverable features to components -- which is not a clear mapping -

The tutorials are lacking, as they do not conform to the Scrum Alliance or SAFe descriptions -- which is challenging as I attempt to teach teams about Agile, not just "JIRA"

I will continue to 'troll' the boards here to learn how the JIRA flavor of Agile can work.

I am also new to JIRA.

I found it conveniant to declare:

EPICS as the customers (name of customer).

Stories as the progress for each customer.

Task - user handled (not scram) that can break appart the stories into parts.

I create a project (A Goal, that leads to the whole sale for customer, such creating a sales' web-site for the customer, or adding terminals use abilitites, etc.)

When I create the project, and an issue in the jira cloud, I just drag+drop the stroies to the epic, and it is related to the story (in backlog tab, after clicking epic and version on the slide bar).

Version - I am using right now only one version (1.0), but if I enhanced the web-sie, i.e - I will call it the version of my whole product.

Jira is the only Agile-aware PM software I have used that makes no distinction between a Story and a Task.

Use a Jira Subtask for a Scrum "task".

[Sorry somehow saving my edits created a duplicate post]

Suggest an answer

Log in or Sign up to answer
Community showcase
Posted Monday in Confluence

Organizing your space just got easier - Page Tree Drag & Drop is here

Hi Community! I’m Elaine, Confluence Product Manager. You may have read my earlier post about page tree in space navigation sidebar. I'm excited to share another improvement that helps you organize ...

161 views 3 5
Join discussion

Atlassian User Groups

Connect with like-minded Atlassian users at free events near you!

Find a group

Connect with like-minded Atlassian users at free events near you!

Find my local user group

Unfortunately there are no AUG chapters near you at the moment.

Start an AUG

You're one step closer to meeting fellow Atlassian users at your local meet up. Learn more about AUGs

Groups near you