Jira Acceptance Criteria: A 7-Step Guide With Clear Examples
Not sure when a Jira story is done? Learn 7 steps and clear examples for testable Jira acceptance criteria. Read now to reduce rework.
A Jira story can look finished while still leaving developers unsure what “done” means. That uncertainty leads to conflicting interpretations, missed edge cases, and avoidable rework during testing.
Vague criteria such as “make the page easy to use” don’t tell a developer what to build or a tester what to verify. If your team writes acceptance criteria this way, small gaps can turn into delayed releases and frustrating handoffs.
But here's the truth: clear acceptance criteria are practical, testable conditions for a completed story. I’ll walk you through seven steps, show Jira-ready examples, and explain how to keep criteria useful as work changes.
How to Write Jira Acceptance Criteria in 7 Steps
Write acceptance criteria as specific, testable conditions that show when a Jira story meets its intended outcome. Start with the user’s need, define observable behavior, cover relevant exceptions, and review the criteria with the people building and testing the work.
Here’s why: criteria work best when they explain the expected result rather than dictate every technical detail. The seven steps below help you turn a broad request into shared, verifiable expectations.

1. Start With the User Story
Read the story and identify who needs something, what they need, and why it matters. Acceptance criteria should clarify the story’s outcome, not introduce unrelated features.
For example, a story might say: “As a returning customer, I want to reset my password so I can regain access to my account.” The criteria should describe how password reset behaves for that customer.
If the story doesn’t explain its intended outcome, ask the product owner or requester before writing detailed criteria. Otherwise, the team may produce precise tests for the wrong problem.
2. Describe Observable Results
Write each criterion so someone can tell whether it passes by observing the product or its behavior. Avoid opinions such as “simple,” “intuitive,” or “fast” unless you define exactly what those words mean.
For example, replace “The reset process should be easy” with “After entering a registered email address, the customer sees a confirmation message.” The revised version gives a tester a clear result to check.
Let me explain: a criterion doesn’t need to prescribe the code or interface design. It needs to make the expected behavior clear enough for the team to implement and verify.
3. Use Given, When, Then for Scenarios
The Given, When, Then format can make behavior easier to discuss and test. “Given” sets the context, “When” describes an action, and “Then” states the expected outcome.
- Given: The customer has an active account.
- When: They request a password reset using their registered email address.
- Then: A confirmation message appears, and a reset link is sent to that address.
This format is especially useful when a story has several distinct scenarios. For a small story, a short list of direct conditions may be easier to read than repeated Given, When, Then statements.
4. Cover the Main Success Path
First describe what should happen when everything goes as expected. This gives developers and testers a shared understanding of the story’s primary purpose.
For a password reset, the main path could include entering a registered email, receiving a reset link, creating a new password, and signing in with that password. Make each result clear enough to verify.
Keep the success path focused on the story. If account registration is a separate feature, don’t quietly add it to the password-reset criteria.
5. Add Important Exceptions and Boundaries
Consider what could go wrong or change the expected outcome. Common cases include missing information, invalid values, duplicate actions, access restrictions, and expired links.
For example, a reset story might need criteria for an unregistered email address and an expired reset link. Those conditions can prevent inconsistent behavior and help testers cover more than the happy path.
You don’t need to list every imaginable edge case. Prioritize exceptions that affect security, customer access, business rules, or the ability to complete the story.
6. Make Every Criterion Testable
Check whether a tester could verify each criterion without guessing what it means. If the statement depends on an undefined phrase, replace it with a measurable or observable condition.
For example, “The page loads quickly” needs a specific performance target and a way to check it. If speed isn’t part of the story, remove the claim rather than leaving an unclear promise.
A useful test is to ask two teammates to explain how they would verify the same criterion. If their answers differ, sharpen the wording before implementation begins.
7. Add and Review the Criteria in Jira
Put the criteria where the team can find them while planning, building, and testing the issue. In Jira, teams commonly add them to the description or use a dedicated field when their workflow provides one.
Use short headings or bullets to separate scenarios, and keep each condition close to the story it supports. Review the criteria with the product owner, developer, and tester when possible.
Update the criteria if the agreed scope changes. A quick review in refinement or sprint planning can reveal a missing condition before it becomes a late testing surprise.
What Good Acceptance Criteria Look Like in Jira
Good criteria are specific, concise, and tied to the story’s intended outcome. They define behavior that someone can verify, while leaving appropriate implementation decisions to the team.
For example, “The customer can reset their password” leaves important questions unanswered. A stronger set explains which email addresses qualify, what confirmation appears, and what happens when a link expires.
The best part? Criteria can be brief without being vague. A few clear conditions often communicate more than a long paragraph full of assumptions.
A Jira-Ready Example
Story: As a returning customer, I want to reset my password so I can regain access to my account.
- A customer who enters a registered email address sees a confirmation that a reset link has been sent.
- The reset link allows the customer to set a new password before it expires.
- A customer who uses an expired link sees an explanation and can request a new link.
- A customer who enters an unregistered email address sees a neutral response that does not confirm whether an account exists.
- After successfully setting a new password, the customer can sign in using the new password.
These conditions cover the main journey, an expiry case, an account-privacy concern, and the final result. The team can still decide how the page is built.
When to Use Given, When, Then
Use Given, When, Then when the scenario needs clear setup, action, and result. It can be especially helpful for permissions, payment flows, or different user states.
For a simpler condition, a direct statement may be more readable: “A customer can sign in with the new password after a successful reset.” Choose the format that makes the expected behavior easiest to understand.
Acceptance Criteria vs. Definition of Done
Acceptance criteria describe the conditions for a particular story. A definition of done describes the team-wide standards that apply to completed work, such as code review or required testing.
For example, a story’s criteria might require a reset link to expire after a defined period. The team’s definition of done might require every change to pass automated checks before it can be considered complete.
Here's why: mixing these ideas can make story criteria repetitive or leave them too broad. Keep story-specific behavior with the issue, and keep shared quality expectations in the team’s definition of done.
Common Mistakes and How to Fix Them
Some acceptance criteria look detailed but still fail to guide implementation or testing. The fix is usually to remove ambiguity, separate unrelated outcomes, or add a missing condition.
- Too vague: “The form should be user-friendly.” Replace it with a visible behavior or a defined usability requirement.
- Too prescriptive: “Use a blue button positioned 20 pixels from the right edge.” Keep design specifications only when they are a real requirement.
- Too broad: One story covers password resets, account registration, and profile editing. Split work that has separate outcomes and tests.
- Only the happy path: The criteria explain success but omit important failures. Add the exceptions that affect access, security, or business rules.
- Unclear ownership: The team discovers different interpretations after work starts. Review the criteria together during refinement.
You might be wondering: how much detail is enough? Add enough to remove meaningful ambiguity, then stop before the criteria become a technical design specification.
Keeping Criteria Useful Through the Sprint
Acceptance criteria should remain visible and relevant as a story moves from planning to delivery. The product owner can clarify intent, while developers and testers can identify gaps from their different perspectives.
For example, a tester may notice that the story explains successful password changes but not repeated use of an old link. That question is easier to resolve during refinement than after the feature is nearly complete.
When scope changes, revisit the criteria and communicate the change in the Jira issue. Clear updates help the team avoid testing against an outdated expectation.
Project and Knowledge Workflows with ONES.com
ONES.com is a unified platform for project management and knowledge management, powered by ONES Assistant. ONES Project handles project management, while ONES Wiki supports knowledge management; the products are sold separately.

For teams refining Jira stories, ONES Project is a Jira alternative with Jira-compatible workflows, sprint management, custom fields, and built-in reporting. It supports cloud and self-hosted deployments, including on-premise, private cloud, and air-gapped environments.
Core Capabilities for Acceptance-Criteria Work
- Scattered story details → Jira-compatible workflows → Teams can manage issues in a familiar project structure while keeping criteria connected to the work.
- Unclear issue fields → Custom fields → Teams can add structured fields for acceptance criteria or review details that match their process.
- Changing team processes → Custom workflows → Teams can reflect their planning and review stages without relying on a fixed sequence.
- Untracked sprint commitments → Sprint management → Teams can plan stories and monitor progress within their sprint workflow.
- Manual status updates → Automation → Repetitive workflow actions can be reduced, leaving more time for criteria review and delivery.
- Limited progress visibility → Built-in reporting → Teams can review project progress without assembling separate reporting steps.
- Separate project and reference spaces → ONES Project and ONES Wiki → Teams can manage delivery work and team knowledge in one platform, with the products available separately.
- Deployment restrictions → Cloud, on-premise, private cloud, or air-gapped deployment → Organizations can choose an environment that fits their operating requirements.
ONES.com offers full feature parity between its cloud and self-hosted versions. Teams can use the deployment approach that suits their environment without giving up the platform’s feature set.
Where It Can Fit
Product teams refining a sprint backlog: A team can create Jira-compatible issues, add acceptance criteria through custom fields or issue details, and plan the work into a sprint. Built-in reporting can help the team review progress.
Organizations with restricted networks: A team that needs an air-gapped environment can use a self-hosted deployment while managing project work. ONES Wiki can separately support shared team knowledge, such as workflow guidance.
ONES.com may suit teams that want project and knowledge management in a unified platform, or need on-premise deployment. Whether it fits depends on your workflow, deployment needs, and preferred way to manage stories.
Common Challenges When Writing Criteria
- Problem: Stakeholders disagree about what the story means. Solution: Rewrite the story’s outcome in plain language and review the criteria together before the sprint.
- Problem: Criteria become too long to scan. Solution: Separate distinct scenarios, remove implementation details that aren’t requirements, and keep related conditions grouped.
- Problem: Testers find important edge cases late. Solution: Ask what happens when information is missing, invalid, expired, or repeated during refinement.
- Problem: The team treats criteria as a replacement for quality standards. Solution: Keep story-specific behavior in the criteria and shared engineering expectations in the definition of done.
- Problem: Jira criteria become outdated after a scope change. Solution: Update the issue and tell everyone affected, so implementation and testing follow the same expectations.
FAQs About Jira Acceptance Criteria
How many acceptance criteria should a Jira story have?
There is no fixed number that suits every story. Write enough criteria to cover the intended outcome, the main user journey, and important exceptions. A small story may need only a few conditions, while a complex flow may need several distinct scenarios. If the list becomes difficult to review, check whether the story combines separate outcomes that could be planned independently.
Should acceptance criteria be written before development starts?
Ideally, the team agrees on the criteria before implementation begins. Early discussion lets the product owner, developer, and tester identify different assumptions while changes are still easy to make. Criteria can evolve when the team learns something new, but update the Jira issue and communicate the change. Starting work with unclear expectations can create rework and disagreements during acceptance testing.
Can acceptance criteria include technical requirements?
Yes, when a technical requirement directly affects the story’s outcome, security, performance, or compatibility. For example, a story may need a defined response time or a supported browser requirement. Avoid prescribing implementation details without a clear need. The team should have room to choose an appropriate design while still meeting observable conditions and relevant constraints.
Are acceptance criteria the same as test cases?
No. Acceptance criteria describe what must be true for a story to meet its intended outcome. Test cases describe specific steps and checks used to verify behavior. A single criterion can lead to several test cases, such as checking a valid reset link, an expired link, and an unregistered email address. Clear criteria help testers create relevant checks without dictating every testing step.
Conclusion
Clear Jira acceptance criteria reduce guesswork by defining what a story should do and how the team can verify it. Start with the user’s need, describe observable outcomes, cover important exceptions, and review the wording together.
When criteria are vague, developers and testers may make different assumptions, and rework becomes more likely. A short refinement conversation can expose gaps before they affect delivery.
Use the seven steps and examples as a practical starting point, then adapt the wording to your team’s workflow. The goal is simple: make each Jira story clear enough to build, test, and accept with confidence.