Gherkin scenarios in Jira are often treated as the point where BDD becomes “real”. In practice, formulation is where BDD either becomes genuinely useful — or quietly turns into another artefact that people stop trusting.
Formulation sits between discovery and execution. It is the stage where discussions and examples are turned into something precise enough to review, reuse, and validate over time. When formulation is rushed or loosely structured, teams feel the impact later through confusion, rework, and brittle scenarios.
This article looks at what formulation actually involves in BDD, where teams struggle when doing it in Jira, and how structured scenario authoring makes BDD easier to sustain.
Formulation Is About Precision, Not Just Writing Gherkin
Formulation is often misunderstood as a purely technical task — “write the scenarios so they run”.
That framing misses the point.
The purpose of formulation is to describe behaviour clearly enough that:
-
product owners can read it and recognise their intent
-
testers can validate it consistently
-
developers can implement it without guesswork
Syntax matters, but clarity matters more. A perfectly valid scenario that still leaves room for interpretation is not doing its job.
Good formulation answers three questions unambiguously:
-
What behaviour is being described?
-
Under what conditions does it apply?
-
What outcome should be observed?
Where Gherkin Scenarios Commonly Go Wrong
Most teams don’t struggle because they don’t know Gherkin keywords. They struggle because formulation happens quickly and without enough structure.
Common issues include:
-
Scenarios that mix multiple behaviours into one
-
Overly technical steps that business stakeholders avoid reading
-
Inconsistent wording across similar scenarios
-
Duplicate steps written slightly differently over time
When this happens, scenarios stop acting as a shared language. They become something maintained by testers, while everyone else relies on assumptions.
At that point, BDD still exists — but its value is significantly reduced.
Why Formulation Works Better Inside Jira
Formulation is not a one-off activity. Scenarios are revisited throughout delivery — during refinement, development, testing, and review.
When Gherkin scenarios live outside Jira, they drift away from the decisions that shape them. Product owners lose visibility, developers work from partial context, and testers are left to reconcile intent after the fact.
Keeping formulation inside Jira changes that:
-
Scenarios stay linked to the user story they describe
-
Structure and wording can be reviewed collaboratively
-
Behaviour remains visible as work progresses
Formulation becomes part of the delivery workflow, not something that happens in parallel.
Supporting Structured Formulation with AssertThat
This is where the AssertThat plugin makes a practical difference.
Rather than providing a simple text area for Gherkin, AssertThat gives teams a purpose-built editor designed specifically for writing and maintaining BDD scenarios inside Jira.
Writing Features, Scenarios, and Rules with Consistent Structure
When you create a feature in AssertThat, you’re working in an editor that understands the structure you’re trying to express.
-
Features group related behaviour clearly
-
Scenarios follow a consistent Given–When–Then layout
-
Backgrounds are supported to reduce duplication
-
Scenario Outlines and Examples can be used where appropriate
Because the editor understands these constructs, it naturally encourages better organisation. You can quickly see:
-
what behaviour a scenario covers
-
where setup ends and action begins
-
what outcome is being asserted
That consistency becomes increasingly important as scenario sets grow.
Autocomplete and Validation to Reduce Syntactic Errors
Small syntax issues can waste a surprising amount of time.
AssertThat reduces this friction through:
-
Autocomplete for keywords and steps
– As you type, the editor suggests existing step phrases already used in the project
– This helps prevent small variations that lead to duplication -
Inline validation
– Missing keywords or malformed structures are flagged immediately
– Errors are caught while writing, not later during execution or review
This keeps the focus on behaviour, rather than fixing avoidable formatting problems.
Maintaining Readability Without Losing Precision
One of the hardest parts of formulation is balancing precision with readability.
Scenarios need to be:
-
specific enough to validate consistently
-
readable enough that non-technical stakeholders can engage
AssertThat helps by:
-
encouraging concise step phrasing
-
keeping formatting clean and predictable
-
presenting scenarios as structured language rather than code
The result is scenarios that can be read, discussed, and reviewed — not just executed.
Step Reuse Across the Project
Over time, step duplication becomes one of the biggest maintenance issues in BDD.
Small wording differences add up:
-
“Given the user is logged in”
-
“Given a logged-in user”
-
“Given the user has logged in”
AssertThat addresses this by:
-
referencing the existing step library as you write
-
suggesting steps already used elsewhere in the project
-
encouraging reuse rather than creating near-duplicates
This keeps scenarios more consistent and significantly reduces maintenance effort as projects scale.
Why Good Formulation Makes Everything Easier
Teams often underestimate how much formulation affects later stages of BDD.
When scenarios are clearly structured and consistently written:
-
automation is easier to maintain
-
execution results are easier to interpret
-
refinement becomes safer and more predictable
When formulation is weak, teams end up compensating later — rewriting steps, clarifying intent, and revisiting decisions that should have been settled earlier.
Final Thoughts
Formulation is where BDD becomes usable.
Treating Gherkin scenarios as a shared specification inside Jira — rather than a technical by-product — makes a tangible difference to how well BDD holds up over time. Clear structure, consistent wording, and visible intent all reduce friction across delivery.
Good formulation won’t solve every problem, but poor formulation almost always creates them.
