Deliverable Acceptance Criteria

As a Business Analyst, How do you write your "Acceptance Criteria" effectively? Great requirements mean nothing if they can’t be tested. That’s where Acceptance Criteria (AC) come in! Clear AC ensures everyone—developers, testers, and stakeholders—is on the same page about what "done" looks like. But how do you write effective AC? Here’s my go-to approach: 1️⃣ Keep It Clear and Measurable Vague AC leads to confusion. Instead of: ❌ "The page should load quickly." Write: ✔️ "The page should load within 2 seconds on a 4G network." 2️⃣ Use the Given-When-Then Format This structure makes AC easy to understand and test: 🔹 Given – Precondition (What’s the setup?) 🔹 When – Action (What triggers it?) 🔹 Then – Expected outcome (What should happen?) Example: ✔️ Given the user is logged in, ✔️ When they enter an incorrect password three times, ✔️ Then their account should be locked for 10 minutes. 3️⃣ Cover Both Functional & Non-Functional Aspects It’s not just about features—consider security, performance, and usability. Example: ✔️ "The system should log out inactive users after 15 minutes for security." Why This Matters? - Developers know exactly what to build - Testers can validate if it works correctly - Stakeholders get what they expect How do you ensure your AC is rock solid? Share your thoughts! #businessanalyst #productowner

Pickle Your Acceptance Criteria No, this post isn’t about soaking acceptance criteria in brine, but it is about Gherkins. Not the small cucumber, but the structured format for writing acceptance criteria (AC). No story should enter a sprint without clear AC. Otherwise, teams risk ambiguity, misaligned expectations, poor estimation, and inaccurate forecasts. AC clarify scope, facilitate splitting, and foster a shared understanding of what "done" means. What’s Gherkin? Gherkin is a plain-text format that makes AC clear, testable, and automation-friendly using simple keywords: Feature: Describes functionality Scenario: Defines a specific system behavior Given: Establishes preconditions When: Describes an action Then: Defines expected outcome And/But: Extends steps for readability Ex 1: Withdraw Cash w/ Sufficient Funds Story: As a bank customer, I want to withdraw cash from an ATM so I can access my funds. Gherkin AC: Feature: ATM Cash Withdrawal Scenario: Successful withdrawal w/ sufficient funds Given the user has a balance of $50 And they have inserted their debit card When they enter their PIN correctly And they request to withdraw $20 Then the ATM should dispense $20 And the balance should be updated to $30 This is a testable definition of a successful withdrawal. Ex 2: Failed Withdrawal of More Than Available Balance Story: As a bank customer, I want to be prevented from overdrawing my account so I don't incur fees Gherkin AC: Feature: ATM Cash Withdrawal Scenario: Withdrawal request exceeds balance Given the user has a balance of $50 And they have inserted their debit card When they enter their PIN correctly And they request to withdraw $80 Then the ATM should display an "Insufficient Funds" message And the transaction should be declined And no money should be dispensed This removes ambiguity about how the system should handle insufficient funds. Gherkin Tips 1) Each scenario should test one behavior. 2) Avoid jargon. Use familiar business stakeholder terms. 3) Avoid redundancy by using a Background section for shared steps: Feature: ATM Transactions Background: Given the user has inserted their debit card And they have entered their PIN correctly Scenario: Checking balance When they select "Check Balance" from the menu Then the ATM should display their current balance 4) Write objectively testable (pass/fail) criteria based on clear outcomes. 5) Review AC with team to eliminate misunderstandings before a story enters a sprint Don’t Settle For Vague AC Clear AC reduce ambiguity, improve estimation, and support accurate planning. The Gherkin format provides a structured way to clearly define behavior that benefits developers, testers, users, and stakeholders. Gherkins help foster a shared understanding across the team; reduce ambiguity, leading to better estimations and more accurate forecasts; create testable requirements that prevent defects; and facilitate test automation, reducing manual regression effort.

Acceptance Criteria vs. Definition of Done In Agile development, ensuring a shared understanding of when a task is complete is critical. Two key concepts that help with this are Acceptance Criteria and Definition of Done (DoD). While they may seem similar, they serve distinct purposes in ensuring high-quality deliverables. Acceptance Criteria: Setting the Scope of Work Acceptance Criteria (AC) define the conditions a user story must meet to be considered complete. These criteria: - Are specific to each user story or feature. - Define functional and non-functional requirements. - Provide a clear guideline for developers and testers. - Ensure alignment with business expectations. For example, in an e-commerce application, an AC for a "Checkout" feature could be: ✅ The user can add items to the cart and proceed to checkout. ✅ The payment gateway should support credit cards and digital wallets. ✅ The system should send a confirmation email after purchase. Definition of Done: Ensuring Quality and Consistency The Definition of Done (DoD) is a standardized checklist that applies to all user stories and tasks. It ensures that work meets quality standards before release. A typical DoD includes: ✔ Code is peer-reviewed and merged. ✔ Unit and integration tests have passed. ✔ The feature is deployed in a staging environment. ✔ Documentation is updated. Why Both Matter? - AC ensures the feature meets user needs, while DoD ensures technical and process completeness. - Without clear AC, teams risk misunderstandings and scope creep. - Without a strict DoD, inconsistent quality can lead to production issues. By implementing both effectively, Agile teams can improve collaboration, reduce rework, and deliver high-quality software consistently. #Agile #Scrum #ProductDevelopment #QualityAssurance #SoftwareTesting

Want to instantly level up your Acceptance Criteria and your Definition of Done? ✅ Frame them as a Yes/No questions. As specific as possible… Why? Because “maybe” is where confusion lives.      “Done” becomes debatable.      “Accepted” turns into a guessing game. Here’s the shift: 🔁 Instead of:      – “The user should be able to log in.”      – “Code is reviewed.”      – “The page is responsive.” 🎯 Ask:      – “Can a user with valid credentials log in successfully?”      – “Was a peer review completed and approved?”      – “Does the page display correctly on mobile and desktop?” 👉 If the answer can’t be Yes or No, it’s not a good criteria. This works for Acceptance Criteria: clarity on what the Product Owner will accept. It works for Definition of Done: clarity on what the team calls complete. It works because ambiguity is a productivity killer. 🎁 Bonus: This technique builds shared understanding, reduces rework, and shortens the feedback loop. 🔄 Start rewriting your AC and DoD with this simple rule: If we can’t answer it with a Yes or No, we’re not done writing it. If your team rewrote all their AC and DoD as Yes/No questions, what would change? Let’s compare notes. #GorillaMoments #ScrumMaster #ProductOwner #DefinitionOfDone #AcceptanceCriteria