<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Alejandro Sierra on Medium]]></title>
        <description><![CDATA[Stories by Alejandro Sierra on Medium]]></description>
        <link>https://medium.com/@alejandrosierraarias_40862?source=rss-457e0dd0eb16------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*eF-ucygluDQLv7DCQMDcOw.jpeg</url>
            <title>Stories by Alejandro Sierra on Medium</title>
            <link>https://medium.com/@alejandrosierraarias_40862?source=rss-457e0dd0eb16------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 15:36:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alejandrosierraarias_40862/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Align Quality with Delivery Speed: The False Dilemma]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/how-to-align-quality-with-delivery-speed-the-false-dilemma-6ed9248946e5?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ed9248946e5</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Sat, 13 Jun 2026 09:14:52 GMT</pubDate>
            <atom:updated>2026-11-16T15:00:01.586Z</atom:updated>
            <content:encoded><![CDATA[<p><em>You’ve been hearing for months that tests slow the team down. The data says exactly the opposite.</em></p><h3>“We Don’t Have Time to Write Tests”</h3><p>I’ve heard it in sprint planning meetings. I’ve seen it written in code comments. I’ve read it in retrospectives as an “impediment.” And for a while, part of me understood it: when there’s delivery pressure, tests seem like the most expendable thing.</p><p>But it’s a trap. A cognitive trap that confuses immediate cost with real cost. And I have my own data to prove it.</p><p>In October 2025 we started measuring test quality with mutation testing across 20 simultaneous projects. We didn’t change delivery dates. We didn’t add extra sprints. We only changed how we measured quality. Five months later, average coverage had gone from 16.47% to 33.99%. Without slowing anything down. In some projects, actually speeding up.</p><p>Here’s what I learned.</p><h3>The Real Cost of Not Investing in Quality</h3><p>Before talking about solutions, we need to understand the scale of the problem we’re ignoring when we decide we “don’t have time for tests.”</p><p>The IBM Systems Sciences Institute has spent decades documenting something the industry keeps ignoring: the cost of fixing a defect in production is between 6 and 15 times more expensive than fixing it during development. This isn’t a metaphor. It’s real cost: engineering hours, interruptions, midnight hotfixes, emergency deploys, coordination with the business.</p><p>I see it in my projects every week. I have projects where 12 out of every 52 weeks invest more in bugs than in new features. One of them has 98% of its issues categorized as bugs. The remaining 2% are features. That team isn’t building product: it’s maintaining debt.</p><blockquote><strong><em>Key data point:</em></strong><em> Over the last 4 months, 90.2% of incidents were contained by QA before impacting the business. That’s 193 bugs detected in Jira versus only 21 detected in UAT by the business. Each of those 21 that slipped through cost more than the previous 193 combined.</em></blockquote><p>Capers Jones, in <em>Applied Software Measurement</em> (2008), calculated that projects with high defect density spend between 40% and 60% of their total effort on rework. Not on features. On redoing what was already done but done wrong.</p><p>The “quality vs. speed” debate starts from a false premise: that quality is an additional cost. The reality is that the <em>lack</em> of quality is the cost. Well-implemented quality doesn’t take time away it gives time back.</p><h3>The Real Experiment: Mutation Testing Across 20 Projects</h3><h3>What We Measured and Why Mutation Testing</h3><p>Traditional code coverage lies. A test that executes a line of code without verifying anything counts as coverage. We’ve seen projects with 80% coverage that failed in production due to cases no test was catching.</p><p>Mutation testing introduces small modifications (mutants) into the source code and verifies that existing tests detect them. If your tests don’t catch that a &gt; has become &gt;=, those tests aren&#39;t protecting anything. It&#39;s the only metric that measures the <em>effectiveness</em> of tests, not just their existence.</p><p>We implemented this measurement as an automated weekly cadence. Every Friday, a snapshot. The data you’re seeing is real, not estimated.</p><h3>Month-by-Month Evolution</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ulr5EOMkVkD27GflJuQZjQ.png" /></figure><p><em>Caption: Phase 1: Code Health Evolution — 20 Projects (Oct 2025 — Feb 2026)</em></p><p>Month Average coverage (mutation score) October 2025 16.47% November 2025 16.35% December 2025 24.82% January 2026 27.52% February 2026 33.99%</p><p>The first thing that stands out is the drop from October to November. It’s not an error. It’s normal. When you start measuring rigorously, the first reaction from teams is disbelief or resistance. The indicator dropped because we started measuring things that previously didn’t count. From December onward, improvement was sustained.</p><blockquote><strong><em>Key data point:</em></strong><em> +28.16% average improvement in mutation score over 5 months, across 20 simultaneous projects, without altering the delivery timelines agreed with clients.</em></blockquote><h3>Greenfield vs. Brownfield: The Most Important Lesson</h3><p>Here’s the finding that has made me think the most.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pyQEE3vSpDitZolpYlBntw.png" /></figure><p><em>Caption: Greenfield vs. Brownfield — Mutation score improvement (Oct–Feb)</em></p><p>Project type Average mutation score improvement Starting point Context Greenfield +43.75% Clean base, no technical debt Architecture designed from scratch Non-Greenfield (Brownfield) +9.44% Accumulated debt, inherited tests Legacy code, rigid dependencies <strong>Overall average</strong> <strong>+28.16%</strong> — 20 projects</p><p>The difference isn’t about effort. Brownfield teams worked just as hard. The difference is accumulated technical debt.</p><p>In Greenfield projects, you can establish testing patterns from the first commit. You can choose testable architectures. You can put quality gates in place before the code even exists. In Brownfield projects, every new test has to deal with coupling, non-injected dependencies, classes with multiple responsibilities that make mocking impossible.</p><p>The lesson: quality has to be an architectural decision from day one, not a later addition. Gene Kim and Patrick Debois frame it in <em>The DevOps Handbook</em> (2016) as “built-in quality”: quality isn’t inspected at the end — it’s built in.</p><h3>The Inverted Testing Pyramid: The Antipattern I Found</h3><p>Martin Fowler described the testing pyramid in 2012 on martinfowler.com. The idea is simple: many unit tests (cheap, fast, isolated), some integration tests, few end-to-end tests (expensive, slow, brittle). It’s the structure that allows feedback to scale without scaling time.</p><p>What I found in many of my projects was exactly the opposite.</p><p><strong>Antipattern: the inverted pyramid</strong></p><p>Many slow, expensive, brittle manual E2E tests at the top — detecting problems late, fixing them late. Few, inconsistent integration tests in the middle. Very few unit tests at the bottom, with a low mutation score, not catching regressions.</p><p><strong>Goal: the shift-left pyramid</strong></p><p>Many fast, isolated unit tests at the base, with a high mutation score and immediate feedback. Some integration tests covering contracts between components. Few E2E tests covering only critical flows.</p><p>The problem with the inverted pyramid isn’t just technical. It’s economic. A bug caught by a unit test has zero cost in cycle time: the developer sees it before committing. A bug caught in UAT by the business carries the full rework cost: analysis, fix, review, QA, deploy. And it carries a trust cost: the client has seen that something didn’t work.</p><p>Kent Beck framed this in <em>Extreme Programming Explained</em> (2000) when he talked about the short feedback loop as the central principle of sustainable development. He didn’t say it as theoretical advice — he said it because he’d seen what happens when feedback arrives late.</p><blockquote><strong><em>Key data point:</em></strong><em> One project in my portfolio has 100% of its issues in WIP. Ten open issues. None finished. The inverted testing pyramid is a symptom: when there’s no confidence in the code, no one dares close tickets.</em></blockquote><h3>Force Multipliers: Automation as Investment</h3><p>Here’s the paradigm shift I’ve found most useful in conversations with business stakeholders: quality automation isn’t an operational cost. It’s an investment with measurable returns.</p><p>A developer who spends 20 minutes running the test suite manually will run it three times a day at best. An automated pipeline runs it on every commit, for every developer, without degradation. The marginal cost of each additional run is zero.</p><p>Tool / Practice What it does Measured impact <strong>Automated mutation testing</strong> Measures real test effectiveness, not just coverage +28.16% average improvement in 5 months <strong>Scaffolding / base projects</strong> New projects start with testing structure included Greenfield: +43.75% vs Brownfield: +9.44% <strong>codeguard (pre-commit hooks)</strong> Blocks commits that degrade mutation score or violate conventions Prevention at the source, not in review <strong>Quality gates in CI/CD</strong> Pull requests blocked if quality metrics drop Technical debt can’t enter main <strong>Weekly metrics cadence</strong> Automated Friday snapshots Visibility for management without TL overhead</p><h3>Why Scaffolding Matters More Than It Seems</h3><p>The biggest multiplier isn’t a specific tool. It’s the starting point. When a new project launches with integrated testing structure — with a base project that already has mutation testing configured and quality gates active from the first commit — the cost of maintaining that quality is marginal.</p><p>The opposite is also true. Adding tests to a project with two years of technical debt is costly, slow, and frustrating. I saw it in the Brownfield numbers: +9.44% improvement with the same relative effort as the Greenfield teams that achieved +43.75%. It’s not that Brownfield teams work worse. They were climbing a much steeper slope.</p><h3>codeguard: The Tool We’re Building</h3><p>We have an in-house hook tool for the development process currently in development. The idea is simple: if you can detect at pre-commit that a change is going to degrade the mutation score, you can block it before it enters the repository. The inverted pyramid problem isn’t solved by training alone. It’s solved by selective friction at the right moment.</p><p>Well-designed automation doesn’t slow down the developer. It gives them faster feedback on the impact of their decisions.</p><h3>How to Sell It Internally: The Business Case</h3><p>This is where most managers get stuck. They have the data. They know that investing in quality makes sense. But they don’t know how to present it to stakeholders who only see the delivery date.</p><p>The usual mistake is trying to sell quality with technical arguments. “We need more test coverage.” “The mutation score is low.” That doesn’t work with someone whose incentive is delivery speed.</p><p>The right argument is this: <strong>bugs that reach production cost more than bugs that don’t.</strong></p><p>You don’t need to convince anyone that quality is good in the abstract. You need to show the cost of recent incidents, the time invested in hotfixes, the impact on team sprints when they have to stop and fix something in production.</p><p>The IBM Systems Sciences Institute data is useful here precisely because it’s conservative: 6x more expensive in production than in development. In high technical debt contexts, the multiplier is higher.</p><blockquote><strong><em>Key data point:</em></strong><em> 78.2% of active work across my projects has no category in Jira. We don’t know if it’s a feature, a bug, or a technical task. If you can’t measure the proportion of rework, you can’t argue there’s no rework. Categorizing work is the first step toward having the business case.</em></blockquote><p>There’s another argument that works even better with certain stakeholder profiles: predictability. Teams with good test coverage have more predictable release cycles. Fewer last-minute surprises. Fewer “we can’t deploy this Friday because we found a critical bug this morning.”</p><p>Sustainable velocity isn’t maximum sprint followed by collapse. It’s constant cadence with few unexpected events. That’s exactly what investing in quality produces.</p><h3>The Context Nobody Mentions: The Human Cost</h3><p>There’s a dimension of the quality-speed debate that doesn’t appear in management books and that I see every week: the impact on people.</p><p>The tech leads in my teams spend between 25% and 50% of their time on management and client meetings instead of technical work. Context switching is the number one problem they mention when I ask what prevents them from doing their best work: four out of every six people bring it up spontaneously.</p><p>When you don’t have tests, when the code has no safety net, every change is risky. That generates interruptions. It generates the need for the tech lead to personally supervise every merge. It generates situations where technical debt can’t be touched because no one knows what might break.</p><p>Investing in quality isn’t just for the client. It’s also for the team. And it’s measurable: when the team trusts the tests, they can work in parallel without fear. They can refactor without anxiety. They can finish sprints without accumulating workarounds.</p><p>One team member said something I keep coming back to: <em>“we live better now than we did a year ago, and we have more visibility.”</em> That’s not a secondary result. It’s the primary one.</p><h3>Conclusion</h3><p>The quality vs. speed debate is false because it starts from an incorrect definition of speed. Speed isn’t number of commits per day. Speed is the ability to deliver value in a sustained, predictable way with few unexpected events.</p><p>The data I have is concrete: +28.16% improvement in test effectiveness over 5 months, without changing delivery dates. 90.2% of incidents contained before reaching the business. Projects that started from scratch with the right patterns improving almost 5 times more than projects with accumulated debt.</p><p>The practical conclusion is this: if you have a new project, the time to establish quality patterns is now. If you have projects with debt, the time to start measuring is now. Not because measurement alone fixes anything, but because without measurement you’re making decisions blind.</p><p>And the next time someone says “we don’t have time to write tests,” the right question is: <em>how much time are we spending fixing what the tests didn’t catch?</em></p><h3>Sources</h3><ol><li><strong>Martin Fowler</strong> — <em>TestPyramid</em>, martinfowler.com (2012). <a href="https://martinfowler.com/bliki/TestPyramid.html">https://martinfowler.com/bliki/TestPyramid.html</a></li><li><strong>Gene Kim, Patrick Debois, John Willis, Jez Humble</strong> — <em>The DevOps Handbook</em>, IT Revolution Press (2016).</li><li><strong>IBM Systems Sciences Institute</strong> — <em>Relative Cost of Fixing Defects</em>, referenced in multiple software quality management publications (established data point, widely cited since the 1990s).</li><li><strong>Capers Jones</strong> — <em>Applied Software Measurement: Global Analysis of Productivity and Quality</em>, McGraw-Hill (2008).</li><li><strong>Kent Beck</strong> — <em>Extreme Programming Explained: Embrace Change</em>, Addison-Wesley (2000).</li></ol><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ed9248946e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testing LLM Based Products: A Practical Guide for Delivery and Quality Teams]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/testing-llm-based-products-a-practical-guide-for-delivery-and-quality-teams-80896fa59d94?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/80896fa59d94</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Mon, 04 May 2026 11:17:24 GMT</pubDate>
            <atom:updated>2026-11-16T15:01:59.618Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w3-lOQYLF4Gpaxrd01-ARA.gif" /></figure><p>You have deployed a product powered by a<strong> Large Language Model</strong>.</p><p>It works beautifully in the demo and It impresses stakeholders.</p><p>Then, three weeks after launch, a user gets a completely wrong answer, a hallucinated fact slips through, or the tone drifts so far from your brand guidelines that your head of marketing calls you directly.</p><p><strong>Sound familiar?</strong></p><blockquote>The problem is not the model. The problem is that most teams still treat LLM based products as <strong>black boxes</strong>, relying on vibes and spot checks instead of systematic quality assurance.</blockquote><p>We will walk through the testing landscape for LLM applications: <em>what the core challenges are, which tools exist, how to use them with real code examples, and how to build a quality mindset that scales with your product.</em></p><h3>Why Testing LLMs Is Different</h3><p>In traditional software, a function given the same inputs always returns the same output. You write a test, it goes green, it stays green.</p><p><strong>LLMs</strong> are fundamentally different:</p><ul><li><strong>Non determinism</strong>: <em>The same prompt can produce different outputs across runs, temperatures, and model versions.</em></li><li><strong>No ground truth:</strong> <em>For many tasks, there is no single correct answer. Quality is contextual, subjective, and domain specific.</em></li><li><strong>Emergent failures:</strong> <em>A model that handles 99% of your test cases perfectly may catastrophically fail on the 1% that matters most to your users.</em></li><li><strong>Shifting baselines </strong>: <em>A model update from your provider can silently degrade your product overnight without a single line of your code changing.</em></li></ul><blockquote>This means we need a new <strong>testing </strong>vocabulary and a new <strong>toolset</strong>.</blockquote><h3>The Testing Stack for LLM Applications</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XEIN21oftpRcSqtL3hwoJA.png" /></figure><p>Think of it in four layers:</p><ul><li><strong>Layer 1 Unit Evals:</strong> Test individual prompts in isolation. Does this prompt reliably return the expected structure? Does it avoid forbidden content? Does it follow instructions?</li><li><strong>Layer 2 Component Evals</strong>: Test larger pipeline components. For RAG systems: is the retrieved context relevant? Is the answer faithful to the source? For agents: does the tool selection logic hold up?</li><li><strong>Layer 3 End-to-End Evals:</strong> Test full user journeys. Does the system produce the right outcome for a representative set of real world inputs?</li><li><strong>Layer 4 Production Monitoring:</strong> Continuously evaluate live traffic. Catch regressions and distribution shifts before users escalate.</li></ul><h4>Tool 1: PromptFoo Prompt Testing and CI/CD Integration</h4><p><a href="https://www.promptfoo.dev/">Build Secure AI Applications | Promptfoo</a></p><p><strong>PromptFoo</strong> treats your prompts as testable artifacts. You define test cases in YAML, run them against one or more models, and get a structured report. It is the closest thing to a unit testing framework for prompts, and it integrates naturally into CI/CD pipelines.</p><blockquote><strong>When to use it:</strong> Regression testing when you change prompts, A/B testing prompt variants, comparing outputs across model versions, catching quality regressions before they reach production.</blockquote><p><strong>Installation</strong></p><pre>npm install -g promptfoo<br># or<br>npx promptfoo@latest</pre><p><strong>Basic Configuration</strong></p><p>Create a promptfooconfig.yaml file:</p><pre>prompts:<br> - &quot;You are a helpful customer support agent for {{company}}. Answer the following question concisely: {{question}}&quot;<br>providers:<br> - openai:gpt-4o<br> - openai:gpt-4o-mini<br>tests:<br> - vars:<br> company: &quot;Acme Corp&quot;<br> question: &quot;What is your return policy?&quot;<br> assert:<br> - type: contains<br> value: &quot;return&quot;<br> - type: llm-rubric<br> value: &quot;Response should be polite and professional&quot;<br> - type: javascript<br> value: &quot;output.length &lt; 500&quot;<br>- vars:<br> company: &quot;Acme Corp&quot;<br> question: &quot;How do I contact support?&quot;<br> assert:<br> - type: contains-any<br> value: [&quot;email&quot;, &quot;phone&quot;, &quot;chat&quot;]<br> - type: not-contains<br> value: &quot;I don&#39;t know&quot;</pre><p><strong>Running Tests</strong></p><pre>promptfoo eval</pre><p><strong>PromptFoo</strong> outputs a detailed HTML report comparing results across models and test cases. You can also run it in CI and fail the pipeline when quality drops below a threshold:</p><pre>promptfoo eval - ci - max-failures 3</pre><p><strong>Custom Graders</strong></p><p>For domain-specific quality checks, you can write custom JavaScript graders:</p><pre>// graders/tone_check.js<br><br>module.exports = (output, context) =&gt; {<br> const formalWords = [&#39;please&#39;, &#39;thank you&#39;, &#39;kindly&#39;, &#39;sincerely&#39;];<br> const informalWords = [&#39;hey&#39;, &#39;yeah&#39;, &#39;nope&#39;, &#39;gonna&#39;];<br> const hasInformal = informalWords.some(w =&gt; output.toLowerCase().includes(w));<br> const hasFormal = formalWords.some(w =&gt; output.toLowerCase().includes(w));<br>return {<br> pass: !hasInformal &amp;&amp; hasFormal,<br> score: hasFormal &amp;&amp; !hasInformal ? 1.0 : 0.0,<br> reason: hasInformal<br> ? `Informal language detected`<br> : `Tone check passed`,<br> };<br>};</pre><pre># Reference in your config<br>assert:<br> - type: javascript<br> filePath: graders/tone_check.js</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kb6w1_w6QEDJCfreaeVDDg.png" /></figure><h4>Tool 2: DeepEval LLM Unit Testing with pytest</h4><p><a href="https://docs.confident-ai.com/">DeepEval by Confident AI - The LLM Evaluation Framework</a></p><p><strong>DeepEval</strong> brings the familiar pytest experience to <strong>LLM</strong> evaluation. It provides a rich library of pre-built metrics and lets you write LLM tests exactly as you would write unit tests. It is particularly strong for RAG evaluation and hallucination detection.</p><blockquote><strong>When to use it</strong>: Unit and integration tests for LLM pipelines, measuring hallucination rate, evaluating RAG faithfulness, running evals as part of your Python test suite.</blockquote><p><strong>Installation</strong></p><pre>pip install deepeval</pre><p><strong>Writing Your First LLM Test</strong></p><pre>import pytest<br>from deepeval import assert_test<br>from deepeval.metrics import AnswerRelevancyMetric, HallucinationMetric<br>from deepeval.test_case import LLMTestCase<br><br>def test_customer_support_response():<br> test_case = LLMTestCase(<br> input=&quot;What is your refund policy?&quot;,<br> actual_output=&quot;We offer a 30-day money-back guarantee on all products.&quot;,<br> retrieval_context=[<br> &quot;Our refund policy allows customers to return products within 30 days &quot;<br> &quot;of purchase for a full refund, no questions asked.&quot;<br> ]<br> )<br>relevancy_metric = AnswerRelevancyMetric(threshold=0.7)<br> hallucination_metric = HallucinationMetric(threshold=0.3)<br>assert_test(test_case, [relevancy_metric, hallucination_metric])</pre><p>Run with standard pytest:</p><pre>deepeval test run test_support.py</pre><p><strong>Measuring RAG Quality</strong></p><p>DeepEval provides a full suite of RAG metrics:</p><pre>from deepeval.metrics import (<br> FaithfulnessMetric,<br> ContextualPrecisionMetric,<br> ContextualRecallMetric,<br> ContextualRelevancyMetric,<br>)<br>from deepeval.test_case import LLMTestCase<br><br>def test_rag_pipeline():<br> test_case = LLMTestCase(<br> input=&quot;What are the main causes of inflation?&quot;,<br> actual_output=&quot;Inflation is primarily driven by demand-pull and cost-push factors.&quot;,<br> expected_output=&quot;Inflation is caused by demand-pull, cost-push, and built-in factors.&quot;,<br> retrieval_context=[<br> &quot;Economists identify three main types of inflation: &quot;<br> &quot;demand-pull inflation occurs when demand exceeds supply, &quot;<br> &quot;cost-push inflation is driven by rising production costs, &quot;<br> &quot;and built-in inflation stems from wage-price spirals.&quot;<br> ]<br> )<br>metrics = [<br> FaithfulnessMetric(threshold=0.8), # Is the answer grounded in context?<br> ContextualPrecisionMetric(threshold=0.7), # Is retrieved context relevant?<br> ContextualRecallMetric(threshold=0.7), # Does context cover the answer?<br> ContextualRelevancyMetric(threshold=0.7), # Is context relevant to the query?<br> ]<br>for metric in metrics:<br> metric.measure(test_case)<br> print(f&quot;{metric.__class__.__name__}: {metric.score:.2f} - {metric.reason}&quot;)</pre><p><strong>Detecting Hallucinations in Production</strong></p><pre>from deepeval.metrics import HallucinationMetric<br>from deepeval.test_case import LLMTestCase<br><br>def evaluate_response(user_input: str, llm_output: str, sources: list[str]) -&gt; dict:<br> test_case = LLMTestCase(<br> input=user_input,<br> actual_output=llm_output,<br> context=sources<br> )<br>metric = HallucinationMetric(threshold=0.3)<br> metric.measure(test_case)<br>return {<br> &quot;hallucination_score&quot;: metric.score,<br> &quot;passed&quot;: metric.score &lt; 0.3,<br> &quot;reason&quot;: metric.reason<br> }</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YJ0gfj0Q03Rudn1OJkONSg.png" /></figure><h4><strong>Tool 3: Ragas — The Standard for RAG Evaluation</strong></h4><p><a href="https://docs.ragas.io/">Ragas</a></p><p>If you are building a RAG <strong>(Retrieval Augmented Generation)</strong> system, <strong>Ragas</strong> is the closest thing to an industry standard for evaluation. It defines a clear set of metrics that cover every dimension of a RAG pipeline: retrieval quality, generation quality, and end-to-end performance.</p><blockquote><strong>When to use it</strong>: Evaluating RAG pipelines, building automated evaluation datasets, monitoring RAG quality over time, benchmarking retrieval strategies.</blockquote><p><strong>Installation and Basic Usage</strong></p><pre>pip install ragas</pre><pre>from ragas import evaluate<br>from ragas.metrics import (<br> faithfulness,<br> answer_relevancy,<br> context_precision,<br> context_recall,<br>)<br>from datasets import Dataset<br><br># Your RAG pipeline outputs<br>data = {<br> &quot;question&quot;: [<br> &quot;What is the capital of France?&quot;,<br> &quot;Who invented the telephone?&quot;,<br> &quot;What year did the moon landing occur?&quot;,<br> ],<br> &quot;answer&quot;: [<br> &quot;The capital of France is Paris.&quot;,<br> &quot;Alexander Graham Bell invented the telephone.&quot;,<br> &quot;The moon landing occurred in 1969.&quot;,<br> ],<br> &quot;contexts&quot;: [<br> [&quot;Paris is the capital and most populous city of France.&quot;],<br> [&quot;Alexander Graham Bell is credited with inventing the telephone in 1876.&quot;],<br> [&quot;Apollo 11 landed on the Moon on July 20, 1969.&quot;],<br> ],<br> &quot;ground_truth&quot;: [<br> &quot;Paris&quot;,<br> &quot;Alexander Graham Bell&quot;,<br> &quot;1969&quot;,<br> ],<br>}<br>dataset = Dataset.from_dict(data)<br>results = evaluate(<br> dataset=dataset,<br> metrics=[<br> faithfulness,<br> answer_relevancy,<br> context_precision,<br> context_recall,<br> ],<br>)<br>print(results)<br># Output: {&#39;faithfulness&#39;: 0.97, &#39;answer_relevancy&#39;: 0.94, &#39;context_precision&#39;: 0.91, &#39;context_recall&#39;: 0.89}</pre><p><strong>Integrating Ragas with LangChain</strong></p><pre>from langchain_openai import ChatOpenAI, OpenAIEmbeddings<br>from langchain_community.vectorstores import FAISS<br>from langchain.text_splitter import RecursiveCharacterTextSplitter<br>from ragas.langchain.evalchain import RagasEvaluatorChain<br>from ragas.metrics import faithfulness, answer_relevancy<br><br># Build your RAG pipeline<br>llm = ChatOpenAI(model=&quot;gpt-4o&quot;)<br>embeddings = OpenAIEmbeddings()<br># Create evaluator chains<br>faithfulness_chain = RagasEvaluatorChain(metric=faithfulness)<br>relevancy_chain = RagasEvaluatorChain(metric=answer_relevancy)<br># Evaluate a response<br>result = faithfulness_chain({<br> &quot;question&quot;: &quot;What is RAG?&quot;,<br> &quot;answer&quot;: &quot;RAG stands for Retrieval-Augmented Generation.&quot;,<br> &quot;contexts&quot;: [&quot;Retrieval-Augmented Generation (RAG) combines retrieval systems with generative models.&quot;]<br>})<br><br>print(f&quot;Faithfulness: {result[&#39;faithfulness_score&#39;]:.2f}&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P7T8MT27eploI_GxQIU_DQ.png" /></figure><h4>Tool 4: LangSmith — Tracing, Observability, and Evaluation</h4><p><a href="https://smith.langchain.com/">LangSmith</a></p><p><strong>LangSmith</strong> is the observability layer for LLM applications. It gives you full visibility into every step of your chains and agents: what prompts were sent, what was retrieved, how long each step took, and what the model returned. Crucially, it also lets you capture real production traces and use them as an evaluation dataset.</p><blockquote><strong>When to use it</strong>: Debugging complex chains and agents, capturing production data for offline evaluation, building human review workflows, tracing latency and cost per run.</blockquote><p><strong>Setup</strong></p><pre>pip install langsmith langchain-openai</pre><pre>import os<br>os.environ[&quot;LANGCHAIN_TRACING_V2&quot;] = &quot;true&quot;<br>os.environ[&quot;LANGCHAIN_API_KEY&quot;] = &quot;your-api-key&quot;<br>os.environ[&quot;LANGCHAIN_PROJECT&quot;] = &quot;my-llm-product&quot;</pre><p><strong>Automatic Tracing</strong></p><p>LangSmith integrates with LangChain automatically once tracing is enabled:</p><pre>from langchain_openai import ChatOpenAI<br>from langchain.prompts import ChatPromptTemplate<br>from langchain.schema.output_parser import StrOutputParser<br>llm = ChatOpenAI(model=&quot;gpt-4o&quot;)<br>prompt = ChatPromptTemplate.from_messages([<br> (&quot;system&quot;, &quot;You are a helpful assistant. Be concise.&quot;),<br> (&quot;user&quot;, &quot;{question}&quot;)<br>])<br>chain = prompt | llm | StrOutputParser()<br># This run is automatically traced in LangSmith<br>response = chain.invoke({&quot;question&quot;: &quot;Explain vector databases in one sentence.&quot;})</pre><p><strong>Manual Tracing for Custom Pipelines</strong></p><pre>from langsmith import traceable, Client<br>client = Client()<br>@traceable(name=&quot;retrieve_documents&quot;)<br>def retrieve(query: str, k: int = 3) -&gt; list[str]:<br> # Your retrieval logic here<br> return [&quot;doc1 content&quot;, &quot;doc2 content&quot;, &quot;doc3 content&quot;]<br>@traceable(name=&quot;generate_answer&quot;)<br>def generate(query: str, context: list[str]) -&gt; str:<br> # Your generation logic here<br> return &quot;Generated answer based on context&quot;<br>@traceable(name=&quot;rag_pipeline&quot;)<br>def rag(query: str) -&gt; str:<br> docs = retrieve(query)<br> answer = generate(query, docs)<br> return answer<br># Run it<br>answer = rag(&quot;What is vector similarity search?&quot;)</pre><pre>from langsmith import Client<br>from langsmith.evaluation import evaluate<br>client = Client()<br># Define your pipeline<br>def my_pipeline(inputs: dict) -&gt; dict:<br> question = inputs[&quot;question&quot;]<br> answer = rag(question)<br> return {&quot;answer&quot;: answer}<br># Define an evaluator<br>def correctness_evaluator(run, example) -&gt; dict:<br> predicted = run.outputs[&quot;answer&quot;]<br> expected = example.outputs[&quot;expected_answer&quot;]<br> score = 1 if expected.lower() in predicted.lower() else 0<br> return {&quot;key&quot;: &quot;correctness&quot;, &quot;score&quot;: score}<br># Run evaluation against a dataset you created in LangSmith<br>results = evaluate(<br> my_pipeline,<br> data=&quot;my-evaluation-dataset&quot;,<br> evaluators=[correctness_evaluator],<br> experiment_prefix=&quot;v2-prompt-change&quot;,<br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4vaOR3zWAAQ3X1mFYpyMQ.png" /></figure><h4>Tool 5: Braintrust Evaluation as a Product Discipline</h4><p><a href="https://www.braintrust.dev/">Braintrust - The AI observability platform for building quality AI products</a></p><p><strong>Braintrust</strong> takes a product centric view of <strong>LLM</strong> evaluation. It provides a full platform for running evals, scoring outputs with LLM judges, managing datasets, tracking scores across experiments, and comparing model and prompt changes over time. It is particularly strong at making evaluation a repeatable, auditable process rather than an adhoc exercise.</p><blockquote><strong>When to use it</strong>: Running structured experiments, comparing prompt or model versions with statistical rigor, building a culture of continuous evaluation, managing eval datasets and scorers in a team setting.</blockquote><p><strong>Installation</strong></p><pre>pip install braintrust autoevals</pre><p><strong>Running a Basic Eval</strong></p><pre>import braintrust<br>from autoevals import Factuality<br># Define the task you are evaluating<br>def classify_intent(input: dict) -&gt; str:<br> question = input[&quot;question&quot;]<br> # Your LLM call here<br> return call_your_llm(f&quot;Classify the intent of: {question}&quot;)<br># Run the eval<br>braintrust.eval(<br> name=&quot;Intent Classification v2&quot;,<br> data=[<br> {&quot;input&quot;: {&quot;question&quot;: &quot;How do I reset my password?&quot;}, &quot;expected&quot;: &quot;account_management&quot;},<br> {&quot;input&quot;: {&quot;question&quot;: &quot;What is your cancellation policy?&quot;}, &quot;expected&quot;: &quot;billing&quot;},<br> {&quot;input&quot;: {&quot;question&quot;: &quot;The app keeps crashing&quot;}, &quot;expected&quot;: &quot;technical_support&quot;},<br> ],<br> task=classify_intent,<br> scores=[Factuality],<br>)</pre><p><strong>Using LLM as Judge Scoring</strong></p><pre>from braintrust import Eval<br>from autoevals import LLMClassifier<br><br># Custom LLM judge for tone<br>ToneChecker = LLMClassifier(<br> name=&quot;ToneChecker&quot;,<br> prompt_template=&quot;&quot;&quot;<br>You are evaluating the tone of a customer support response.<br>Response: {{output}}<br>Is the tone:<br>A) Professional and empathetic<br>B) Neutral<br>C) Unprofessional or cold<br>Answer with A, B, or C only.<br>&quot;&quot;&quot;,<br> choice_scores={&quot;A&quot;: 1.0, &quot;B&quot;: 0.5, &quot;C&quot;: 0.0},<br>)<br>Eval(<br> name=&quot;Support Response Quality&quot;,<br> data=lambda: load_test_cases(),<br> task=lambda input: generate_support_response(input),<br> scores=[ToneChecker, Factuality],<br>)</pre><p><strong>Tracking Scores Over Time</strong></p><p>Braintrust automatically tracks every experiment, letting you see whether a change to your prompt or model improved or regressed your scores:</p><pre>import braintrust<br>experiment = braintrust.init(<br> project=&quot;Customer Support Bot&quot;,<br> experiment=&quot;gpt-4o-mini-prompt-v3&quot;<br>)<br>for test_case in test_suite:<br> output = your_pipeline(test_case[&quot;input&quot;])<br> score = evaluate_output(output, test_case[&quot;expected&quot;])<br>experiment.log(<br> inputs=test_case[&quot;input&quot;],<br> output=output,<br> expected=test_case[&quot;expected&quot;],<br> scores={&quot;quality&quot;: score},<br> metadata={&quot;model&quot;: &quot;gpt-4o-mini&quot;, &quot;prompt_version&quot;: &quot;v3&quot;}<br> )<br>experiment.summarize(show=True)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mq_CfDhoBxQMGPHVxRh6Hg.png" /></figure><h3>Building a Testing Culture for LLM Products</h3><p>The tools above are only as valuable as the process around them. Here is what a mature LLM quality process looks like:</p><p><strong>1. Start with a Golden Dataset</strong></p><p>Before any automation, invest time in building a curated set of 50 to 200 test cases that represent your real users. Include edge cases, adversarial inputs, and the failure modes you have already seen in production. This dataset is your most valuable quality asset.</p><p><strong>2. Define Your Quality Dimensions</strong></p><p>Not every product needs the same metrics. A customer support bot prioritizes faithfulness and tone. A code generation tool prioritizes correctness and safety. A creative writing assistant prioritizes diversity and coherence. Pick 3 to 5 metrics that directly map to your product’s success criteria.</p><p><strong>3. Automate the Eval Loop</strong></p><pre>Code change -&gt; Run PromptFoo/DeepEval in CI -&gt; Block merge if score drops -&gt; Deploy -&gt; Monitor with LangSmith</pre><p>This loop catches regressions before they reach users and gives your team confidence to iterate quickly.</p><p><strong>4. Use Production Data to Improve Evals</strong></p><p>Real user interactions are your best source of test cases. Use LangSmith or Braintrust to flag low confidence outputs, route them to human reviewers, and feed confirmed failures back into your evaluation dataset. The dataset gets stronger with every production incident.</p><p><strong>5. Treat Model Updates as Releases</strong></p><p>When your <strong>LLM</strong> provider updates a model, treat it as a dependency upgrade. Run your full eval suite. Compare scores against your baseline. Only promote the new model if scores hold or improve on your key metrics.</p><h4>Summary: Which Tool for Which Job</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lR8xNpo9gS6Vku-iI3hIhQ.png" /></figure><h4>References:</h4><p>- PromptFoo documentation: https://www.promptfoo.dev/docs<br>- DeepEval documentation: https://docs.confident-ai.com<br>- Ragas documentation: https://docs.ragas.io<br>- LangSmith documentation: https://docs.smith.langchain.com<br>- Braintrust documentation: https://www.braintrust.dev/docs<br>-“Building LLM Applications for Production” by Chip Huyen: https://huyenchip.com/2023/04/11/llm-engineering.html<br>- RAGAS Paper: <a href="https://arxiv.org/abs/2309.15217">https://arxiv.org/abs/2309.15217</a></p><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80896fa59d94" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From QA to IA QA Orchestrator: How Generative AI Redefined Software Quality in 2025 and 2026]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/from-qa-to-ia-qa-orchestrator-how-generative-ai-redefined-software-quality-in-2025-and-2026-7add24358a7a?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/7add24358a7a</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Fri, 01 May 2026 15:27:59 GMT</pubDate>
            <atom:updated>2026-11-16T15:02:46.591Z</atom:updated>
            <content:encoded><![CDATA[<h3>From QA to AI QA Orchestrator: How Generative AI Redefined Software Quality in 2025 and 2026</h3><h3>IA QA Orchestrator: The Immune System of AI-Generated Software</h3><p>In 2024, GitHub Copilot reached 1.8 million paid subscribers and was adopted by more than 50,000 organizations worldwide. That same year, 92% of US developers were already using AI tools in their workflow, according to the State of the Octoverse Report</p><p>Those numbers are impressive. But there is another number nobody celebrates:</p><h4>41% of teams using generative AI reported deploying code with critical bugs that passed every automated check. Source: Forrester Research.</h4><blockquote><em>Why</em>? Because the speed of generation outpaced the architecture of quality.</blockquote><pre>This article is about the role that closes that gap.</pre><h3>The Context: A Real Paradigm Shift</h3><p><a href="https://medium.com/@alejandrosierraarias_40862/scrum-in-the-agentic-era-why-what-worked-for-30-years-might-be-holding-you-back-35687b186ace">Scrum in the Agentic Era: Why What Worked for 30 Years Might Be Holding You Back?</a></p><blockquote>This changes everything for QA. Not just the when or the how. It changes what we are even validating.</blockquote><h3>What the data says about the problem:</h3><ul><li><strong>73% of engineering leaders say their biggest concern with generative AI in development is code quality</strong>, not speed. Source: GitLab DevSecOps Survey 2024.</li><li><strong>67% of bugs found in production in projects with generative AI come from functional hallucinations</strong>: code that is syntactically correct but semantically wrong. Source: DORA Report 2025.</li><li><strong>Projects with agentic frameworks and no defined quality architecture accumulate 3.2x more technical debt in the first 90 days than traditional projects</strong>. Source: Accelerate State of DevOps 2026.</li><li><strong>Only 18% of organizations using generative AI tools have a defined LLM output evaluation strategy.</strong> Source: Gartner, August 2026.</li></ul><blockquote>Speed without control is not delivery. It is scaled risk.</blockquote><h3>What Is the IA QA Orchestrator?</h3><p>The IA QA Orchestrator is not a QA engineer who learned to use ChatGPT.</p><p>It is a 360 degree quality architect who designs the validation system before the AI starts generating software. Think of it as the designer of the software immune system.</p><p>The fundamental difference:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Atq4Im6TUFJl5LJQvOVQoA.png" /></figure><h3>The Problem Without This Role (With Data)</h3><p>When a team adopts agentic development without an IA QA Orchestrator, the following happens:</p><h4>1. False Coverage</h4><p>The AI generates code and its own tests. The result is a system that validates itself within its own frame of reference.</p><blockquote>It is like asking someone to grade their own exam.</blockquote><p>According to the Stack Overflow Developer Survey 2025, 45% of developers who use AI to generate tests admit those tests do not cover critical edge cases they themselves would identify manually.</p><h4>2. Functional Hallucinations</h4><p>The AI can generate code that compiles, passes linters, and has 90% coverage but does something different from what the PRD says.</p><blockquote>The code is correct BUT the behavior is wrong.</blockquote><p>The DORA Accelerate Report 2025 identified this as the primary vector of invisible technical debt in projects with AI.</p><h4>3. Quality Drift</h4><p>Without defined quality gates, each generation iteration introduces small semantic deviations from the expected behavior.</p><blockquote>After 10 iterations, the delta between the PRD and the implementation can be enormous without any test detecting it.</blockquote><h4>4. Prompt Dependency</h4><p>If the testing architecture does not exist before the first prompt, the quality of the software will be tied to the quality of the initial prompt.</p><blockquote>Change the prompt, change the system, tests fail, and nobody knows why.</blockquote><h3>The 5 Core Responsibilities of the IA QA Orchestrator</h3><h4>1. Testing Architecture Adapted to AI</h4><p>The classic testing pyramid <em>(70% unit, 20% integration, 10% E2E)</em> does not apply in generative systems.</p><p>The new pyramid is:</p><ul><li><strong>60% Functional semantic validation</strong>: does the system do what the business needs?</li><li><strong>25% Integration tests</strong>: do the agents communicate correctly?</li><li><strong>15% Structural unit:</strong> is the code solid?</li><li><strong>Plus LLM Evaluation Layer</strong>: are the model outputs reliable and repeatable?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zqU7laXeWe3VI2tUZbdopw.png" /></figure><blockquote>This architecture cannot be designed by AI alone. It requires a human who understands both the business and the limits of the model.</blockquote><h4>2. Quality Gates and Guardrails</h4><h4>Guardrails are the limits that block generation if minimum quality criteria are not met.</h4><p>Real examples:</p><p>If the PRD has incomplete acceptance criteria, total block.<br>If the generated code exceeds a cyclomatic complexity threshold, mandatory review.<br>If the semantic score of an epic is below 70%, it does not pass to release.</p><blockquote>According to the NIST AI Risk Management Framework , 89% of AI incidents in production could have been prevented with guardrails defined at the design stage.</blockquote><h4>3. LLM Output Evaluation</h4><p>This is the newest and least understood layer. Language model outputs need specialized evaluation:</p><p><em>Scoring by functional epics: does the code generated for epic X cover all PRD criteria?</em></p><p><strong>PRD vs Implementation comparison:</strong></p><ul><li>Is there semantic drift between what was requested and what was generated?</li><li>Release Readiness Score: a composite score that determines whether the system is ready for production.</li></ul><blockquote>Frameworks like RAGAS, DeepEval, and LangSmith are emerging for this, but the evaluation strategy is still a human responsibility.</blockquote><h4>4. Dataset Strategy</h4><p>Test data in AI systems is radically different.</p><p>It needs to be:</p><ul><li>Modular: scalable by epic and by agent</li><li>Versioned: model behavior changes over time</li><li>Anti-drift: with control cases that detect semantic degradation</li><li>Bias-free: validated to not reinforce model biases</li></ul><blockquote>McKinsey estimates the cost of fixing a contaminated testing dataset in production is 15 to 20 times greater than designing it correctly from the start.</blockquote><h4>5. Agentic Task Orchestration</h4><p>90% of the IA QA Orchestrator’s work happens before generation:</p><p><strong>Pre-generation (blocking):</strong></p><ul><li>Complete quality strategy design</li><li>Quality prompt and skills definition</li><li>Test architecture and evaluation metrics</li><li>PRD validation and acceptance criteria</li><li>Testing dataset design</li></ul><p><strong>Post-generation (validation):</strong></p><ul><li>Evaluation of AI-generated tests</li><li>Real vs apparent functional coverage review</li><li>Detection of AI-introduced technical debt</li><li>Feedback loop for the next iteration</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XCKnlqgYRyQEQj4CWAcWVQ.png" /></figure><h3>BMAD as the Foundation</h3><p>BMAD (Business Model Agile Development) is one of the most widely used agentic development frameworks today.</p><p>In BMAD, the IA QA Orchestrator integrates from the spec writing phase, defining:</p><ul><li><strong>Evaluable acceptance criteria for AI</strong></li><li><strong>Quality metrics per agent</strong></li><li><strong>Epics validatable with automatic scoring</strong></li><li><strong>Quality feedback loops in each iteration</strong></li></ul><p>Without this role integrated in BMAD, the framework executes correctly but without functional quality guarantees.</p><h3>Industry Data: The Cost of Not Having This Role</h3><ul><li>The average cost of a bug found in production is $4,572 vs $93 at design stage. Source: IBM Systems Sciences Institute.</li><li>Teams with mature DevOps plus QA integrated in AI have 2.6x more deploy frequency and 50% less incident recovery time. Source: DORA</li><li>Organizations with an AI quality strategy have 37% fewer functional regressions in the first 6 months of use. Source: Gartner</li><li>The AI Quality Assurance market will reach $8.2 billion in 2027 with a CAGR of 31.4%. Source: MarketsandMarkets</li></ul><h3>With and Without the IA QA Orchestrator</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mnCqvkuPt4e3KB2GkAEPzA.png" /></figure><pre>The IA QA Orchestrator Profile<br>Hard Skills:<br>Testing systems architecture<br>LLM output evaluation (RAGAS, DeepEval, LangSmith)<br>Quality prompt engineering<br>Dataset design and bias control<br>Agentic framework knowledge (BMAD, LangChain, AutoGen)<br>Soft Skills:<br>Systems thinking<br>Cross-functional communication (business to technical)<br>Change management<br>Leadership without direct authority</pre><p><strong>Conclusion: AI Scales Everything. What Does Your Quality System Scale?</strong></p><blockquote>Generative AI is redefining how we build software.</blockquote><blockquote>The question is not whether you should use it. The question is: do you have the quality architecture to control what it generates?</blockquote><p><strong>Without an IA QA Orchestrator:</strong><br>AI scales code and also scales errors<br>Speed increases and reliability decreases<br>Coverage grows and functional value decreases</p><p><strong>With an IA QA Orchestrator:</strong><br>AI scales controlled, verifiable, and auditable systems<br>Speed is maintained with quality as a living system<br>Delivery accelerates without compromising real behavior</p><blockquote>The software of the future will not be written by humans alone or machines alone.<br>It will be designed by humans who understand how to control what machines generate.</blockquote><h3>That is the IA QA Orchestrator.</h3><p><strong>Sources and References</strong></p><p>1. <strong>GitHub</strong> Octoverse Report at github.blog/octoverse<br>2. <strong>McKinsey</strong> Global Institute, The economic potential of generative AI <br>3. <strong>GitLab</strong> DevSecOps Survey at about.gitlab.com<br>4. <strong>DORA</strong> Accelerate State of DevOps Report at dora.dev<br>5. <strong>Forrester</strong> Research, AI Code Generation Quality Gap<br>6. <strong>Gartner</strong>, AI in Software Development<br>7.<strong> Stack Overflow</strong> Developer Survey at survey.stackoverflow.co<br>8. <strong>NIST</strong> AI Risk Management Framework at nist.gov/ai<br>9. <strong>MarketsandMarkets</strong>, AI Quality Assurance Market <br>10. <strong>IBM</strong> Systems Sciences Institute, Cost of Quality in Software</p><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7add24358a7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scrum in the Agentic Era: Why What Worked for 30 Years Might Be Holding You Back?]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/scrum-in-the-agentic-era-why-what-worked-for-30-years-might-be-holding-you-back-35687b186ace?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/35687b186ace</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Fri, 01 May 2026 11:31:39 GMT</pubDate>
            <atom:updated>2026-11-16T15:03:45.879Z</atom:updated>
            <content:encoded><![CDATA[<h3>Scrum in the Agentic Era: Why What Worked for 30 Years Might Be Holding You Back</h3><blockquote>“The only constant in software development is change.”</blockquote><blockquote>Jez Humble</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Eo1zLXdiybg_ltUS" /></figure><p><strong>When was the last time your team sat down to question whether Scrum is still the right model for what you are building today?</strong></p><p>Not whether Scrum is well implemented. Not whether sprints are the right size. Whether the model itself, the entire paradigm, is still the right tool for the work in front of you.</p><p>That is the uncomfortable question nobody wants to raise in the retrospective.</p><p>Let&#39;s talk about :</p><ul><li><strong>The System We Know (and That Has Worked Well)</strong></li><li><strong>The New Paradigm: SDD + Agentic AI</strong></li><li><strong>The Most Controversial Point: Story Points Are Dead</strong></li><li><strong>Two Models That Coexist</strong></li><li><strong>The Role Change Nobody Is Processing</strong></li><li><strong>The Mistake Most Organizations Are Making</strong></li><li><strong>Coexistence: The Real Scenario in 2026</strong></li></ul><h3>The System We Know (and That Has Worked Well)</h3><p>Waterfall arrived in the 1970s. The foundational idea behind Scrum emerged in 1986 with Takeuchi and Nonaka. The Agile Manifesto was signed in 2001. For decades these models have been the backbone of how we build software: iterative, incremental, running at human pace, with teams that agree on their capacity and deliver against it.</p><p>And they have worked. That is not a historical accident. Scrum solves real problems: visibility, predictability, change management, expectation alignment.</p><p>Most software companies have lived somewhere on this spectrum at some point, and many have traveled through every model in a continuous improvement journey.</p><p>The problem is not that Scrum is bad. The problem is that the context has changed so radically that continuing to apply the same model as if nothing happened is, at best, a missed opportunity and at worst, an active drag.</p><h3>The New Paradigm: SDD + Agentic AI</h3><p>Over the last two years a set of practices and tools has emerged that we group under the umbrella of SDD (Specification Driven Development) with agentic AI: BMAD, Multi Agent Workflows, Evaluation Driven Development (EDD), Guardrail Driven Development, Prompt and Context Engineering Workflows, Spec Kit, and more.</p><p>This is not “Scrum with AI on top.” It is a different development model. And the difference is not cosmetic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XSwrtdTcwG3D8cLQlRWweg.png" /></figure><h3>The Most Controversial Point: Story Points Are Dead</h3><p>In Scrum, story points estimate human effort, complexity, uncertainty, and relative time. All of that is tied to team capacity and a stable velocity.</p><p>In an agentic system, those pillars disappear:</p><p>Generation is nearly instantaneous. Human effort is not the bottleneck. Velocity is not stable because it depends on context, prompt quality, and specification depth.</p><p>You are trying to measure an industrial system with a craft metric.</p><p>Story points, as we know them, do not “adapt” to the agentic environment. They lose their foundation. The right question is no longer “how many points does this story have?” It becomes “is the specification good enough for the system to generate the correct output on the first attempt?”</p><p>The metrics that start to make sense in SDD + AI are different: acceptance rate of generated output, number of prompt iterations until the Quality Gate passes, automatic evaluation coverage, and spec quality measured against predefined criteria.</p><h3>Two Models That Coexist</h3><p>Here is the structural difference between both models:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a-Z5Dj9OHB8aqutlK6tQaw.png" /></figure><blockquote>“We cannot solve our problems with the same thinking we used when we created them.”</blockquote><blockquote>Albert Einstein</blockquote><h3>The Role Change Nobody Is Processing</h3><p>In Scrum, the developer builds. They take a story, break it into tasks, write code, open a PR, go through review, and merge.</p><p>In SDD + AI, the developer specifies, orchestrates, and evaluates. They define the context with surgical precision, design the agentic flow, interpret outputs, and decide whether a Quality Gate has been passed or not.</p><p>This is not a minor adjustment in responsibilities. It is a cognitive profile change. The value no longer lives in knowing how to write code. It lives in knowing what to ask for, at what level of detail, in what order, and how to evaluate whether what you received is correct.</p><p>The question very few organizations are asking themselves is this: are we training our teams for this new role, or are we simply giving them access to AI tools and hoping they figure it out on their own?</p><h3>The Mistake Most Organizations Are Making</h3><p>This is the real point of this post.</p><p>The technology is not what fails. Technology advances, gets adopted, gets integrated. The problem is that many organizations are mixing both models without adapting how they work.</p><p>They want rapid adaptation but without impact on existing processes. They want innovation but without investment in training. They want AI productivity without having defined what need it covers or what problem it solves. They want to manage heterogeneous teams and projects the same way. And they believe, or hope, that what has worked for 30 years must keep working in exactly the same way.</p><p>Technology evolves, gets adopted reactively, and the way of working is left to “emerge” without a strategy, without a framework, without standard guidelines. The result is the worst of both worlds: neither the predictability of Scrum nor the speed of SDD.</p><h3>Coexistence: The Real Scenario in 2026</h3><p>Scrum is not going to disappear. The reality of the industry today is one of coexistence:</p><p>Large organizations with established Scrum teams incorporating SDD + AI pilot projects. Small product teams working in SDD + AI mode inside a predominantly Scrum ecosystem. Companies trying, with limited success, to apply Scrum ceremonies to agentic workflows.</p><p>The consequence in every case is the same. You need a strategy for coexistence. You cannot treat both models as if they were the same, because they are not.</p><p>And the question I leave you with:</p><blockquote>Does your organization have an explicit strategy to manage this transition, or are you letting it “emerge” and then trying to understand why productivity is not improving the way you expected?</blockquote><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35687b186ace" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How We Scaled Performance Testing to 20+ Teams in 15 days(With Production Blocked)]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/how-we-scaled-performance-testing-to-20-teams-in-15-days-with-production-blocked-a8fe511ce7f7?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8fe511ce7f7</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 16:37:07 GMT</pubDate>
            <atom:updated>2026-11-16T15:04:36.982Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>TLTR</strong>:</p><blockquote><strong>“Performance is not a QA task. It is a shared responsibility.”<br></strong> Development understands the code<br>Infrastructure understands the platform<br>QA orchestrates quality</blockquote><p><strong>Feedback was clear:</strong></p><blockquote>“This is not just theory. You executed fast, with quality, and helped us. We want to keep working with you and continue learning in this area.”</blockquote><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FpPhyAv5t9V8djyRFJH%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Fwtf-obama-wth-pPhyAv5t9V8djyRFJH&amp;image=https%3A%2F%2Fmedia1.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExb2lqcXFvdjV1aXNhdW9oZjd2OG84ODlmdDUyenp4d3FzcG9yNzJmOCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2FpPhyAv5t9V8djyRFJH%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="318" frameborder="0" scrolling="no"><a href="https://medium.com/media/ac71eb1517e2973180843da7732c33d2/href">https://medium.com/media/ac71eb1517e2973180843da7732c33d2/href</a></iframe><p>Imagine the scenario: more than <strong>20 development teams,</strong> multiple products running in parallel, and a firm decision:</p><p><strong>“No more deployments to production without performance testing.”</strong></p><p>Total blockage.</p><p>And the starting point was, literally, zero:</p><ul><li><em>No non-functional requirements</em></li><li><em>No testing infrastructure</em></li><li><em>No standard tooling</em></li><li><em>No observability capabilities</em></li><li><em>No clear strategy</em></li><li><em>And most critically: no prior experience across most teams</em></li></ul><p>What looked like an impossible <strong>bottleneck</strong> became the perfect opportunity to transform the engineering culture across the company.</p><p>What <strong>Blocking Production </strong>Taught Us About Performance, QA, and Ownership</p><h3>1. Diagnosis: The Problem Was Not Technical</h3><p>The first key realization:</p><p><strong>the problem was not choosing a tool, it was defining a strategy.</strong></p><p>You cannot scale something that is not properly defined at its core.</p><blockquote>A tool should never drive the approach or the strategy.<br> And one thing was clear: workarounds and the classic <em>“it works on my machine”</em> bring no clarity and do not help with detection or prevention.</blockquote><p>We tackled three fronts:</p><h3>Data</h3><p>To test performance, you need data. Always.</p><p>Read, create, modify, delete, it does not matter the operation: without data, there is no realistic test.</p><p>We decided to generate our own datasets:</p><ul><li>Synthetic data aligned with business logic</li><li>Independent from test execution (external preparation)</li><li>Identified with a common ID per team/project</li></ul><p>The flow was clear:</p><ol><li>Create datasets</li><li>Execute load and tests</li><li>Finish execution</li><li>Clean the environment</li></ol><p>Result:<br> <strong>a clean, reproducible database ready for the next iteration.</strong></p><p>Additionally, many tests required preconditions or included data mutations as part of the test, so restoring the initial state was not optional, it was mandatory.</p><p>Another key decision:</p><p><strong>operate through endpoints, not directly against the database.</strong></p><p>This reduced:</p><ul><li>Complexity</li><li>Coupling</li><li>Issues with business rules and constraints</li></ul><p>And brought us much closer to real system behavior.</p><h3>Environment</h3><p>We had to kill the “it works on my machine” mindset.</p><p>Running performance tests locally is one of the most common mistakes in the industry.</p><p><strong>Why?</strong></p><p>Because you introduce uncontrollable variables:</p><ul><li>CPU and RAM usage</li><li>Network and latency</li><li>Parallel processes</li><li>Device capacity</li></ul><p>Clear example:</p><p>Mike:</p><ul><li>64GB RAM</li><li>Latest generation CPU</li><li>30 Chrome tabs, music, debugging, production deployment in a war room</li></ul><p>Tim:</p><ul><li>8GB RAM</li><li>i3</li><li>basic laptop</li></ul><p>Same test? Yes.<br> Same results? No.<br> Reliable results? Not at all.</p><p>The answer is simple:</p><blockquote><strong>you cannot validate the availability of a global system from a local laptop simulating 100 users.</strong></blockquote><p>Solution:</p><ul><li><em>Dedicated instances (GCP VM or AWS EC2)</em></li><li><em>Controlled resources (CPU, RAM)</em></li><li><em>Scalability</em></li><li><em>Documented and reproducible environment</em></li></ul><p>From there:</p><ul><li><em>We executed tests</em></li><li><em>Consumed real APIs</em></li><li><em>Generated reports</em></li><li><em>Measured impact</em></li></ul><p>It is not an ephemeral system environment, but it is a controlled testing environment.</p><h3>Visibility</h3><p>This is where the loop closes.</p><p>Performance tools give you metrics like:</p><ul><li>RPS</li><li>Percentiles</li><li>Averages and medians</li><li>Concurrent users</li><li>Ramp-up</li></ul><p>That is useful, but not enough.</p><p>The real questions are:</p><ul><li><strong>Where is the bottleneck?</strong></li><li><strong>Why does the system fail under sustained load?</strong></li><li><strong>What happens to CPU and RAM at that moment?</strong></li></ul><p>Without infrastructure observability (CPU, RAM, network), you are flying blind.</p><p><strong>Performance without observability does not explain the problem, it only shows it.</strong></p><h3>2. Solution Architecture</h3><p>Moving more than 20 teams in under 15 days requires something very specific:</p><p><strong>simple, scalable, and executable.</strong></p><p>No complex per-team configurations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q20jHdD_Wnwu3CgOMwoBqw.jpeg" /><figcaption><strong>Caption:</strong> Solution workflow: from dataset to final report.</figcaption></figure><h3>Technical Pillars</h3><h4>Critical Endpoint Identification</h4><p>We did not test everything.<br> We tested what impacts the business:</p><ul><li>Login</li><li>Payments</li><li>Inventory</li></ul><p>This is key:</p><p><strong>understanding the real production pain points.</strong></p><ul><li>Where is usage highest?</li><li>Where do users complain?</li><li>Where is the bottleneck?</li></ul><p>Without this, you are shooting without a target.</p><h4>Lightweight Tooling: Locust</h4><p>We chose Locust for several reasons:</p><ul><li>Code-first approach in Python</li><li>Easy adoption</li><li>Fast CI/CD integration</li><li>Fully programmatic (classes, methods, reusable logic)</li><li>Simple execution</li><li>Friendly UI</li><li>Headless mode and solid reporting</li></ul><p>In short:<br> <strong>quick to implement, easy to scale.</strong></p><h4>Three Execution Levels</h4><ul><li><strong>Load</strong> → long-term stability</li><li><strong>Stress</strong> → breaking point</li><li><strong>Concurrency</strong> → simultaneous user spikes</li></ul><h3>3. The Human Factor: QA as a Change Agent</h3><p>This is where the real impact happened.</p><p><strong>Technology is only 20%.<br> The remaining 80% is people.</strong></p><p>We moved from being “the team that tests” to becoming facilitators.</p><ul><li><strong>Pair programming</strong></li><li><strong>1:1 mentoring</strong></li><li><strong>Supporting 20 teams</strong></li></ul><p>The challenge was not trivial:</p><ul><li><strong>Dependency on development</strong></li><li><strong>Infrastructure</strong></li><li><strong>Databases</strong></li><li><strong>Observability</strong></li><li><strong>Business</strong></li></ul><p>And performance testing maturity was significantly lower compared to E2E.</p><p>So we did what was needed:</p><ul><li>Evangelize</li><li>Train</li><li>Execute</li><li>Align</li></ul><h3>4. Results in 30 Days after release in Production</h3><p>Under pressure, this is what we achieved:</p><ul><li><strong>Production unblocked</strong> → deployments backed by real data</li><li><strong>Early detection</strong> → issues found before impacting users</li><li><strong>Observability culture</strong> → CPU and RAM became part of the conversation</li><li><strong>Scalability</strong> → what works for 1 team works for 20</li><li>Stakeholder trust</li><li>Team trust</li><li>Strengthened brand image</li><li>Continuous value delivery</li></ul><h3>Conclusion</h3><p>The key was not using the most expensive tool,<br> but designing an approach that is:</p><ul><li>Simple</li><li>Reproducible</li><li>Aligned with business</li></ul><p>And that is what truly scales.</p><p>In 30 days, we saw real results.<br> But operational maturity started to consolidate within weeks.</p><p>This requires three things:</p><ul><li>Patience</li><li>Trust in teams</li><li>Consistency in execution</li></ul><p>Because when all of that aligns,<br> the outcomes are not only good</p><p><strong>they are sustainable.</strong></p><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8fe511ce7f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Bottleneck to Business Enabler: The SDET Transformation]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/what-if-the-real-problem-was-never-the-testers-the-tools-or-the-number-of-automated-checks-384c8f12f22e?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/384c8f12f22e</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Thu, 26 Feb 2026 17:52:02 GMT</pubDate>
            <atom:updated>2026-11-16T15:05:26.161Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>What if the real problem was never the QA, the tools, or the number of automated checks?What if the problem was the model itself?</strong></h3><pre>From Bottleneck to Business Enabler: The SDET Transformation</pre><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FlXu72d4iKwqek%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExZ2h4anIyMndvaGZucm8wNG5xaHBwcXFiM3p4NGR5NGwzN24wZXI0NiZlcD12MV9naWZzX3NlYXJjaCZjdD1n%2FlXu72d4iKwqek%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia1.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExajBseHhwNjI3Y20xYmYyZG1kaXR2MHk2Z2d6ZGFleTkxNW02a2x1dSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2FlXu72d4iKwqek%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="326" frameborder="0" scrolling="no"><a href="https://medium.com/media/61c54e6f01ed5ada458436984cd625d1/href">https://medium.com/media/61c54e6f01ed5ada458436984cd625d1/href</a></iframe><p><em>This article is about redesigning how quality lives inside the SDLC not about testing more.</em></p><h3><strong>Index</strong></h3><ol><li>⚠️<strong><em>The Problem</em></strong><em>: QA as a bottleneck</em></li><li>🔄<strong><em>The Paradigm Shift</em></strong><em> :Moving left, embedding QA</em></li><li>🏛️<strong><em>Estrategic Model: 3 Pillars</em></strong></li><li>📊<strong><em>Impact :</em></strong><em>Results that speak (real case)</em></li><li>💡<strong><em>Conclusion &amp; Learnings</em></strong><em> : From testing to prevention architecture</em></li></ol><h3>⚠️The Problem</h3><blockquote>For years, the model was clear: QA appeared at the end of the cycle and that created a domino effect.</blockquote><h4>QA as a Bottleneck</h4><ul><li>Testing concentrated in the last days of the sprint</li><li>2 days to validate new features + full regression</li><li>No real space for shift left and no time for strategic automation</li></ul><blockquote>Result: QA was perceived as a brake, not an accelerator.</blockquote><h4>Quality Without Clear Ownership</h4><ul><li>A production bug was “QA’s fault.”</li><li>Development had no shared responsibility for quality.</li><li>Weak or non-existent unit testing, integration testing or mocking.</li><li>Total uncertainty in every deployment.</li></ul><blockquote>When quality has no owner, everyone points… and no one prevents.</blockquote><h4>SDLC Without Solid Structure</h4><ul><li>No quality gates, no real quality, no objective criteria for testing or coverage</li><li>Undefined bug and release protocols</li><li>Lack of traceability</li></ul><blockquote>People talked about testing, but there was no quality system.</blockquote><h4>Fragmented Culture</h4><ul><li>Teams working with heterogeneous solutions and Misalignment.</li><li>Lack of shared standards.</li><li>Resistance to structural improvements.</li><li>QA defended quality as the last shield.</li><li>Development focused on shipping fast.</li></ul><blockquote>No one was selling quality as part of product value. There was no shared product culture. There were silos.</blockquote><h4>The Illusion of Automation</h4><ul><li>“With AI I have 100% effectiveness in Playwright.”</li><li>“I’ll do performance testing” without technical criteria.</li><li>Tools without a methodological framework and automation without strategy.</li></ul><blockquote>Automating without a system doesn’t improve quality, It just masks the problem.</blockquote><h4>Real Impact</h4><ul><li>Constant production incidents.</li><li>Unpredictable releases despite the final QA shield.</li><li>High cost of late regressions.</li><li>Difficulty identifying failed integrations.</li><li>Accumulated risk in every deployment.</li></ul><blockquote>Quality was not designed. It was validated at the end.</blockquote><h4>Spoiler:</h4><p>This is not solved by:</p><ul><li><strong>Hiring more testers</strong></li><li><strong>Buying more tools</strong></li><li><strong>Automating more UI</strong></li></ul><blockquote>It’s solved by redesigning the quality model at its roots.</blockquote><p>That’s where transformation begins…</p><h3>🔄The Paradigm Shift</h3><p>The change was not technical but cultural and structural.</p><h4>QA Moves Left and everywhere</h4><p>Real shift left with presence in:</p><ul><li>Functional documentation and technical analysis</li><li>Design and standards definition in processes and in technical aspects</li></ul><blockquote>QA everywhere as a process enabler.</blockquote><h4>Real Space to Build Quality</h4><p>Sprint capacity was enabled to:</p><ul><li>Reduce automation gap prioritizing by criticality</li><li>Create structured internal deliverables with clear deadlines focused in design real layered testing (not just UI)</li></ul><blockquote>More prevention on the <strong>left</strong> = more value for the team and the business.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kw38VAp96iV1vuZvcaTnUA.png" /></figure><h4>Shared Responsibility</h4><p>A production bug is not QA’s responsibility it’s the team’s responsibility.</p><p>We defined:</p><ul><li>Clear roles, scopes and boundaries</li><li>Joint ownership</li></ul><blockquote>QA doesn’t execute tests they design prevention systems.</blockquote><h4>SDLC Redesign</h4><ul><li>Implementation of quality gates with solid release protocols and solid process standards</li><li>Real quality metrics</li></ul><blockquote>Quality stopped being a phase and It became a system.</blockquote><h4>Leadership &amp; Evangelization</h4><p>It wasn’t about imposing It was about aligning.</p><p>We translated quality into 💸economic impact and risk.<br>We turned quality into part of the delivery model.</p><blockquote>Today we don’t talk about QA and Dev.<br> We talk about a shared culture of responsible delivery, with QA as the engine of change.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*S8q8rz3eBimPJGYw" /><figcaption>Checkmate</figcaption></figure><h3>🏛️The Strategic Plan</h3><p>The transformation was not improvised It was structured.</p><h4>Pillar 1: Strategy</h4><p>From being on the right… to integrating on the left of the cycle.</p><p>First step: QA could no longer appear at the end.</p><p>We did three fundamental things:</p><h4>Real Presence in Every Team</h4><p>Active integration in:</p><ul><li>Functional definition, Refinements and Planning</li><li>Technical analysis</li><li>API design</li></ul><p>Not as observers, but as active product contributors.</p><blockquote>QA stopped validating only external behavior and It started adding internal value in technical decisions.</blockquote><h4>Increased Capacity &amp; Structured Deliverables</h4><p>We created a structured delivery system:</p><ul><li>Gantt-style roadmap</li><li>Homogeneous internal milestones</li><li>Progressive coverage evolution</li><li>Prioritization by criticality and risk</li><li>Not automation for automation’s sake</li><li>A realistic roadmap aligned with capabilities and context</li></ul><blockquote>Each delivery reduced future uncertainty.</blockquote><h4>Full SDLC Redesign</h4><ul><li>We reevaluated the entire Software Delivery Lifecycle.</li><li>QA became embedded in the process, not appended to it.</li><li>Quality gates at critical points.</li><li>Real metrics.</li><li>Standardized action protocols.</li><li>Unified criteria across teams.</li></ul><blockquote>Quality stopped being a phase and It became a transversal system.</blockquote><h4>Pillar 2: People</h4><p>This was the real change.</p><pre>What a brilliant effort! Couldn&#39;t be prouder of this team </pre><h4>Training &amp; Direct Support</h4><p>Each QA:</p><ul><li>Trained their development team</li><li>Implemented tools together</li><li>Acted as technical support</li><li>Facilitated horizontal communication</li></ul><blockquote>It was Supported not imposed.</blockquote><h4>Clear Responsibility Redefinition</h4><p>To fix ownership:</p><ul><li>Clear role boundaries</li><li>Explicit intrinsic responsibilities</li><li>Quality defined as shared</li><li>Client aligned: quality is part of the product</li></ul><blockquote>A production bug stopped being “QA’s” and It became the team’s.</blockquote><h4>Leadership &amp; Evangelization</h4><p>Key actions:</p><ul><li>Align technical leaders and PMs</li><li>Translate quality into delivery impact</li><li>Show metrics</li><li>Build trust through results</li></ul><p>When teams see:</p><ul><li><strong>Less volatility</strong></li><li><strong>Less uncertainty</strong></li><li><strong>More structural stability</strong></li></ul><blockquote>Resistance disappears, culture shifts.</blockquote><h4>Pillar 3: Technology</h4><p>Automation with architecture, not enthusiasm.</p><ul><li>We introduced real layered testing.</li><li>Worked on integration, mocking and base stability.</li><li>Reduced deployment volatility.</li><li>Designed solid framework scaffolding.</li><li>Prioritized criticality over quantity.</li></ul><blockquote>Automation stopped being a patch It became a habit.</blockquote><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F1300w1HkjihpIY%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExbmI5cDh1eXJ2ZG50dGRqOGg3YTdqd25keDBuemRwM3dranF1aXkxcyZlcD12MV9naWZzX3NlYXJjaCZjdD1n%2F1300w1HkjihpIY%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia3.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExZ2hibHkwaTVmbXNoZnpwNjZsOXByMGg3aG1vMzc1MmFnZ2kzd2l2YSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2F1300w1HkjihpIY%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/07af31e6050e6a19ab7f464043d4b448/href">https://medium.com/media/07af31e6050e6a19ab7f464043d4b448/href</a></iframe><h3>📊Measurable Impact</h3><h4>Production Incidents</h4><ul><li>🔻<strong>88.08</strong>% reduction in production incidents</li><li>🔻Only <strong>2.93</strong>% of defects detected by clients in UAT after deployment</li><li>✅ <strong>97.07</strong>% of defects contained before impacting business</li></ul><blockquote>The change was not “test more” It was detect earlier.</blockquote><h4>Structural Prevention</h4><ul><li>✅ <strong>537</strong> incidents detected in development (previously: 0)</li><li>✅ <strong>326</strong> detected in final phase as safety net</li><li>✅ <strong>863</strong> defects contained in pre-production</li></ul><blockquote>It was system redesign.</blockquote><h4>Layered Coverage</h4><ul><li>✅ 60 / 30 / 10 model (Unit / Integration / UI)</li><li>✅ Drastic reduction of base-to-validation gap</li><li>✅ Higher structural stability</li><li>✅ Less dependency on the last filter</li></ul><h4>Code Quality</h4><ul><li>✅ <strong>43.75</strong>% average improvement in unit code quality</li><li>✅Real increase in testing discipline from development</li><li>✅Better traceability per component</li></ul><blockquote>Quality stopped depending on QA and it became embedded in the code.</blockquote><h4>Delivery</h4><ul><li>🔻 Regression time</li><li>✅ Release speed with lower uncertainty</li><li>✅ Deployment confidence</li><li>🔻 Uncertainty ✅Predictability</li></ul><h3>💡Conclusion: From Testing to Prevention Architecture</h3><p>Transforming QA into SDET is not a technical shift.<br>It’s cultural, strategic, and organizational.</p><p>We improved delivery architecture not just tests</p><p>From:</p><ul><li>QA as final filter</li><li>Testing as phase</li><li>Incidents as inevitable</li></ul><p>To:</p><ul><li>Distributed prevention</li><li>Integrated quality in the SDLC</li><li>Metrics as decision tools</li><li>Shared responsibility</li></ul><p>Reducing production incidents by 88.08% isn’t operational success. It’s the natural consequence of moving detection left.</p><p>Containing 97.07% of defects before business impact isn’t testing efficiency.<br>It’s system design maturity.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F3kD2Eciolhy4VOzjRV%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fv1.Y2lkPWVjZjA1ZTQ3d3Vnejh0em9ucTQydGZpbmg0Ymd1bnZ0Z3U1Y2Znam5ndm9oZjVqdiZlcD12MV9naWZzX3NlYXJjaCZjdD1n%2F3kD2Eciolhy4VOzjRV%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia4.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExcGJ1b2R0N3draWEzN2pkdjBnaGt5aXB5ZTZ3b2NweWJyazBnODFhYiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2F3kD2Eciolhy4VOzjRV%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/f2d64abfe1604ecac88345d8df9316ca/href">https://medium.com/media/f2d64abfe1604ecac88345d8df9316ca/href</a></iframe><h3><strong>Key Learnings</strong></h3><p>Automation is not the strategy it’s the enabler but without model redesign, automation accelerates chaos.</p><p>What isn’t measured doesn’t transform so we started measuring where defects were born, not where they exploded.</p><p><strong>Quality doesn’t belong to QA It belongs to the system.</strong></p><p>️ Real change is <strong>uncomfortable</strong><br> <strong>Redefining responsibilities </strong>was harder than implementing frameworks.</p><blockquote>Stability doesn’t depend on individual talent it depends on model design.</blockquote><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=384c8f12f22e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quality Is Not Negotiable: How I Improved Code Health Across 25+ Teams Without Slowing Delivery]]></title>
            <link>https://medium.com/@alejandrosierraarias_40862/quality-is-not-negotiable-how-i-improved-code-health-across-25-teams-without-slowing-delivery-58df76035f82?source=rss-457e0dd0eb16------2</link>
            <guid isPermaLink="false">https://medium.com/p/58df76035f82</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Alejandro Sierra]]></dc:creator>
            <pubDate>Sat, 21 Feb 2026 20:47:29 GMT</pubDate>
            <atom:updated>2026-11-16T15:06:17.128Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3e38lJBr3mzcjVNC" /></figure><p>Many development teams are deadline-driven but not <strong>quality-driven.</strong></p><p>Releases happen. Features ship.</p><p>But few teams can answer:</p><ul><li><strong>Which quality gates did we pass?</strong></li><li><strong>What defect detection ratio do we have?</strong></li><li><strong>What mutation coverage are we running?</strong></li><li><strong>Do we block a release if tests fail?</strong></li><li><strong>Are we protecting integration between teams?</strong></li></ul><blockquote>Quality is intrinsic to the product. Whether you are Apple, Amazon, or JohnDoeShoes.com ,stakeholders expect stability, reliability and trust.</blockquote><p>As a Quality &amp; Delivery Excellence Lead, I led a structured quality transformation across 25+ teams in production environments without impacting delivery velocity.</p><h3>Phase 1 — Analysis: Establishing the Baseline</h3><p>Before improving anything, we needed visibility.</p><p>Most teams believe they know their delivery health. Very few actually measure it.</p><p>The first phase was a structured discovery process focused on understanding how teams truly operated not how they thought they operated.</p><h4>1. SDLC Mapping</h4><ul><li><strong><em>How code moved from commit to production</em></strong></li><li><strong><em>What tests were executed and when</em></strong></li><li><strong><em>What environments were used and how stable they were</em></strong></li><li><strong><em>Whether releases were blocked by quality gates or just by deadlines</em></strong></li><li><strong><em>How integration between teams was validated</em></strong></li></ul><blockquote>The goal was not to judge. It was to observe patterns.</blockquote><h4>2. Defining Baseline KPIs</h4><p>We established measurable quality indicators:</p><ul><li><strong>Defect Detection Ratio (DDR)<br></strong> How many defects were detected before production vs total defects.</li><li><strong>Defect Leakage Ratio<br></strong> What percentage of issues escaped into production.</li></ul><p>These two metrics immediately reveal the maturity of the testing strategy.</p><h4>3. Mutation Testing Baseline</h4><p>Coverage alone is misleading. You can have 85% line coverage and still have weak tests.</p><p>So we can introduced mutation testing to evaluate test robustness:</p><ul><li>Stryker for Front-End</li><li>PIT for Back-End</li></ul><p>We measured:</p><ul><li>Mutation coverage</li><li>Line coverage</li><li>Number of tested classes</li><li>Survived mutations</li></ul><p>This gave us a real picture of test strength not just quantity.</p><blockquote>The outcome of Phase 1 was simple: We replaced perception with data.</blockquote><h3>Front-End &amp; Back-End — Mutation Testing (Stryker and Pitest)</h3><blockquote><em>During Phase 1, </em>Initial mutation score revealed high line coverage but weak mutation resistance indicating superficial test assertions.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ty7U9JSuUEliZ5ezY1MQ6g.png" /><figcaption><strong>STRYKER PHASE 1. </strong>Example mutation report</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TtkBrwKLJ6L48k7j" /><figcaption><strong>PITEST PHASE 1. </strong>Example mutation report</figcaption></figure><h3>Phase 2 — Strategy &amp; Implementation: Building a Sustainable System</h3><blockquote>The objective was never to increase coverage for one quarter.</blockquote><blockquote>The objective was to embed quality into the SDLC permanently.</blockquote><blockquote>This phase focused on system design, not isolated fixes.</blockquote><h3>Strategic Pillars</h3><h4>1. Tooling Standardization</h4><p>We defined clear tooling by technology stack:</p><ul><li>Mutation testing per layer (FE/BE)</li><li>Unit testing frameworks aligned across teams</li><li>Static analysis tooling defined and respected</li></ul><p>Standardization reduces variability and accelerates adoption.</p><h4>2. Git Hook Governance</h4><p>To protect the integrity of the codebase before CI even starts, we implemented:</p><ul><li>Husky templates for Front-End</li><li>Spotless enforcement for Back-End</li></ul><p>These hooks ensured:</p><ul><li>Code formatting compliance</li><li>Linting rules</li><li>Test execution pre-push (when applicable)</li><li>Prevention of low-quality commits</li></ul><p>Quality begins before CI/CD.</p><p><strong>Pre commit Hooks used with Husky:</strong></p><pre># Check for sensitive data<br>echo &quot;🔍 Checking for sensitive data...&quot;<br>SENSITIVE_PATTERNS=&quot;(password|passwd|pass|pwd|secret|token|key|api_key|private_key|auth_token|auth|bearer|basic_auth|credentials|client_secret|access_token|refresh_token|jwt|cookie|session)&quot;<br>SENSITIVE_FILES=$(git diff --cached --name-only | grep -v -E &#39;^.husky/|^eslint.config.|.env.example$&#39; | xargs grep -l -i -E &quot;$SENSITIVE_PATTERNS&quot; 2&gt;/dev/null || true)<br><br>if [ -n &quot;$SENSITIVE_FILES&quot; ]; then<br>    echo &quot;❌ ALERT: Potential sensitive data detected in:&quot;<br>    echo &quot;$SENSITIVE_FILES&quot;<br>    echo &quot;🚫 Commit aborted&quot;<br>    exit 1<br>fi<br>echo &quot;✅ No sensitive data detected&quot;<br><br># Commented-out code detection<br>echo &quot;🔍 Checking for commented-out code...&quot;<br>COMMENT_FILES=$(git diff --cached --name-only | grep -E &#39;\.(ts|tsx|js|jsx)$&#39;)<br>if [ -n &quot;$COMMENT_FILES&quot; ]; then<br>    COMMENTED_CODE=$(echo &quot;$COMMENT_FILES&quot; | xargs awk &#39;<br>    {<br>        if ($0 ~ /^\s*\/\//) {<br>            print FILENAME&quot;:&quot;NR&quot;:&quot;$0&quot; -&gt; Possible commented-out code&quot;<br>        }<br>    }&#39; 2&gt;/dev/null)<br>    if [ -n &quot;$COMMENTED_CODE&quot; ]; then<br>        echo &quot;⚠️ Commented-out code detected:&quot;<br>        echo &quot;$COMMENTED_CODE&quot; | head -5<br>        echo &quot;💡 Recommendation: Please remove unnecessary code. If temporary, use // TODO: or // FIXME:&quot;<br>        exit 1<br>    fi<br>fi<br>echo &quot;✅ No problematic commented-out code detected&quot;<br><br># Run lint-staged (ESLint + Prettier on modified files)<br>echo &quot;🔍 Checking frontend files...&quot;<br>cd frontend<br>if npx lint-staged; then<br>    echo &quot;✅ Frontend files formatted and lint-free&quot;<br>else<br>    echo &quot;❌ Linting or formatting failed - Commit blocked&quot;<br>    exit 1<br>fi<br>cd ..<br><br># TypeScript type validation<br>echo &quot;🔍 Checking for TypeScript typing errors...&quot;<br>if cd frontend &amp;&amp; npx tsc --noEmit; then<br>    echo &quot;✅ No TypeScript typing errors found&quot;<br>else<br>    echo &quot;❌ TypeScript typing errors detected - Commit blocked&quot;<br>    exit 1<br>fi<br><br>echo &quot;✅ Pre-commit checks completed successfully&quot;<br>exit 0</pre><h4>3. Defined Quality Gates</h4><p>We formalized:</p><ul><li>Minimum mutation thresholds</li><li>Coverage expectations</li><li>Release blocking criteria</li><li>Checkpoints within the delivery cycle</li></ul><h4>4. Standardized Quality Framework Repositories</h4><h4>Git Hooks Repository (Husky Templates)</h4><p><a href="https://github.com/alejandrosierraariasDev/codeguard-flow">GitHub - alejandrosierraariasDev/codeguard-flow</a></p><ul><li>Centralized pre-commit and pre-push hooks</li><li>Formatting, linting and test enforcement</li><li>GitHub-based reusable templates</li></ul><h4>Front-End Mutation Framework (Stryker)</h4><p><a href="https://github.com/alejandrosierraariasDev/mutation-testing-stryker">GitHub - alejandrosierraariasDev/mutation-testing-stryker: Stryker Mutator (Stryker) is a mutation testing tool for front-end projects. It works by introducing code mutations and checking if your tests detect them. It supports JavaScript, TypeScript, React, Angular, and Vue through popular test runners (Jest, Mocha, Jasmine, Karma).</a></p><ul><li>Preconfigured mutation testing setup</li><li>Defined mutation thresholds</li><li>Standardized reporting structure</li></ul><h4>Back-End Mutation Framework (PIT)</h4><p><a href="https://github.com/alejandrosierraariasDev/mutation-testing-pitest">GitHub - alejandrosierraariasDev/mutation-testing-pitest: This project uses mutation testing with Pitest for Java, evaluating the effectiveness of unit tests. It includes CI/CD integration with GitHub Actions to automatically generate mutation coverage reports, ensuring code quality and professionalism.</a></p><ul><li>Unified PIT configuration</li><li>CI-ready execution</li><li>Consistent mutation score baseline</li></ul><blockquote>These repositories acted as accelerators.<br> Instead of asking teams to “improve quality”, we gave them a ready-to-adopt system.</blockquote><h4>5. QA as the Change Enabler</h4><p>Instead of centralizing control, we empowered QA as the transformation driver.</p><p>QA received:</p><ul><li>Formal mutation testing training</li><li>Centralized repositories:</li><li>Git hooks templates</li><li>PIT templates</li><li>Stryker templates</li><li>Reporting frameworks</li></ul><p>They acted as:</p><ul><li>Evangelists</li><li>1:1 technical mentors</li><li>Quality auditors</li><li>Delivery safeguards</li></ul><p>This shifted QA from reactive testing to proactive quality governance.</p><p>And most importantly:</p><blockquote>Quality became collaborative, not imposed.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*4uadAuxGurN9KkrLH6-UyA.png" /><figcaption><strong>Delivery Improvement in SDLC</strong></figcaption></figure><h3>Phase 3 — Measurement &amp; Tracking: Making Progress Visible</h3><p>Transformation without tracking is illusion.</p><p>We defined recurring measurement cycles aligned to sprints and releases.</p><p>We tracked:</p><ul><li>Defect Detection Ratio (DDR) : <strong>DDR (%)=(Defects detected/Total existing defects)×100</strong></li><li>Defect Leakage Ratio (DLR) : <strong>DLR (%)=(Defects found in later phase or production/Total defects detected)×100</strong></li><li>Mutation Coverage (FE &amp; BE)</li><li>Line Coverage</li><li>Survived mutations</li><li>Class coverage growth</li><li>Release stability</li></ul><p>We established checkpoints to identify:</p><ul><li>Knowledge silos</li><li>Teams requiring additional coaching</li><li>High-performing teams to use as benchmarks</li></ul><p>Tracking allowed us to detect:</p><ul><li>Coverage stagnation</li><li>Regression in test robustness</li><li>Overconfidence without real improvement</li></ul><blockquote>Most importantly, it allowed leadership to see quality evolution as a business metric not just a technical one.</blockquote><h3>Phase 4 — Measurable Impact: Demonstrating Structural Improvement</h3><p>Impact must be observable over time.</p><p>We measured a full quarter (Q), comparing:</p><ul><li>Initial baseline (A)</li><li>End-of-quarter state (Z)</li></ul><p>Across both Front-End and Back-End.</p><p>The improvement was calculated as the aggregated delta between the start and end of the quarter across both layers.</p><p>This allowed us to evaluate structural evolution not isolated spikes.</p><h3>Front-End — Mutation Testing (Stryker) and Back-End — Mutation Testing (PIT)</h3><blockquote><em>During Phase 4, we measured mutation score evolution across the quarter.<br>We evaluate test strength at bytecode level.<br> The goal was to measure resilience against artificial faults, ensuring real defect detection capacity.</em></blockquote><h3>Results</h3><p>Across more than 25 production teams, the transformation generated measurable structural improvements:</p><ul><li>Significant average improvement in overall code health across both Front-End and Back-End layers</li><li>Strong individual team uplifts, with multiple teams tripling their mutation resistance baseline</li><li>Near total defect detection before production release</li><li>Neartotal containment of production incidents</li><li>Noticeable uplift in both greenfield and brownfield environments</li><li>Stabilization of previously closed or legacy heavy projects</li><li>Substantial improvement in legacy dominated systems where test robustness was historically weak</li></ul><blockquote><em>Exact values have been intentionally abstracted to preserve confidentiality. The trends and proportional improvements reflect real production environments.</em></blockquote><p>More importantly:</p><p>Delivery velocity was not negatively impacted.</p><p>In several cases, it improved due to reduced rework and fewer production incidents.</p><h3>Final Reflection</h3><blockquote>Quality is not an optional enhancement.</blockquote><p>It directly impacts:</p><ul><li><strong>Credibility</strong></li><li><strong>Reliability</strong></li><li><strong>Scalability</strong></li><li><strong>Stakeholder trust</strong></li><li><strong>Financial performance</strong></li></ul><blockquote>Whether you are Apple, Amazon, or a small digital startup, quality defines how your product is perceived.</blockquote><blockquote>And quality is not owned by QA alone.It is a shared responsibility across the SDLC.</blockquote><blockquote>The role of leadership is not to enforce quality once but to design systems where quality becomes the default behavior.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MclzRWUqG_3F7tPx" /></figure><p>Alejandro Sierra writes about quality engineering and delivery. More at <a href="https://alejandrosierra.dev/">alejandrosierra.dev</a> and on <a href="https://www.linkedin.com/in/alejandro-sierra/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58df76035f82" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>