Agile Testing with Acceptance Test-Driven Design (ATDD) & Behavior-Driven Development (BDD)

Foundations

Agile Testing

Testing as a continuous, whole-team activity that builds quality in throughout development rather than inspecting it at the end.

Built-In Quality

Practices that ensure each increment meets quality standards as it is built, reducing rework and enabling fast, reliable delivery.

Whole-Team Quality

Quality is owned by the whole team, not a separate QA phase; developers, testers, and the PO collaborate on it.

Shift Left

Moving testing and quality activities earlier so defects are prevented or found when they are cheap to fix.

ATDD

Acceptance Test-Driven Development (ATDD)

Collaboratively defining acceptance tests before development so the team shares a clear, testable definition of what to build.

Acceptance Criteria

Conditions a story must satisfy to be accepted; in ATDD they become concrete acceptance tests.

Executable Specification

An acceptance test written so it can be run automatically, doubling as both requirement and verification.

Specification by Example

Clarifying requirements with concrete examples that become the acceptance tests, reducing ambiguity.

BDD

Behavior-Driven Development (BDD)

An approach that describes system behavior in business-readable language, fostering shared understanding and executable specifications.

Given-When-Then

A structured format describing context (Given), action (When), and expected outcome (Then) for a behavior.

Gherkin

A business-readable, structured language (Given/When/Then) used to write BDD scenarios that tools can automate.

Feature and Scenario

A feature groups related behaviors; a scenario is one concrete example of a behavior expressed in Given-When-Then.

Ubiquitous Language

A shared vocabulary between business and technical people that BDD scenarios use to avoid miscommunication.

Collaboration

The Three Amigos

A conversation among business (PO), development, and testing perspectives to define behavior and examples together before coding.

Discovery, Formulation, Automation

The BDD cycle: discover behavior through conversation, formulate it as scenarios, then automate them as tests.

Living Documentation

Automated BDD scenarios that stay in sync with the system and document its behavior accurately over time.

Automation

Test Automation

Automating acceptance and regression tests so they run frequently, giving fast feedback and enabling continuous integration.

Test Automation Pyramid

A guide to balance many fast unit tests, fewer service/API tests, and few slow UI tests for efficient coverage.

Continuous Integration

Frequently integrating and testing changes so defects surface early and the system stays working.

Cucumber / BDD Tools

Tools that execute Gherkin scenarios by binding steps to code, turning specifications into automated tests.

Regression Testing

Re-running tests to ensure new changes don't break existing behavior, made feasible by automation.

Practices

Test-First Mindset

Defining how you'll know something works before building it, which clarifies requirements and drives design.

Definition of Done

Quality criteria — including passing tests — that work must meet to be considered complete.

ATDD vs. TDD

ATDD/BDD focus on business-facing acceptance behavior; TDD focuses on developer-facing unit design. They complement each other.