Deliverable Acceptance Criteria

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.

I’ve spoken to enough founders, designers, and devs to notice a pattern. They track hours like proof of value. 10 hours designing. 8 hours coding. 3 hours stuck on client calls. And they wonder why clients still push back. But clients don’t care about your hours. They care about outcomes. Not once will your client say, "Wow, this looks like 40 hours of work." But what they will say, "Does this do what we need it to do?" That’s what clicks for them. People don’t pay for effort. They pay for outcomes. They care about: • Did the landing page convert? • Did the site load fast? • Did the product work the way they imagined? That’s what gets judged. Not the late nights or "how long it took." And when expectations aren’t clear, that’s when resentment creeps in. One person’s "minor tweak" is another’s full rebuild. That’s why I always tell service providers: • Put it in the contract. • Make it measurable. • Define success upfront. Don’t leave room for assumption. And start defining success before the project starts. It protects your time. It protects your energy. And most importantly, it protects your client relationship. Let effort fuel the outcome - not define it. And if you want to make outcomes measurable in contracts, here's what I suggest 1) Set clear, quantifiable deliverables Don’t just say "design a landing page." Be specific instead: "Design a landing page with three sections, mobile responsive, integrated with XYZ form, delivered in Figma and HTML." 2) Define success metrics For example:  "The landing page must achieve a minimum conversion rate of 8% within 30 days of launch (measured via Google Analytics)." Or: "Website load time under 2 seconds on 4G, tested with PageSpeed Insights." You can measure these. 3) Use acceptance criteria List what needs to be true for the project to be considered complete. For e.g.,  "All buttons and forms function as intended; site passes accessibility checks; all content matches approved copy." 4) Be clear on revision limits and feedback cycles Such as,  "Includes two rounds of revisions. Further changes billed at $X/hour." Or "Client feedback must be provided within 3 business days to keep the timeline on track." 5) Tie payments to outcomes, not hours Break payments into milestones based on deliverables: "40% on design approval, 30% on development completion, 30% on final handover and live launch." And when you make outcomes measurable, you: • Eliminate ambiguity • Reduce scope creep • Build trust (and repeat business) So, before your next project, ask: Is your contract tracking hours, or is it defining results? Because in the end, clients remember outcomes - not overtime. --- ✍ Tell me below: Do you define "done" in your projects?

As a BA, the clarity of our user stories and acceptance criteria can make or break a project. Here are some real-life examples of common mistakes and how to avoid them: ✅ 𝐓𝐨𝐨 𝐁𝐫𝐨𝐚𝐝: A user story like "As a user, I want a dashboard so that I can see information" is too vague. Instead, try "As a marketing manager, I want to view real-time user engagement statistics on a dashboard to adjust campaigns quickly." ✅ 𝐓𝐞𝐜𝐡-𝐒𝐩𝐞𝐚𝐤: A user story stating "As a user, I need a SQL database to store customer data" might confuse non-technical stakeholders. Better: "As a customer service rep, I need a way to retrieve customer histories quickly to improve service times." ✅ 𝐅𝐞𝐚𝐭𝐮𝐫𝐞-𝐂𝐞𝐧𝐭𝐫𝐢𝐜: Writing "As a user, I want a four-step checkout process" focuses on system design rather than user needs. Flip it to: "As a shopper, I want a quick and easy checkout process so that I can complete my purchase in minutes." ✅ 𝐌𝐢𝐬𝐬𝐢𝐧𝐠 𝐀𝐜𝐜𝐞𝐩𝐭𝐚𝐧𝐜𝐞 𝐂𝐫𝐢𝐭𝐞𝐫𝐢𝐚: Don't just say, "The system should load fast." Specify, "The home page shall load within 3 seconds on 80% of occasions as measured by [specific tool]." ✅ 𝐒𝐭𝐚𝐭𝐢𝐜 𝐒𝐭𝐨𝐫𝐢𝐞𝐬: If initial feedback suggests users are confused by a feature, update the user story. Original: "As a user, I want tooltips on each dashboard element." Improved: "As a new user, I want clearly labeled tooltips on each dashboard element, appearing as I hover over them, to help understand the data presented." 🔄 𝐏𝐫𝐨 𝐓𝐢𝐩: Regularly revisit and revise your user stories and acceptance criteria based on ongoing feedback from all stakeholders. BA Helpline

“To the satisfaction of the Client” is a legal black hole. Because what is “satisfaction”? Measured how? Against what? Defined by whom? I once reviewed a creative services agreement with this clause tied to final payment. The client kept saying “not quite there yet.” And legally, they weren’t breaching anything. Because when satisfaction is the standard, there is no standard. But wait.. 😄 Here’s what most lawyers replace that vague wording with: “Deliverables shall be deemed accepted if the Client does not provide specific, written, and substantiated objections identifying material non-conformities with the agreed specifications within [X] business days of delivery. The Service Provider shall address valid objections within [Y] business days. Revisions shall be limited to a maximum of two (2) rounds per deliverable. Final approval shall not be unreasonably withheld, delayed, or conditioned.” Do you see any problem here? — Hello, I’m Gvantsa, a Partner at GBPLO. I specialize in providing thorough legal support to entrepreneurs facing diverse business challenges and building efficiency in legal ops.

Most AI/ML SaMD teams spend weeks debating acceptance criteria. That's weeks they can't afford. ↳ Set them too high → your device fails testing, back to R&D ↳ Set them too low → FDA pushes back, delays or rejection ↳ Get them right → submission on time, clearance secured Before you even pick a number, scope the problem along two axes: → Clinical risk: what's the probability of a wrong output × the chance a clinician acts on it × the severity of that outcome? → Algorithm complexity: can you walk through the decision logic on a single page, or is it a deep network with millions of parameters? Low risk + high explainability = lighter evidentiary burden. High risk + black box = you're collecting a lot more data. But regardless of where you land on that spectrum, you still need to commit to specific numbers. And that's where most teams stall, because FDA guidance speaks in abstractions, not thresholds. Innolitics analyzed 2000+ acceptance criteria and 6,300+ observed values from hundreds of real FDA 510(k) summaries. Here are the data-backed starting points: → AUC: start at 0.9 (subtract 0.05 from observed, round to nearest 0.05) → Sensitivity/Specificity: start at 0.8 (subtract 0.1, round to nearest 0.05) → Dice: start at 0.8 (subtract 0.1, round to nearest 0.05) → Kappa: start at 0.85 (subtract 0.05, round to nearest 0.05) → Bland-Altman LOA: ±10% of mean physiological value (multiply by 125%) → Bland-Altman Bias: ±2% of mean physiological value (multiply by 125%) If your algorithm can output a continuous score, make AUC your primary endpoint. It lets you choose your operating point later, even post-clearance, without redoing the study. A device might look mediocre at a suboptimal threshold but have a strong AUC underneath. The operating point is often as much a marketing decision as a clinical one: do you optimize for high sensitivity with more false alarms, or fewer false alarms with occasional misses? This can turn a weeks-long debate into a few-hour exercise. Full article with plots and methodology: https://hubs.li/Q047zFbm0

🚨 A Hard Truth: Acceptance Criteria and Definition of Done are NOT the same. Too many teams blur them together. Here’s the difference 👇 📝 Acceptance Criteria (AC) Unique to each Product Backlog Item. They describe what must be true so the Scrum Team and Product Owner share the same understanding of what delivering that PBI means. AC Example: As an online customer who forgot my password, I want to reset my login quickly, So that I can regain access to my account without calling customer support. Acceptance Criteria: - Forgot password link is visible on the login screen - Clicking the link prompts the customer to enter their registered email - A reset email is sent within 1 minute - Reset link expires in 10 minutes for security ✅ Definition of Done (DoD) Applies to every PBI and the Increment. It’s the Scrum Team’s commitment to quality and non-functional requirements. Examples: Codebase Quality - Code is written, peer-reviewed, and merged into the main branch - All unit, integration, and functional tests are automated and passing - Static code analysis shows no critical vulnerabilities or code smells - Security scanning (e.g., OWASP, dependency checks) shows no high-severity issues Performance & Reliability - Meets agreed non-functional requirements (e.g., page loads <1s, API responds <200ms) - Application monitored for errors, with no failing health checks - Backward compatibility verified (no breaking changes to existing consumers) Integration & Deployment - Integrated into the main branch without conflicts - Deployed to Production environment and verified - Deployment scripts and infrastructure-as-code updated where needed Documentation & Transparency - End-user documentation updated (help files, FAQs, release notes) - Technical documentation updated (API docs, architecture diagrams if changed) - Product Backlog updated to reflect new state of work Defect Management - No open critical or high-severity bugs - Medium/low-severity defects reviewed and either fixed or added to the Product Backlog 🔑 The distinction: AC = Do we have a shared understanding of the right thing to build for this PBI? DoD = Did we build it the right way, and does the whole Increment meet our quality standard? 👉 Think of it like a hotel: AC = checklist for one type of room. DoD = the safety, cleanliness, and quality standard for the entire hotel. 💬 What’s the biggest mix-up you’ve seen between AC and DoD?

How I write Acceptance Criteria (without them becoming vague or useless) One of the biggest causes of rework in delivery is acceptance criteria that are too vague. You’ll see AC like: → “Works as expected” → “User friendly” → “Loads quickly” → “Shows available times” The issue is simple: none of that is testable. So devs interpret it one way, testers interpret it another way, and sign-off turns into opinion. Here’s how I approach it 👇 1️⃣ Start with the user story AC are always linked to a story. If the story isn’t clear, the AC won’t be either. 2️⃣ Ask a small set of prompt questions (only use what’s relevant) → What does success look like? → What inputs does the user provide? → What rules/validations apply? → What can go wrong / no result scenarios? → What must be saved/retained/updated? 3️⃣ Write the AC in Given / When / Then → Given (setup) → When (action) → Then (observable outcome) The outcome? → Clear, testable AC the whole team can align on → Less guesswork in build + test → Cleaner sign-off If you found this useful, consider giving me a follow Matthew Thomas Holliday and reshare to your network ♻️ Want to build confidence in your BA career? Feeling stuck? Wanting extra guidance? Wanting to learn simple, repetable steps that will make you stand out?? That's exactly what our BA mentoring community helps you with (link in bio). #businessanalyst #acceptancecriteria

For over two decades, I've been writing acceptance criteria and helping teams write them. But it was a particular insight that sent the quality of my user stories and my automation through the roof. Acceptance Criteria fall into one of two categories. Understanding which type you are writing, and which type you SHOULD write, is the key to writing acceptance criteria that really deliver. Acceptance Criteria fall into two categories: Business Rules and Journey Scenarios. Knowing which type to write is essential for effectiveness. The two types of acceptance criteria are: 📜 Business Rules: Business Rules focus on specific rules or logic, allowing for quick execution and integration. They offer a detailed way to verify individual aspects. 🗺️ Journey Scenarios describe end-to-end user journeys, involving multiple components. They take longer to write and execute but are vital for understanding the big picture. A balance between these two types is key. Business Rules should be 90% or more of your criteria, with Journey Scenarios filling the rest. Avoid the trap of solution-centric criteria, which can lead to misinterpreting business needs. By employing these two types strategically, you can ensure that your software meets its functional requirements and aligns with broader objectives. You can learn more about this and other ways to write more effective BDD scenarios in the free eBook: "The 7 Qualities Of Highly Effective BDD Scenarios (and How AI Can Help)". Let me know if you'd like to know more.

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

𝗔𝗜 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗶𝗼𝗻𝘀: 𝗧𝗵𝗲 𝗕𝗿𝗶𝗱𝗴𝗲 𝗳𝗿𝗼𝗺 𝗣𝗼𝗖 → 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗣𝗼𝗖𝘀 𝘄𝗼𝘄. 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗽𝗮𝘆𝘀. The gap from PoC → production is real. Your demo dazzles in a controlled pre-production setup, but by day two in the real world, cracks appear. The root cause? Many builds skip a continuous, iterative evaluation framework anchored to rigorous acceptance criteria. Acceptance criteria differ from success criteria—and grasping this is crucial for reliable scaling. 𝗤𝘂𝗶𝗰𝗸 𝗲𝘅𝗮𝗺𝗽𝗹𝗲: Almond grading with 25 defect classes. We spent ~6 months building a golden set (~2,000 images per class) and only green‑lit when two bars were hit: 90% F1 on a blind holdout (success) and the production line met the business bar — low false rejects (≤2%), line‑rate throughput, and a unit‑cost ceiling (acceptance). 𝗦𝘂𝗰𝗰𝗲𝘀𝘀 𝗰𝗿𝗶𝘁𝗲𝗿𝗶𝗮 𝘃𝘀. 𝗔𝗰𝗰𝗲𝗽𝘁𝗮𝗻𝗰𝗲 𝗰𝗿𝗶𝘁𝗲𝗿𝗶𝗮 (𝗻𝗼𝘁 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲) • 𝗦𝘂𝗰𝗰𝗲𝘀𝘀 𝗰𝗿𝗶𝘁𝗲𝗿𝗶𝗮 (𝗯𝘂𝗶𝗹𝗱‑𝘁𝗶𝗺𝗲): fast signals for iteration—task win‑rate, RAG groundedness, tool‑call accuracy, unit tests. • 𝗔𝗰𝗰𝗲𝗽𝘁𝗮𝗻𝗰𝗲 𝗰𝗿𝗶𝘁𝗲𝗿𝗶𝗮 (𝗴𝗼‑𝗹𝗶𝘃𝗲 & 𝘀𝗰𝗮𝗹𝗲): the business bar—success rate, time‑to‑task, cost per task, risk/safety, and operability (observability, canary, rollback). If this isn’t met offline, don’t ship. If it slips in production, auto‑rollback. 𝗔𝗰𝗰𝗲𝗽𝘁𝗮𝗻𝗰𝗲 𝗳𝗼𝗿𝗺𝘂𝗹𝗮 (𝗲𝘅𝗮𝗺𝗽𝗹𝗲) Ship only if Success rate ≥ X%, Time‑to‑task ≤ Y minutes, Cost per task ≤ $Z. 𝗧𝗵𝗿𝗲𝗲 𝗺𝗼𝘃𝗲𝘀 𝘁𝗵𝗮𝘁 𝘄𝗼𝗿𝗸 𝗳𝗼𝗿 𝗶𝘁𝗲𝗿𝗮𝘁𝗶𝘃𝗲 𝗲𝘃𝗮𝗹𝘂𝗮𝘁𝗶𝗼𝗻𝘀:  𝗚𝗼𝗹𝗱𝗲𝗻 𝘀𝗲𝘁 + 𝘀𝗰𝗼𝗿𝗶𝗻𝗴 𝗴𝘂𝗶𝗱𝗲. Curate 50–100 real tasks. Define a simple scoring guide (what “good” looks like), align reviewers, and version the dataset and the guide. Keep a blind holdout and track how often reviewers agree. Gate with thresholds (e.g., ≥80% first‑pass resolution in <2 minutes, ≤2% escalations). 𝗟𝗟𝗠‑𝗮𝘀‑𝗷𝘂𝗱𝗴𝗲—𝘄𝗶𝘁𝗵 𝘀𝗮𝗳𝗲𝗴𝘂𝗮𝗿𝗱𝘀. Use pairwise comparisons, 2+ judge models, and human spot‑checks. Monitor judge disagreement/drift in CI and block merges on preference win‑rate drops. Log evaluation cost and latency so tests don’t balloon spend. 𝗦𝗰𝗼𝗿𝗲 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝘁𝗲𝘅𝘁. • Agents: goal completion, steps‑to‑success, tool‑call success and preconditions, safe‑action %, rollback/undo rate. 𝗚𝗼𝘃𝗲𝗿𝗻𝗮𝗻𝗰𝗲: 𝗔 𝘀𝘁𝗲𝗽 𝗺𝗼𝘀𝘁𝗹𝘆 𝗺𝗶𝘀𝘀𝗲𝗱 Name an Evaluation Owner with approve authority. Run weekly evaluations and publish the scoreboard. Tie every score to success rate, time‑to‑task, and cost per task. 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀 • Make evaluations your ship/no‑ship gate tied to KPIs. • Start with a 100‑task golden set and a guardrailed LLM‑judge in CI. • Always score execution and keep a visible, weekly scoreboard. Treat evaluation like a product—owned, versioned, and tied to outcomes—and you’ll ship AI that sticks and scales. #AgenticAI, #AIEvaluation, #EnterpriseAI, #RAG, #MLOps