In the realm of Agile development, user stories serve as essential building blocks for communication between development teams and stakeholders. However, to ensure these stories are implemented correctly and meet the desired objectives, acceptance criteria are indispensable. Acceptance criteria provide the specific conditions and expectations that a user story must fulfill to be considered complete. But what’s the best way to structure these criteria? In this article, we delve into three popular acceptance criteria templates: Given-When-Then, Behavior-Outcome-Expectation, and Role-Feature-Reason. We will explore the pros and cons of each template and discuss when and how to use them effectively.

Common Acceptance Criteria Templates

Acceptance criteria are essential for defining the scope of a user story and ensuring that the development team understands what needs to be implemented. Here are three common templates:

  1. Given-When-Then (GWT):
    • Given: A precondition or context that sets the stage.
    • When: The action or event that triggers the user story.
    • Then: The expected outcome or result.


    • Given a registered user is logged in
    • When they click the “Add to Cart” button
    • Then the item should be added to their shopping cart
  2. Behavior-Outcome-Expectation (BOE):
    • Behavior: The action or behavior the user story is addressing.
    • Outcome: The result or state change expected from that behavior.
    • Expectation: Any additional details or conditions.


    • Behavior: User submits a contact form
    • Outcome: An email containing the form data is sent to the support team
    • Expectation: The email contains the user’s contact information and message
  3. Role-Feature-Reason (RFR):
    • Role: The role or persona involved in the user story.
    • Feature: The specific feature or functionality being described.
    • Reason: The purpose or justification for the feature.


    • Role: Admin
    • Feature: Ability to delete user accounts
    • Reason: To maintain the integrity of the user database and remove inactive accounts

These are just a few examples of acceptance criteria templates. The choice of template often depends on the team’s preference and the complexity of the user story. It’s important that acceptance criteria are clear, specific, and testable to ensure that the user story is implemented correctly. Additionally, acceptance criteria should cover both functional and non-functional requirements as needed for the user story.

Summarizing the Acceptance Criteria Templates

Here’s a table comparing the pros and cons of the three acceptance criteria templates (Given-When-Then, Behavior-Outcome-Expectation, and Role-Feature-Reason) along with their related aspects:

Aspect Given-When-Then (GWT) Behavior-Outcome-Expectation (BOE) Role-Feature-Reason (RFR)
Clarity Provides a clear structure for expressing user story requirements. Explicitly separates behavior, outcome, and expectations for clarity. Emphasizes the role, feature, and reason for better understanding.
Testability Easy to convert into test cases. Encourages specifying testable conditions for validation. Can be used to derive test cases by focusing on roles and features.
Flexibility Suitable for a wide range of user stories, from simple to complex. Allows flexibility in describing user interactions and expected results. Adaptable to various scenarios and helps in justifying the need for features.
Readability Readable and understandable by both technical and non-technical team members. Concise and structured, making it easier for stakeholders to review. Provides context for why a feature is needed, aiding in prioritization.
Overhead Can become verbose for very complex user stories, leading to lengthy criteria. Might not capture certain non-functional requirements or constraints. Requires additional explanation if the role, feature, or reason is not obvious.
Lack of Context May not capture the overall context of the user story effectively. Could miss out on broader business goals or motivations behind the user story. Relies on stakeholders understanding the role, feature, and reason implicitly.
Not Ideal for Non-Functional Req. Less suitable for specifying non-functional requirements (e.g., performance, security). May not emphasize non-functional aspects unless explicitly included in expectations. Non-functional requirements may be overlooked if not explicitly stated.

These are some of the key pros and cons associated with each of the acceptance criteria templates. The choice of template should consider the specific needs of the user story, the project, and the team’s familiarity with the template. In practice, teams often use a combination of these templates as needed to provide comprehensive acceptance criteria for user stories.


User story acceptance criteria play a crucial role in Agile software development, defining the boundaries and expectations for each story. To optimize this process, this article compares three widely used acceptance criteria templates: Given-When-Then, Behavior-Outcome-Expectation, and Role-Feature-Reason. We examine the strengths and weaknesses of each template, providing insights into when to apply them based on the complexity of the user story and the team’s needs. By the end, you’ll have a clear understanding of how to choose the most suitable template to craft effective acceptance criteria for your Agile projects.


Leave a Comment

Your email address will not be published.