High Impact Gherkin Applied to Sprint Planning

While developing software, ensuring that a product meets user expectations and business requirements is paramount. One essential tool in achieving this goal is the practice of writing acceptance criteria. Acceptance criteria define how a specific feature should behave from an end user's perspective, guide development, and establish the conditions for the success of that feature.

Acceptance Criteria

Well-written acceptance criteria focus on the following key aspects:

  1. User Perceptive: they describe how a feature can be used from an end user's viewpoint.
  2. Scope Boundary: acceptance criteria establish boundaries, delineating what's included and excluded from the tickets scope.
  3. User Experience: they inform both the product behavior in the happy path and in the unhappy path, providing scenarios to guide which acceptance tests to verify.
  4. Success Confirmation: A clear pass/fail outcome allows for automated testing.

Tips for Writing Acceptance Criteria

  • At Least One Criterion: Each user story should have at least one acceptance criterion.
  • Write Before Implementation: Draft acceptance criteria before starting development to ensure a shared understanding.
Pro Tip: For team that operate using Scrum the best time to write acceptance criteria is during product backlog grooming sessions.
  • Independtly Testable: Each criterion should be independtly testable.
  • Clear Pass/Fail Result: Criteria should have a clear/pass fail result. The best writtena acceptance criteria leave no room for ambiguoity.
  • Focus on the End Result: They focus on the end result or behavior, not the approach to the technical solution.
  • Include Functional and Non-Functional Criteria: Include both functional and non-functional criteria (e.g., performance, availability, reliability) when relevant.
  • Collaboration: Scrum team members write acceptance criteria, and the Product Owner verifies them, ensuring a shared understanding.
  • Challenges: Avoid criteria that are too narrow, too broad, or overly complex. Focus on simplicity and clarity.
  • Rule of Thumb: Aim for 1-3 acceptance criteria per user story. If there are 4 or more, consider splitting the story.

Gherkin: Structured Language for Acceptance Criteria

Gherkin is a structured language commonly used for writing acceptance criteria. It is primarily associated with Behavior Driven Development (BDD) and is used to create executable specifications for testing. Gherkin is designed to be easily understood by both technical and non-technical stakeholders, making it a valuable tool for collaboration between different teams involved in software development.

Gherkin follows a specific syntax:

  • Feature: Describes the functionality being tested.
  • Scenario: A label for the behavior you're describing.
  • Given: The initial state or context of the scenario.
  • When: A specific action taken by the user.
  • Then: The testable outcome, typically resulting from the action in the "When" step.
  • And: This continues any of the other three operators.

Example of Gherkin Scenario:

Feature: User Logout

    Scenario: User clicks on the log-out button
        Given: The user is logged in
        And the user is on the profile screen
        When: the user clicks on the log-out button
        Then: the user should be logged out
        And the user should be redirected to the home page

Generalization of Gherkin Scenario:

    Scenario: Some Determinable Business Situation
        Given: Some precondition 
        And some other precondition
        When: Some action by the actor
        And some other action
        And yet another action
        Then: Some testable outcome is achieved 
        And something else we can check happens too

Benefits of using Gherkin in Software Development and Testing:

  1. Clarity and Understandability: Gherkin's structured language and plain text format make scenarios easy to understand. This clarity enhances communication among team members, leading to a shared understanding of requirements.
  2. Test Automation: Gherkin scenarios can be automated, allowing for the automatic execution of tests. This automation accelerates the testing process, increases test coverage, and provides rapid feedback on whether the software functions as intended.
  3. Behavior-Driven Development (BDD): Gherkin is a fundamental component of BDD, which fosters collaboration between cross-functional teams. BDD promotes a user-centric approach to development, ensuring that software aligns with business goals and user needs.
  4. Reusable Steps: Gherkin allows for the creation of reusable steps, reducing redundancy in scenario writing and promoting consistency across tests. This feature simplifies test maintenance and ensures that common actions are defined consistently.

Benefits of using Gherkin for Product Managers

  1. Alignment with Business Goals: Gherkin scenarios closely tie software behavior to user needs and business objectives. Product Managers can use Gherkin to ensure that development efforts align with strategic goals and customer requirements.
  2. Validation of Product Vision: Gherkin scenarios provide a tangible way to validate the product vision and user stories. Product Managers can use Gherkin to create concrete examples of how the product should function, helping to confirm that it meets customer expectations.
  3. Prioritization: Gherkin scenarios can assist in prioritizing feature and requirements based on their business impact. Product Managers can use Gherkin to highlight critical functionality and ensure that high-priority items are thoroughly tested.
  4. Quality Assurance: Gherkin scenarios serve as a quality assurance tool. Product Managers can use Gherkin to define acceptance criteria for user stories and ensure that the delivered product meets those criteria, maintaining a high level of quality.


Writing acceptance criteria using Gherkin is a powerful practice in software development. It ensures that features meet user expectations, helps catch missing requirements early in the development process, and provides a shared understanding among team members. By focusing on user behaviors and using Gherkin, teams can deliver high-quality software that aligns with business goals.

Remember, in software development, the focus should always be on the user and their behaviors, not just the technical details. Acceptance criteria, written in Gherkin can be your key to success.  

If you are working to solve any of these problems then please consider working with us getstarted@peacockconsulting.com. We have had continued success accelerating software delivery and implementing all of these topics at scale.

© 2024 Peacock Consulting