Skip to contentComing soon: SprintProof for ChatGPT and Codex

Guide · Planning

How to break down a feature into stories and tasks.

A six-step method for turning a feature or epic into parts, user stories and tasks your team can estimate and pick up, with a worked example.

By the SprintProof team · Updated 30 October 2026

In short. To break down a feature, start from what done means, then split the work by layer: frontend, backend, data and cross-cutting work such as permissions, email and billing. Give each part a best, likely and worst estimate, ask what is missing before you commit, and only then turn parts into stories and tasks with acceptance criteria.

Epic, feature, story, task: what each level is for

Teams use these words loosely, so agree on them before you split anything. What matters is that each level answers a different question.

Start from a short written description. A one-page feature description template is enough.

  • Epic. A large goal that takes several features, often more than one sprint. It answers “what are we trying to achieve?” and is too big to estimate as one piece.
  • Feature. Something a person can use and notice, such as “workspace admins invite colleagues by email”. It answers “what will they be able to do?” A feature of a few weeks is the right size to plan as a whole.
  • Part. A piece of the feature small enough to estimate but bigger than a task, for example “Invite email” or “Seat limit check on accept”. It answers “what has to be built?”
  • User story. One thing a user can do, written from their side: “As an admin, I can resend a pending invite.” It answers “who gets what, and why?”
  • Task. A piece of work one person can pick up, with acceptance criteria. It answers “what exactly do I do on Monday?”

How to break down a feature, step by step

Work top-down: what done means first, then the shape of the work, and only at the end the stories and tasks. Writing stories first is the most common reason a breakdown misses work, because stories describe what users see and most of the work sits underneath.

  1. Write what done means, and what is out. Two short lists. “Done when” has checks a tester could run on the real screen. “Not now” names what people will assume is included and isn’t. Without both, nobody can say when the breakdown is finished. The PRD guide covers how to write them.
  2. Split by layer. List the work in each place it lives: frontend (screens and their states), backend (endpoints, jobs, integrations) and data (tables, migrations, backfills). Splitting by layer is quick, and each layer usually belongs to different people, so it shows who has to be involved.
  3. Add the cross-cutting work. Permissions, rate limits, logging, email, billing, tests and rollout belong to no single screen, so they are forgotten first. Give each one its own part. If you’d be embarrassed to find out in week two that nobody planned it, it needs a line now.
  4. Estimate each part as a range. Ask the people who will build it for a best, likely and worst case in days. A part with a wide gap between best and worst is where the risk is. If a part’s worst case is more than a few days, split it again. The free estimation tool turns the ranges into dates. If your team sizes in points instead, see story points explained.
  5. Run a gap check. Before you commit, ask what the plan doesn’t mention. Walk the feature planning checklist against the parts, or run the gap review in SprintProof. Each answer becomes a new part, a “Not now” item or an open question with an owner.
  6. Turn parts into stories and tasks. Now write the user stories that sit on top of the parts, and the tasks under them, each with acceptance criteria. A part is often one task; a larger one becomes several. The user story template and the acceptance criteria template give you the wording.

A worked example: team invitations

The feature: workspace admins invite colleagues by email and pick a role for each. Done when an admin can invite up to 20 addresses at once, links expire after 7 days, and pending invites can be resent or revoked. Not now: invite links without an email address, and SSO-only workspaces.

Split by layer, with best, likely and worst days:

  • Frontend. Invite modal (1, 1.5, 3). Pending invites list (1, 2, 3). Accept-invite page (1.5, 2, 4).
  • Backend. Invitations API (2, 3, 5). Invite tokens (0.5, 1, 2). Invite email (1, 1.5, 3).
  • Data. The invitations table (0.5, 1, 1.5).
  • Cross-cutting. Permission rules (1, 1.5, 3). Tests (1.5, 2, 3).

What the example shows

Added up, those nine parts come to 10 days best case, 15.5 likely and 27.5 worst. The range is wide, and the parts that make it wide are the API, the accept-invite page and the email, so those are the parts to talk through first.

Then the gap check asks: is sending invites rate-limited? Anything that emails an address a user typed can be used to send spam from your domain. That adds one part, “Rate limit invite sends” (0.5, 0.5, 1), and the totals become 10.5, 16 and 28.5. Half a day, found before the sprint instead of during it.

Only now do the stories come: “As an admin, I can invite several people at once”, “As an invitee, I can accept with one click”, “As an admin, I can revoke a pending invite”. Each one points at the parts it needs. The same plan, with its tasks, is in the PRD template.

Ways to split a story that is too big

If a story or part still has a worst case you can’t believe, split it. These cuts work for most software, and each leaves two pieces you could ship on their own.

  • By workflow step. “Invite, accept, join” becomes three stories, built in that order.
  • By business rule. One story for the basic rule, one for each exception, such as seat limits or role restrictions.
  • By data. Start with the common case, then add the others: one email address now, a pasted list of 20 later.
  • By happy and unhappy path. Build the case where everything works, then the expired link, the bounced email and the address that already has an account.
  • By layer, last. Use this one only when the others don’t apply. “Build the API” is rarely a story a user would recognise, and it hides the integration risk until late.

Common mistakes

Most weak breakdowns fail in one of these ways.

  • Starting from stories. Stories describe what users see, so the work under the screen goes unplanned.
  • Forgetting cross-cutting work. Permissions, email, rate limits, tests and rollout show up as surprises.
  • Parts too big to estimate. If the worst case is “a few weeks”, the part is a feature. Split it again.
  • One number per part. A single estimate hides which part is risky. The gap between best and worst is the information.
  • No “Not now” list. Anything not written down as out will be asked for in review.
  • Splitting without the people who will build it. A breakdown written alone is a guess. Ask an engineer to read the first draft.
  • Treating the breakdown as final. New parts will turn up. Add them with their estimates and update the range.

Checklist before sprint planning

A breakdown is ready for sprint planning when all of these are true.

  • “Done when” and “Not now” are written, and someone outside the team can read them.
  • The work is listed by layer, including the cross-cutting parts.
  • Every part has a best, likely and worst estimate from someone who will build it.
  • You ran a gap check, and each answer is a part, a “Not now” item or an open question with an owner.
  • Every story has acceptance criteria, and every task can be done by one person.
  • You know which parts are riskiest and have said so to whoever is waiting for the date.

Doing this in SprintProof

SprintProof follows this order. After the AI interview, the planner drafts the parts in four lanes with best, likely and worst days, and you edit them. The feature breakdown is where the parts live. The “Did you think of…?” gap review checks them against a library of checks, and the tasks are drafted from the parts with acceptance criteria.

The AI suggests and people accept: nothing in the plan changes without a click, and it does not replace the engineers who know the code. See pricing for the Team plan.

Plan the feature, not just the document.

Describe the feature and SprintProof interviews you, drafts the breakdown, asks the questions reviewers ask, and gives an estimate as a range with 50, 80 and 90% dates.

Plan your first feature free

FAQ

Common questions

What is the difference between an epic, a feature and a user story?
An epic is a large goal that takes several features. A feature is something a person can use and notice, planned as a whole. A user story is one thing a user can do, written from their side. Stories sit inside features, and features sit inside epics.
How small should a user story be?
Small enough that one or two people can finish it within a sprint, and that the team can agree what done means. If the worst case estimate is far from the likely one, or the story has several unrelated acceptance criteria, split it.
Should you estimate before or after breaking down a feature?
After. Nobody can estimate a whole feature well, but people can estimate its parts. Break it down, estimate each part as a range, then run a gap check and update the estimate with whatever the check adds.
What is a work breakdown structure in software?
A work breakdown structure is a tree that splits a project into smaller and smaller pieces of work until each one can be estimated and assigned. For a software feature, the top level is the feature and the next level is usually its layers: frontend, backend, data and cross-cutting work.
How do you find work that is missing from a breakdown?
Ask questions the plan doesn’t answer: who is allowed to do this, what happens when it fails, what email or billing does it touch, how is it rolled out. A checklist or a gap review asks them for you. Each answer becomes a part, a “Not now” item or an open question.
Can AI break down an epic into user stories?
AI can draft a breakdown quickly, and it helps most as a first draft and a source of questions. A draft still needs the people who know the code and the customers to correct it. In SprintProof the AI suggests parts and tasks, and nothing changes in the plan until someone accepts it.

Team

Plan the next feature before the sprint starts.

Create your account and name your workspace. Your first feature plan is free. To keep planning, subscribe to Team: the 14-day money-back guarantee applies.

Want to hear when the ChatGPT and Codex plugin ships? Leave your email.

Team size (optional)
One email when it ships. No spam.