Acceptance Test-Driven Development (ATDD)

What is Acceptance Test-Driven Development (ATDD)?

Acceptance test-driven development (ATDD) is a practice in which the business, developers and testers agree acceptance tests for a feature before development, and the feature is built until those tests pass.

Updated November 2026 · 3 min read


Acceptance test-driven development (ATDD) is a practice in which the business, developers and testers agree on acceptance tests for a feature before development starts, and the feature is then built until those tests pass. The tests describe the feature from the user's point of view: what it must do for the work to be accepted. Because they are written first and agreed together, they turn vague requirements into precise, checkable examples and give everyone the same picture of "done."

The idea grew out of Extreme Programming, which called for customers to define acceptance tests for each story, and from Ward Cunningham's Framework for Integrated Test (FIT), released in 2002, which let business people express tests as simple tables that ran against the software. Later books gave the practice its current shape, including Ken Pugh's Lean-Agile Acceptance Test-Driven Development (2011) and Gojko Adzic's Specification by Example (2011), which uses that name for much the same approach.

How ATDD Works

  1. Discuss. Before a story enters development, the product owner, a developer and a tester review it together and work through concrete examples: normal cases, edge cases and error cases. Questions nobody can answer are taken back to the business.
  2. Distill. The examples are written up as acceptance tests in a clear, unambiguous form, such as a table of inputs and expected outputs or a set of Given-When-Then scenarios.
  3. Develop. Developers build the feature, typically using test-driven development for the code underneath, until the acceptance tests pass.
  4. Demo. The passing tests and the working feature are shown to the product owner, who accepts the story or identifies what was missed.

Where possible the acceptance tests are automated, so they run with every change and protect the feature from later regressions. Tools such as FitNesse, Robot Framework and Cucumber are common, but ATDD can start with tests written in a shared document and run by hand.

ATDD and BDD

ATDD and behavior-driven development share the same core: collaboration on examples before development, and those examples becoming tests. The differences are mostly of emphasis. ATDD focuses on acceptance criteria and whether a story meets them, and is open about format. BDD puts more weight on describing behavior in a common business language and is closely tied to the Given-When-Then structure and tools such as Cucumber. Many teams use the terms interchangeably.

Benefits

  • Fewer misunderstood requirements. Concrete examples expose ambiguity early. "Customers get a discount for bulk orders" becomes "10 to 49 units get 5% off, 50 or more get 10% off," and someone asks what happens at exactly 50.
  • Testing starts on day one. Testers shape the requirement instead of discovering problems at the end of a sprint, which is one form of shift-left testing.
  • A shared definition of done. Developers know when to stop, and product owners know what they will get.
  • A regression suite tied to business value. Automated acceptance tests check that features still do what the business needs.

An Example

Consider a hypothetical logistics company adding a delivery-fee calculator. In a 20-minute discussion, the product owner, developer and tester agree on this table of acceptance tests:

WeightDistanceExpected fee
2 kg10 km$5.00 (base fee)
2 kg60 km$7.50 (base plus $0.05 per km over 10 km)
25 kg10 km$12.00 (heavy-item fee)
0 kg10 kmRejected: weight must be greater than zero

Writing the second row prompts the question of whether the distance surcharge applies to heavy items, and the product owner decides it does. That rule would otherwise have been discovered by a customer. The developer builds the calculator until all the rows pass, and the table stays in the test suite as the specification.

Common Pitfalls

  • Writing acceptance tests after development, which turns ATDD into ordinary test automation and loses its main benefit.
  • Leaving the business out, so testers and developers guess at the rules.
  • Testing everything through the user interface, which makes suites slow and fragile.
  • Too many low-value examples. A handful of well-chosen cases, including boundaries, usually say more than dozens of similar ones.

ATDD makes acceptance criteria executable and gives teams an objective definition of done for each user story.