This is the most technical course in our Acceptance Testing collection - It is for  developers, programmers, engineers and software technologists  who turn ideas for new products into software. 

The course builds incrementally from finding and capturing Stories and Examples, expressing requirements as outcomes, and translating them into Executable Specifications. Learn techniques for building durable tests and infrastructure for Automated Acceptance Testing. 

What is Acceptance Testing?

Good Acceptance Tests are complex. Our aim in writing these high-level functional tests, is to make them understandable, stable and robust in the face of changes to the system or environment. What tools and techniques are effective? How can we avoid the common pitfalls which lead to tests that are difficult, fragile, slow and prone to intermittent failure. This course addresses these problems, by sharing proven approaches and demonstrating  techniques from complex projects, widely seen as world-class examples of the practices.

Acceptance Test Driven Development - is an approach to software development that focuses on the outcome/purpose of the software, and not the technologies or implementation details. This 'outside-in' approach results in better designed software, and replaces expensive manual testing with automated tests that are resilient to changes in requirements, allowing the software to be developed faster and with fewer defects. 

What’s in This Course?

This course explores “Acceptance Testing”, “Behaviour Driven Development (BDD)”, “Specification by Example” and the use of a “Domain Specific Language” in some detail. 

Through a mix of theory and worked examples, Dave Farley demonstrates the practices and techniques of high-level automated functional testing using “Executable Specifications” as the model for the behaviour of a system, and use this as a guiding principle for the development process.


The course starts with the question - "Why Acceptance Test?" and proceeds to explain:

  • The team roles and responsibilities of Acceptance Testing
  • Properties of Good Acceptance Tests
  • What to Test, 
  • How Test First Improves Design, and
  • Techniques we use to write effective Acceptance Tests that describe WHAT we want the system to do, and not HOW it will do it.

We explore the link between an effective, story-based, approach to requirements and practise the skills to map from Story to Acceptance Test. We share real world examples of Executable Specifications and set some problems for you to practise writing tests using these techniques:

  • Defining the Behaviour of the System
  • Event Storming - Understanding Your Problem
  • Capturing & Translating Requirements
  • Story-Mapping
  • Specification by Example
  • Domain Specific Language

The course is built around a "Four-Layer Approach" to organising and developing testing infrastructure to make tests easy to write, easy to understand, and flexible in the face of system change, and includes:

  • Acceptance Tests & BDD
  • Building a DSL for Testing
  • Test Isolation
  • Protocol Drivers and Stubs
  • Testing Asynchronous Systems
  • Testing Time
  • Dealing with Intermittent Tests


There are three exercises for you to apply what you have learned: 

  • To create specifications without implementation detail
  • Story-mapping, to capture narratives, activities and stories
  • Finding stories and examples - followed by a demo showing Dave's solution

There is also a recording of a live student workshop exploring a real-world problem, which demonstrates the sorts of conversations that you may expect to have, as you explore a problem with your domain experts. 

The Course concludes by looking at the scope of Acceptance Testing and Test strategy - how effective, efficient test cases in complex systems.

Course Objectives

  • To develop skills in the creation and use of “Acceptance Tests” in the form of “Executable Specifications”.
  • To practise effective story-writing using a combination of “Story Mapping” and “Specification by Example” techniques.
  • To learn how to create and use a “Domain Specific Language” to support the creation and maintenance of “Executable Specifications”.
  • To be able to build Acceptance Tests, as Executable Specifications, that are not compromised by changes in the system under test.


Our collection of 3 courses on Acceptance Testing is not a progression from 'basic' to 'advanced'. Each course has been tailored to suit the different roles that people play in software development. Pick the one course that is right for you.