Frequently asked questions

Behavior-Driven Development (BDD) is an innovative software development approach that focuses on defining the behavior of an application from the perspective of its stakeholders. Central to BDD is the use of a common, ubiquitous language to describe system behavior, fostering collaboration between developers, QA, and non-technical stakeholders. This approach emphasizes continuous example-based communication, with scenarios written in natural language to describe system functionality.

With AssertThat BDD & Cucumber for Jira, Cucumber test results are published directly into Jira from your CI/CD pipeline using standard Cucumber JSON reports. Once uploaded, results are visible inside Jira issues and dedicated execution views, showing pass/fail status, execution history, logs, and linked requirements.

This allows teams to track automated BDD execution without leaving Jira, providing full traceability between requirements, scenarios, and test outcomes.

AssertThat enables teams to practice BDD entirely within Jira by authoring Gherkin feature files, linking scenarios to Jira issues, and managing execution results in one place. Business analysts can write acceptance criteria in Gherkin, testers can execute scenarios manually or automatically, and developers can integrate those same scenarios into automation pipelines.

This makes Jira the central collaboration hub for BDD, rather than just a backlog tool.

You can browse all BDD and Cucumber-related plugins on the Atlassian Marketplace by searching for keywords such as BDD, Cucumber, or test management. Each listing includes feature descriptions, pricing, hosting compatibility, and customer reviews.

AssertThat BDD & Cucumber Test Management for Jira is listed on the Marketplace with full Cloud and Data Center support.

Traditional development often defines requirements separately from tests, leading to misinterpretation and late feedback. BDD differs by expressing requirements as executable examples written in a shared, structured language before development begins.

Instead of testing after implementation, BDD encourages collaboration upfront, using scenarios to define expected behaviour that can later be automated and verified continuously.

Cucumber is a testing framework that supports BDD by executing specifications written in Gherkin. BDD is the methodology, while Cucumber is one of the most widely used tools that implements it.

AssertThat bridges Cucumber and Jira by allowing Gherkin scenarios to be managed as first-class artefacts inside Jira, rather than existing only in code repositories.

Gherkin is a structured, plain-text language used to describe system behaviour using keywords such as Feature, Scenario, Given, When, and Then. Its purpose is to make requirements readable by both technical and non-technical stakeholders.

AssertThat provides a Jira-native editor for Gherkin, supporting Scenario Outlines, Examples tables, tags, and validation to ensure compatibility with Cucumber automation.

BDD and Cucumber help teams align on expected behaviour early, reduce rework, and improve test coverage through executable specifications. Scenarios serve as both documentation and tests, keeping requirements and verification tightly coupled.

When combined with Jira via AssertThat, these benefits extend to improved traceability, clearer acceptance criteria, and better visibility of quality throughout the delivery lifecycle.

BDD uses examples written in business-readable language rather than technical specifications. This allows product owners, analysts, testers, and developers to collaborate using the same artefacts.

By managing Gherkin scenarios directly in Jira, AssertThat ensures these shared conversations remain visible, reviewable, and actionable for all roles.

Effective BDD scenarios should describe behaviour, not implementation, and focus on observable outcomes. They should be concise, consistent, and written from the user or business perspective.

AssertThat supports these practices by encouraging reusable steps, validating syntax, and allowing scenarios to evolve from manual acceptance criteria into automated tests without duplication.

Yes. BDD scenarios written in Gherkin can be automated using many frameworks, including Selenium, Playwright, Cypress, REST clients, and custom test runners. Cucumber acts as the execution layer, while AssertThat manages the lifecycle in Jira.

This allows teams to integrate BDD seamlessly with CI/CD pipelines, source control systems, and existing automation stacks while keeping Jira as the central source of truth.

With AssertThat BDD & Cucumber for Jira, you can create, edit, and manage Gherkin feature files natively inside Jira — without needing an external editor. Every Scenario, Scenario Outline, Background, and Examples table can be authored in the feature editor and stored directly against your Jira project.

The editor supports multi-line steps, fast auto-completion of Given/When/Then syntax, and a clean layout that mirrors standard Cucumber conventions. Teams can write acceptance criteria in the language of the business, attach them directly to user stories, and keep test intent visible throughout the development lifecycle.

This ensures your BDD process is centralised in Jira, reducing friction between BAs, QAs, and developers. For more information see the full product walkthrough video

Yes. AssertThat supports the full Gherkin syntax specification, including:

• Scenario
• Scenario Outline
• Examples tables
• Background sections
• Step Tables
• DocStrings
• Tags (@smoke, @regression, @wip, etc.)

Every element is rendered and stored exactly according to the Cucumber standard. You can create complex scenarios, parameterised test outlines, shared backgrounds, and tagged execution groups — all directly within Jira.

This ensures compatibility with all major Cucumber runners (Java, JS, Ruby, .NET, Python) and avoids vendor lock-in.

More information can be found in this video – Add BDD Scenarios in Jira with AssertThat Plugin

AssertThat doesn’t currently support Rules.

Yes. AssertThat performs live validation of Gherkin syntax as you author scenarios. The plugin automatically checks:

• Correct Given/When/Then/And/But structure
• Valid Examples tables
• Duplicate or conflicting scenario names
• Missing parameters in Scenario Outline examples
• Malformed tags or formatting errors

The plugin also has shortcut keys to easily format the scenarios and to auto complete steps. See video Add BDD Scenarios in Jira with AssertThat Plugin

Validation happens instantly, so teams catch issues before running tests or pushing changes to automation pipelines.

This helps maintain high-quality feature files and reduces failures caused by incorrect syntax in CI/CD.

AssertThat supports step reuse and standardisation to prevent duplication and ensure consistent behaviour definitions across Jira projects.

Key capabilities include:

• Reusing existing steps from other scenarios or features
• Searching for matching steps while writing new ones
• Encouraging business-level language that can be shared across teams
• Reducing maintenance by centralising common patterns

For large organisations, shared steps help enforce consistent test language, accelerate scenario creation, and simplify onboarding for new team members.

Yes. AssertThat supports importing existing .feature files directly into Jira. You can:

• Upload feature files individually
• Bulk-import multiple files from your local machine
• Import feature definitions from Git repositories via our Maven/CLI integration
• Map imported features to Jira stories or epics

The importer preserves all original Gherkin syntax — including tags, examples tables, comments, and formatting.

This is ideal for teams migrating from standalone Cucumber frameworks or centralising multiple repositories into Jira.

AssertThat provides native integrations to connect your automated Cucumber tests to Jira. You can:

• Use our Maven plugin
• Use the REST API
• Commit results from CI/CD pipelines (Jenkins, GitHub Actions, GitLab CI, Bamboo, Azure DevOps)
• Upload standard Cucumber JSON reports
• Automatically link executed scenarios to Jira issues

Once uploaded, test results appear directly in Jira with:

• Execution status
• Pass/fail trends
• Error messages
• Console logs
• Linked user stories

This closes the loop between requirements, scenarios, automation, and reporting — all inside Jira. For more information integrations please see our confluence pages

Yes — AssertThat supports a flexible hybrid execution model where scenarios authored in Jira can be executed either manually or automatically — and both result types feed back into the same scenario history, reporting and traceability. Here’s how it works in detail:

How hybrid execution works:

• You author . feature files in Jira (or import them) and link them to user stories or requirements.
• At first, a tester or business-analyst may execute a scenario manually (e.g., using the built-in test run screen inside Jira).
• Later, when the scenario becomes stable, you can automate it in your CI/CD pipeline (e.g., using Cucumber, GitHub Actions, Azure DevOps or other frameworks).
• When your automation runs, the plugin automatically uploads results (via the REST API or other supported upload mechanism) and updates the same scenario in Jira — so it’s exactly the same scenario definition, but now with automated execution history.
• Both manual and automated executions are visible in the scenario’s history tab in Jira, so you retain full traceability of “how many times executed manually vs via automation”, pass/fail results, and links back to the user story or requirement.
• You can continue to run some scenarios manually (e.g., exploratory, ad-hoc, or maintenance runs) while others transition to full automation — and this doesn’t require duplicating scenario definitions or maintaining parallel manual vs automated tracks.

Key benefits for your team:

• Single source of truth: You don’t need separate definitions for manual vs automated tests — the same Scenario or Scenario Outline in Jira serves both.
• Smooth transition to automation: As automation matures, you simply hook the same scenarios into CI/CD rather than starting anew.
• Traceability and reporting: Because the results from both manual and automated executions are aggregated in Jira, you get unified reporting (pass/fail trends, execution frequency, history) regardless of execution mode.
• Reduced maintenance overhead: No need to maintain two parallel sets of tests; your teams can evolve manual runs into automation without rewriting definitions.

AssertThat BDD & Cucumber for Jira enables seamless integration with Git repositories, so your teams can collaborate across Jira and Git workflows.

• Supports pulling and pushing feature files with Git providers: GitHub, GitLab, Bitbucket, Azure Repos.
• Two sync models documented: AssertThat as master (feature files owned in Jira and synced to Git) and Git as master (feature files owned in Git and synced into Jira). Reference the workflows:
  • Azure DevOps (AssertThat as master)
  • Azure DevOps (Azure DevOps as master)
  • GitHub (AssertThat as master)
  • GitHub (GitHub as master)
• This allows developers to work in Git and business analysts/testers to work in Jira without duplicating feature definitions or losing version control.

With this setup, you maintain synchronized versioning, consistent feature-file definitions, and full traceability across both environments, supporting flexible workflows and reducing maintenance overhead.

BDD test management allows teams to create, manage and execute Behaviour-Driven Development scenarios directly within Jira. AssertThat provides an integrated workflow for writing Gherkin scenarios, linking them to user stories and tracking both manual and automated test results in one place.

Yes. AssertThat includes a native Gherkin editor with syntax highlighting, autocomplete, validation and full support for BDD elements like Features, Backgrounds, Rules and Scenario Outlines. All scenario authoring happens inside Jira with no external tools required.

Yes. You can upload Cucumber JSON results from any CI/CD pipeline. AssertThat links the results back to the correct scenarios and updates the execution status in real time, giving full visibility across automated test runs.

AI-Driven BDD: Using AI to Generate and Refine BDD Scenarios

AI scenario generation is live. Enable it per project, then click Generate Scenarios in the Acceptance Tests panel of any Jira issue: AI drafts BDD scenarios from the issue title and description, and you accept or discard each one before anything is saved. You can also refine an existing scenario with AI. Advanced subscriptions include the AssertThat default model with no API key needed; on Standard you bring your own OpenAI, Claude or Azure OpenAI key.

Read the AI test case generation guide

Yes. AssertThat supports both manual and automated BDD scenarios. You can run manual executions inside Jira, track outcomes, and combine them with automated results in Test Plans and dashboards for a complete view of test coverage.

Test Plans allow you to group BDD scenarios for specific releases or regression cycles. You can clone plans, lock scenario details for stability, monitor execution status and analyse progress using Test Plan reporting and dashboards.

Yes. AssertThat integrates with any CI/CD pipeline, including Jenkins, GitHub Actions, GitLab, Bitbucket, Bamboo and Azure DevOps. You can export scenarios for automation and import automation results back into Jira via our APIs.

Absolutely. AssertThat supports project-level configuration so organisations can define consistent BDD workflows, tagging rules, scenario structures and review processes. This helps maintain shared standards while allowing teams to customise where needed.

AssertThat includes dashboard gadgets and reporting views designed for programme or enterprise-level insights. You can track coverage, execution trends, adoption levels and problem scenarios across multiple Jira projects.

Yes. The Scenario Manager allows you to filter and select multiple BDD scenarios and update steps, tags, execution mode or linked issues in bulk. It’s ideal for large-scale refinement or release-based updates.

Yes. You can import existing Feature files using the Upload function or integrate via custom APIs to migrate scenarios from other test management tools or repositories. Structure, tags and scenario content are preserved.

Yes. AssertThat provides interactive traceability views showing how Features and Scenarios map to Jira issues, including execution status. This helps teams understand coverage, dependencies and readiness for release.

Yes. AssertThat fully supports Jira Cloud and Jira Data Center, with feature parity across platforms and flexible deployment options.