Specification by Example (SBE) helps to deliver the software product based on the user’s requirements. Specification by Example is called Acceptance Test Dest-Driven Development (A-TDD), a requirement discovery approach to create executable specifications using examples and automated testing.

Specification by Example is a collaborative process to define and verify the requirements of the software products. Specification by Example delivers a user’s expected software by avoiding ambiguity and rework.

In this article, let us see how to manage and maintain specification by example tests across multiple iterations and releases.

SBE Overview

Specification by Example is created to deliver the desired product using realistic examples instead of abstract statements. In this section, let us see the objective, benefits, uses, and applications of Specification by Example. 

The Objective of Specification by Example (SBE)

The primary objective of the Specification by Example is to create the right product. It establishes a single source of truth through a shared understanding of the software product from development to delivery.

Specification by Example promotes testing in the early stage of the software lifecycle. By enabling the automation testing of acceptance criteria, SBE shifts the focus from defect detection to defect prevention.

Benefits of the Specification By Example (SBE) Tests

Specification by Example is a single source of truth of the product requirements and specifications. The specification By Example test gives different advantages to agile teams. SBE defines the shared understanding between stakeholders, testers, and developers.

Specification by Example supports TDD and BDD. SBE enables automation testing and ensures the software functionality and quality through frequent validation and validation.

The main benefit of Specification by Example (SBE) is that it provides automation testing to ensure that these tests can reduce defects and ambiguity and improve the collaboration and communication between the stakeholders and team in the software development lifecycle process.

Uses of Specification by Example (SBE) Test

The Specification by Example test demonstrates the expected software system behavior that describes the business values. It demonstrates the real-time example of the development process. Then, these examples generate the executable requirements that are testable without translation and captured in live documentation. The SBE Test is easy to understand and interpret. These are the reasons why example tests are used to describe particular specifications.

Applications of Specification by Example (SBE)

The Specification by Example has various applications, such as

  • SBE eliminates the common misunderstanding about the requirements of the business
  • It significantly reduces the feedback loop in the software development lifecycle.
  • SBE helps to create the environment tickets and executable specifications.
  • A documentation system from specifications with examples to support future development is evolving.
  • Specification by Example (SBE) reduces the risk of production defects.

Best Practices to Manage and Maintain Specification by Example Test Across Multiple Iterations and Releases

The Agile team adheres to the best practices to manage and maintain the SBE test effectively, efficiently, and valuably. The SBE Test has three techniques as

  1. Example Mapping
  2. Specification Workshops
  3. Three Amigos Sessions

These techniques involve the relevant stakeholders, testers, and developers in creating, reviewing, and executing the test examples with automation testing.

Example Mapping: It uses multiple examples to clarify and convey the information about the concept. This technique creates a common understanding between Stakeholders and the agile team.

Specification workshop: The specification workshop establishes a collaboration between the agile team, testers, and business to develop a requirement specification.

Three Amigos Sessions: The Three objectives of the sessions are specification, Automation Testing Scenarios, and New Features. Three Amigos Sessions focuses on collaboration between business analysts, developers, and testers during software development and testing.

Various cloud-based testing tools cover different aspects of software testing, such as load testing, regression testing, acceptance testing, and integration testing. Cloud testing involves scalability, reliability, and performance in a cloud environment. In the context of SBE, software development and automation testing tools such as Gherkin, Cucumber, SpecFlow, and LambdaTest are used to create a clear and consistent format and structure for the Specification by Example Test.

Cloud testing platforms like LambdaTest help you automate complex or uncertain scenarios with specifications. LambdaTest is an AI-powered test orchestration and execution platform that empowers developers and testers to perform automated testing seamlessly on over 3000+ real browsers and operating system combinations.

Each SBE automation testing tool has its specifications and functionality.

  • Gherkin: Gherkin is used to improve the effectiveness and clarity of the user stories. The Gherkin is popular among the Behavior-Driven Development (BDD) community because it is a cucumber format specification with the cause and effect of an idea with a concept of input and output process. 
  • Cucumber: Cucumber is used to develop test cases for software product functionality. It supports BDD and automation testing. Test cases developed by Cucumber are easy to use and understand. Cucumber is both a functional automation testing tool and a functional performance tool.
  • SpecFlow: SpecFlow is an open-source BBD framework for DotNet developers. It helps define, manage, and execute automation testing. It supports writing test cases in multiple programming languages.
  • FitNesse: FitNesse is an open-source framework for Wiki-based test systems wherein teamwork is possible on test cases between those who do the development programming, testers, and application users.

To make the example test efficient, unnecessary data or details that do not have any influence over the test cases are dropped. Invalid test cases are either updated or removed to keep the consistency in test case execution. SBE test cases are frequently tested using automation testing tools such as Jenkins or Travis CI, and reports from the testing are recorded and reported for feedback.

Scripts and Scenarios

Scripts are step-by-step syntax written in a particular programming language used to test the specific functionality of the application or software. It is used to verify the performance of the software function under automation testing.

Scenarios are sets of descriptions for the user’s goal, actions, and expected result or outcome. Scenarios are usually written in natural languages. Scenarios are also called test conditions, which describe sequential actions the tester should take while testing the software. One Scenario can cover one or many test cases at a time.

Scenarios are more flexible than scripts, and with the help of tools like Cucumber and FitNesse, Scenario can generate automatic test scripts. So, scenarios are preferred over Test Scripts.

Early involvement of Stakeholders

The SBE test’s important function is maintaining a collaborative environment between stakeholders, developers, and testers. The involvement of stakeholders in the early stage of development and testing will help analyze their requirements and specific needs.

The Stakeholders also give valuable real-world data and examples. Involving them early will also elicit and validate the requirements, clarify the assumption about the real-world insights and examples, resolve conflicts among the teams, and get feedback on the software development and automation testing.

Given-When-Then (GWT) Format

The given-when-then (GWT) Format is a structured writing approach for drafting the Acceptance criteria or Scenarios. It provides a template to guide acceptance test writing for user stories. The format comprises three parts: Given, When, and Then. Each part provides specific information about the requirements of the user story.

The Format is as follows:

  • Scenario description: This contains the description of every scenario created during the software automation testing.
  • Given: The Given describes all the given conditions and pre-conditions.
  • When: When describes the particular action or event that triggers the scenario.
  • Then: Then describe the outcome of the action or postcondition.

The Given-When-Then format creates clear communication and testability by reducing or avoiding unnecessary details.

Tables and Examples

In the SBE test, sometimes, a single scenario can not cover the multiple scripts and all the possible variations and combinations of the features. The tables and examples cover multiple scenarios with different inputs and outputs in such cases.

The table and examples not only cover multiple scenarios but also reduce duplication among the scenarios and improve the readability of the scenarios. For example, the table can compare different pricing options, and an example can search different criteria.

Error and Exception handling

The  Exception handling handles errors during the automated testing and responds to different error states. So, preparation is to be done to handle the errors that occur during the execution of scenarios.

Error and Exception handling should be pre-defined to ensure the flow of the execution of the scenarios. The Software should be ready to handle exceptions like entering an invalid input, network failure, and security breaches.

The Given-When-Then format can specify exceptions or unexpected error conditions and expected behavior or messages.

Reviewing and Refactoring the test cases

Refactoring is a method to rewrite or modify the internal code without changing the external appearance of the written code. The SBE test should be considered and reorganized regularly to ensure that the test cases are adequate, correct, and maintainable. This code becomes less difficult to update and extend when refactoring. It also makes the test cases reusable.

Naming conventions, tags, categories, and folders can be applied to organize the test. Test cases can be made simpler and more readable by parameterization, abstraction, and encapsulation.

In certain conditions, the test code quality will certainly receive an improvement from regular check-ups and monitoring. Tools such as support include version control (GIT) or Live Code Analysis with feedback reports.

Living Documentation

Living documentation should be accessible to all and collaboratively written by many actors, such as Stakeholders, Developers, and testers. Living Documentation is a set of feature records verified and updated automatically after every automation testing. This is also known as dynamic documentation.

The specification records should be short, efficient, and simple. The records must be organized to update them as work progresses.


In conclusion, effective management of Specification by Example (SBE) tests is important for successful software delivery. Collaborative techniques like Example Mapping and Three Amigos Sessions, along with automation tools such as Gherkin and Cucumber, ensure clarity and consistency in testing. Early stakeholder involvement provides valuable insights and promotes a collaborative environment.

Adhering to the Given-When-Then format, using tables and examples, and implementing error handling contribute to reliable Specification by Examples (SBE) tests. Regular review and refactoring, supported by version control, maintain test relevance and accuracy. Living Documentation, updated automatically after each testing cycle, ensures dynamic and accessible records. Embracing these practices enhances communication, reduces ambiguity, and facilitates the delivery of high-quality software products.