<?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 QASimplifiedByAkash on Medium]]></title>
        <description><![CDATA[Stories by QASimplifiedByAkash on Medium]]></description>
        <link>https://medium.com/@codinghoum?source=rss-50da0710f1ae------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*DIqYdBE42BaKRE37jHRUbQ.png</url>
            <title>Stories by QASimplifiedByAkash on Medium</title>
            <link>https://medium.com/@codinghoum?source=rss-50da0710f1ae------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:40:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@codinghoum/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[A Company Cancelled His Offer 10 Days Before Joining. His Employer Wouldn’t Take Him Back.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@codinghoum/a-company-cancelled-his-offer-10-days-before-joining-his-employer-wouldnt-take-him-back-ff4b155b26a9?source=rss-50da0710f1ae------2"><img src="https://cdn-images-1.medium.com/max/1536/1*XTD0BSC-IMUVkLHA6WsKAw.png" width="1536"></a></p><p class="medium-feed-snippet">A real story about the 90-day notice trap, and what you should do before you resign.</p><p class="medium-feed-link"><a href="https://medium.com/@codinghoum/a-company-cancelled-his-offer-10-days-before-joining-his-employer-wouldnt-take-him-back-ff4b155b26a9?source=rss-50da0710f1ae------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@codinghoum/a-company-cancelled-his-offer-10-days-before-joining-his-employer-wouldnt-take-him-back-ff4b155b26a9?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff4b155b26a9</guid>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[india]]></category>
            <category><![CDATA[job-hunting]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[jobs]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 04:56:55 GMT</pubDate>
            <atom:updated>2026-11-16T04:56:55.621Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[5 Myths About QA That Junior Testers Still Believe | The Testing Mindset]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@codinghoum/5-myths-about-qa-that-junior-testers-still-believe-666972f1fdcf?source=rss-50da0710f1ae------2"><img src="https://cdn-images-1.medium.com/max/1536/1*ViPI3mso7oHTkRM40hiI-g.png" width="1536"></a></p><p class="medium-feed-snippet">In 13 years of QA, I&#x2019;ve watched junior testers believe these five things. I believed some of them myself.</p><p class="medium-feed-link"><a href="https://medium.com/@codinghoum/5-myths-about-qa-that-junior-testers-still-believe-666972f1fdcf?source=rss-50da0710f1ae------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@codinghoum/5-myths-about-qa-that-junior-testers-still-believe-666972f1fdcf?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/666972f1fdcf</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 05:02:49 GMT</pubDate>
            <atom:updated>2026-11-11T05:58:06.235Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Interview Solved #8: Honeywell — QA API Tester Interview Decoded: What They Ask, What They Expect &…]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@codinghoum/interview-solved-8-honeywell-qa-api-tester-interview-decoded-what-they-ask-what-they-expect-9c72630d9f8b?source=rss-50da0710f1ae------2"><img src="https://cdn-images-1.medium.com/max/1456/0*y-g4GcqDBUanQpiz.png" width="1456"></a></p><p class="medium-feed-snippet">Experience category: 3&#x2013;6 years (QA Engineer / API Tester / Automation Engineer)</p><p class="medium-feed-link"><a href="https://medium.com/@codinghoum/interview-solved-8-honeywell-qa-api-tester-interview-decoded-what-they-ask-what-they-expect-9c72630d9f8b?source=rss-50da0710f1ae------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@codinghoum/interview-solved-8-honeywell-qa-api-tester-interview-decoded-what-they-ask-what-they-expect-9c72630d9f8b?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c72630d9f8b</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[restassured]]></category>
            <category><![CDATA[interview-preparation]]></category>
            <category><![CDATA[api-testing]]></category>
            <category><![CDATA[software-testing]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 03:31:01 GMT</pubDate>
            <atom:updated>2026-11-10T03:31:01.776Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Risk-Based Testing: How Good QA Engineers Decide What to Test First | QA Fundamentals #4]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@codinghoum/risk-based-testing-how-good-qa-engineers-decide-what-to-test-first-qa-fundamentals-4-1f0df1dd9b81?source=rss-50da0710f1ae------2"><img src="https://cdn-images-1.medium.com/max/995/0*Rcm4u3yUGUAppbLi.png" width="995"></a></p><p class="medium-feed-snippet">Every tester runs out of time eventually. The good ones have already decided what gets tested before that happens.</p><p class="medium-feed-link"><a href="https://medium.com/@codinghoum/risk-based-testing-how-good-qa-engineers-decide-what-to-test-first-qa-fundamentals-4-1f0df1dd9b81?source=rss-50da0710f1ae------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@codinghoum/risk-based-testing-how-good-qa-engineers-decide-what-to-test-first-qa-fundamentals-4-1f0df1dd9b81?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f0df1dd9b81</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[test-strategy]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 06:32:52 GMT</pubDate>
            <atom:updated>2026-11-09T06:32:52.873Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[HTTP for QA Engineers: Understanding Requests and Responses | API Testing Foundations # 2]]></title>
            <link>https://medium.com/@codinghoum/http-for-qa-engineers-understanding-requests-and-responses-api-testing-foundations-2-5faf35b7cbcd?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/5faf35b7cbcd</guid>
            <category><![CDATA[sdet-interview]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[quality-engineering]]></category>
            <category><![CDATA[api-testing]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 03:53:44 GMT</pubDate>
            <atom:updated>2026-11-04T03:53:44.559Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xGpbSCxgfhqdf5zt.jpeg" /></figure><p>Abug report comes in: <em>“Checkout fails sometimes.”</em></p><p>A tester who only works through the UI reproduces it, attaches a screenshot of a spinner, and assigns it to the frontend team. The frontend team says it’s a backend issue. The backend team says they can’t reproduce it. Three days later, it’s still open.</p><p>A tester who understands HTTP opens DevTools, reproduces it once, and finds the POST /api/orders call returning <strong>504 Gateway Timeout</strong> after 30 seconds, but only when the cart has more than 20 items. The bug report now has a request, a response, a pattern, and an owner. It gets fixed that sprint.</p><p>Same bug, same tester skill level, very different result. The difference is knowing what’s happening underneath the screen.</p><p>This article isn’t a protocol textbook. It covers the parts of HTTP that change how you test and how you report bugs.</p><h3>Why HTTP matters even if you “only do UI testing”</h3><p>Every modern web and mobile app is a front end talking to APIs over HTTP. When you click a button, the UI is mostly packaging a request and displaying a response.</p><p>That means:</p><ul><li><strong>Most “UI bugs” aren’t UI bugs.</strong> The screen is just showing what the API returned.</li><li><strong>The UI hides information.</strong> A generic “Something went wrong” toast might be a 400, a 401, a 409, or a 500. Each one means something completely different.</li><li><strong>The UI can mislead you.</strong> A success message can appear even when the API failed, and a stale value can come from cache.</li></ul><p>If you can read HTTP traffic, you stop guessing and start diagnosing.</p><h3>The request: what the client asks for</h3><p>An HTTP request has four parts: <strong>method, URL, headers, and body.</strong></p><h4>Method</h4><p>The method states the intent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GdclU3dDwVI20LEC.png" /></figure><p>The POST row is where real money is lost. A user double-clicks “Pay,” or the network retries, and two identical POSTs hit the server. Does the customer get charged twice? This is <strong>idempotency</strong>, and testing it is a valuable check that’s easy to skip.</p><h4>URL</h4><p><a href="https://shop.example.com/api/v1/orders/1042?include=items">https://shop.example.com/api/v1/orders/1042?include=items</a></p><ul><li><strong>Path</strong> (/orders/1042) identifies the resource.</li><li><strong>Query params</strong> (?include=items) filter or shape the result.</li></ul><p>The most important test here is simple: <strong>change the ID.</strong> If logging in as User A and calling /orders/1043 returns User B’s order, you’ve found an Insecure Direct Object Reference (IDOR). It’s one of the most common serious API vulnerabilities, and finding it doesn’t take a security tool. Swapping a number is enough.</p><h4>Headers</h4><p>Headers carry context. The ones QA touches most:</p><ul><li>Authorization: who you are (Bearer token, Basic auth)</li><li>Content-Type: what format the body is in</li><li>Accept: what format you want back</li><li>Cookie: session data from the browser</li></ul><p>Negative tests that take very little time:</p><ul><li>No Authorization header → expect <strong>401</strong></li><li>Valid token, but for a user without permission → expect <strong>403</strong></li><li>Expired token → expect <strong>401</strong>, with a clear message</li><li>Wrong Content-Type → expect <strong>415</strong> or <strong>400</strong>, not 500</li></ul><h4>Body</h4><p>The body carries the payload, usually JSON. This is where input validation gets tested:</p><ul><li>Required field missing</li><li>Wrong type (&quot;quantity&quot;: &quot;five&quot;)</li><li>Boundaries (0, -1, 99999999)</li><li>Empty string vs null vs field absent (APIs often treat these three differently, and inconsistently)</li><li>Extra fields the API doesn’t expect. Are they ignored, rejected, or, worse, saved? (&quot;role&quot;: &quot;admin&quot; on a profile update is the classic case.)</li></ul><h3>The response: what the server says back</h3><p>A response has a <strong>status code, headers, and body.</strong> Most weak API tests read only the first.</p><h4>Status codes: learn the ones that matter</h4><p>You don’t need all of them. You need to know these well:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CbNoZY3n0A0JVJt9.png" /></figure><p><strong>The rule to remember: a 500 caused by user input is always a bug.</strong> The server should have validated the input and returned a 4xx. A 500 means it didn’t, and that the input reached a part of the code that wasn’t expecting it.</p><p>Also watch for the opposite problem: <strong>APIs that return 200 for everything</strong> and put the error inside the body ({&quot;success&quot;: false}). Monitoring, retries, and automation tools all depend on status codes. If the API returns 200 for a failure, all of those tools will treat it as a success.</p><h4>Response headers</h4><p>Check these, especially on auth and sensitive endpoints:</p><ul><li>Content-Type matches what’s actually in the body</li><li>Set-Cookie for sessions includes HttpOnly (JavaScript can’t read it) and Secure (HTTPS only)</li><li>Cache-Control: no-store on responses with personal or financial data</li><li>No headers leaking server versions or internal details</li></ul><h4>Response body</h4><p>This is where “status 200, test passed” falls apart. Check:</p><ul><li><strong>Schema:</strong> are the fields, types, and nesting what the contract promises?</li><li><strong>Values:</strong> is the total correct? Is the status right? Is the timestamp in the right timezone?</li><li><strong>Data exposure:</strong> does the user profile response include the password hash, internal IDs, or other users’ data?</li><li><strong>Error quality:</strong> is the message useful to the client, without stack traces, SQL errors, or file paths?</li></ul><h3>HTTP is stateless, which is why sessions break</h3><p>HTTP doesn’t remember anything between requests. Every request has to prove who it is, again and again. That’s what cookies and tokens are for.</p><p>This is the source of a whole family of bugs testers see regularly:</p><ul><li>Logged out on page refresh</li><li>Logged in on one tab, logged out on another</li><li>Session survives logout (the token still works after the user clicks “Logout”)</li><li>Token never expires</li><li>Old token still works after a password change</li></ul><p>Each of these can be tested directly at the HTTP level. For example, capture a token, log out, and replay a request with the old token. If it still works, logout is only cosmetic.</p><h3>Your HTTP testing toolkit</h3><p>You don’t need anything fancy to start:</p><ul><li><strong>Browser DevTools → Network tab:</strong> watch real traffic, filter by Fetch/XHR, inspect requests and responses, and use “Copy as cURL” to reproduce outside the UI.</li><li><strong>cURL:</strong> the fastest way to replay and tweak a request.</li><li><strong>Postman / Bruno / Insomnia:</strong> organize requests, add assertions, and build collections.</li><li><strong>Code-based clients:</strong> REST Assured, Playwright’s request context, or Python requests for automation.</li></ul><p>A workflow that works well in practice:</p><ol><li>Reproduce the bug in the browser with DevTools open.</li><li>Find the failing request.</li><li><strong>Copy as cURL</strong> and replay it from the terminal.</li><li>Change one thing at a time (body, header, ID) until you isolate the cause.</li><li>Attach the request, response, and your finding to the bug.</li></ol><p>That’s how “checkout fails sometimes” turns into “POST /orders times out when the cart has more than 20 items.”</p><h3>Writing better bug reports with HTTP</h3><p>Compare these two:</p><blockquote>“Profile update not working. Screenshot attached.”</blockquote><blockquote>“PATCH /api/v1/users/me returns 500 when <em>phone</em> includes a ‘+’ prefix. Same request without ‘+’ returns 200. Request/response attached. Expected: 200, or 400 with a validation message.”</blockquote><p>The second one needs no back-and-forth. It names the endpoint, the trigger, the expected result, and the evidence. Developers fix these first because they can start immediately.</p><h3>A practical HTTP checklist for every endpoint you test</h3><p><strong>Request side</strong></p><ul><li>Correct method accepted, wrong methods rejected (405)</li><li>Missing / invalid / expired auth handled (401/403)</li><li>Other users’ resource IDs blocked</li><li>Required, optional, extra, null, and empty fields handled</li><li>Boundary and type validation returns 4xx, never 5xx</li><li>Duplicate POSTs don’t create duplicate side effects</li></ul><p><strong>Response side</strong></p><ul><li>Status code is the <em>correct</em> one, not just a 2xx</li><li>Body matches the schema and the values are correct</li><li>No sensitive data in body or headers</li><li>Error messages are helpful and safe</li><li>Auth cookies have HttpOnly and Secure</li><li>Response time is acceptable</li></ul><h3>The takeaway</h3><p>You don’t need to memorize RFCs to test APIs well. You need to see clearly what goes out and what comes back.</p><p>Once you read HTTP easily, three things change. Your bug reports get sharper. Your negative testing gets more thorough. And you stop treating the UI as the source of truth, because you know it’s only showing what the API returned.</p><p>Start this week: pick one feature you test daily, open the Network tab, and read every request it makes. You’ll likely find at least one thing you’ve never checked.</p><p><em>Next Wednesday: GET, POST, PUT, PATCH and DELETE with Real Testing Examples</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5faf35b7cbcd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Maintenance Cost of Test Automation | Automation Foundations # 3]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@codinghoum/the-hidden-maintenance-cost-of-test-automation-automation-foundations-3-979e6a35c232?source=rss-50da0710f1ae------2"><img src="https://cdn-images-1.medium.com/max/1456/0*F8F_r5Q_oFWs2NoB.png" width="1456"></a></p><p class="medium-feed-snippet">Writing the test was the easy part. Keeping it alive is the real job</p><p class="medium-feed-link"><a href="https://medium.com/@codinghoum/the-hidden-maintenance-cost-of-test-automation-automation-foundations-3-979e6a35c232?source=rss-50da0710f1ae------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@codinghoum/the-hidden-maintenance-cost-of-test-automation-automation-foundations-3-979e6a35c232?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/979e6a35c232</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[qa-automation]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 06:26:18 GMT</pubDate>
            <atom:updated>2026-11-03T06:26:18.637Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Stop Automating Everything: How to Spot a Test Worth Automating | Automation Foundations #2]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@codinghoum/stop-automating-everything-how-to-spot-a-test-worth-automating-automation-foundations-d0b863fb99d6?source=rss-50da0710f1ae------2"><img src="https://cdn-images-1.medium.com/max/1888/1*PzxXHx9qf1d8sJ6x3KaFdw.jpeg" width="1888"></a></p><p class="medium-feed-snippet">Seven traits that separate high-value automation from scripts you&#x2019;ll regret</p><p class="medium-feed-link"><a href="https://medium.com/@codinghoum/stop-automating-everything-how-to-spot-a-test-worth-automating-automation-foundations-d0b863fb99d6?source=rss-50da0710f1ae------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@codinghoum/stop-automating-everything-how-to-spot-a-test-worth-automating-automation-foundations-d0b863fb99d6?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0b863fb99d6</guid>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[qa-engineering]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 20:19:32 GMT</pubDate>
            <atom:updated>2026-10-28T07:35:23.123Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Microsoft’s 60,000-Person Exit Offer Is a Preview of How Tech Will Reshape Work]]></title>
            <link>https://medium.com/@codinghoum/microsofts-60-000-person-exit-offer-is-a-preview-of-how-tech-will-reshape-work-866ff53ddf99?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/866ff53ddf99</guid>
            <category><![CDATA[layoffs]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[microsoft]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 03:31:02 GMT</pubDate>
            <atom:updated>2026-10-27T03:31:02.094Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fe-By56oslwzmKMNidgb7w.png" /></figure><p>On October 26, 2026, Microsoft introduced something it had never tried before: a <strong>Voluntary Exit Offer</strong>. Eligible employees in participating teams across the United States, Canada, India and the United Kingdom, at level 70 and below, can choose to leave the company with financial support and career-planning resources.</p><p>About 60,000 people are eligible, roughly 27% of Microsoft’s 223,000-person workforce. Employees have until early December to decide, and those who accept leave on December 31.</p><p>The headline number is striking, but the method matters more.</p><h3>This is not a layoff, and that’s the point</h3><p>A layoff is a decision made <em>for</em> you. A voluntary exit is a decision handed <em>to</em> you. Microsoft describes the offer as a way to give employees “a new choice” while letting participating organizations adapt to changing needs.</p><p>It also isn’t a one-off. Microsoft says the program builds on its Voluntary Retirement Program from earlier this year. According to CNBC, that April program covered about 7% of U.S. employees, and it was followed in July by plans to lay off 4,800 people.</p><p>Put the three together and a pattern appears: a retirement window, then targeted cuts, then a broad voluntary exit. Workforce reshaping is no longer a single event every few years. It is becoming a continuous process.</p><h3>Why now: AI is expensive</h3><p>Microsoft is spending heavily on data centers to meet AI computing demand, supplying cloud capacity to companies such as OpenAI and Anthropic. It said capital expenditures for the September quarter would exceed $50 billion, up from $34.9 billion in the same quarter a year earlier.</p><p>That spending has to be balanced somewhere. Microsoft is also moving toward charging customers based on how much AI they actually use, and it has given programmers, sellers and supply-chain teams AI tools that it says are producing noticeable results.</p><p>The underlying message: the company wants the right talent for its biggest growth opportunities without weakening its financial profile.</p><h3>What “eligible” really means</h3><p>It is easy to read this as “60,000 people are leaving Microsoft.” That isn’t what happened. Sixty thousand people <em>can</em> say yes. Not every organization is offering the program; participation depends on each business’s priorities, customer commitments and workforce needs.</p><p>The real number will become clear only after December. Until then, any claim about mass departures is speculation.</p><h3>Lessons for anyone working in tech</h3><p><strong>1. Optionality is now a career skill.</strong> When a company offers you a paid exit, the question isn’t only whether you should take the money. It’s whether you have somewhere better to go. People who have kept their skills, network and public profile current can decide from a position of strength.</p><p><strong>2. Visible impact beats quiet effort.</strong> When leadership asks which work matters most, the answer goes to people whose contribution is easy to see and measure. Doing good work is no longer enough; others need to understand its value.</p><p><strong>3. AI changes the shape of roles, not just the headcount.</strong> The shift is toward people who can deliver more with AI and make sure AI-assisted work is reliable.</p><p>For those of us in quality engineering, that last point is the opportunity. As more code, tests and decisions are produced with AI, someone has to verify that the output is correct, safe and trustworthy. That makes testing judgment more valuable, not less.</p><h3>The bigger picture</h3><p>Microsoft has said it will learn from this program and keep adjusting. Other large tech companies are facing the same pressure from AI costs, so similar programs may follow.</p><p>The best response isn’t fear. It’s preparation: build skills that complement AI, make your work visible and keep your options open before someone else decides for you.</p><p><em>If you received an offer like this, would you take it or stay and reskill?</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=866ff53ddf99" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Error, Bug, Defect, Failure and Incident: Finally Explained | QA Fundamentals #3]]></title>
            <link>https://medium.com/@codinghoum/error-bug-defect-failure-and-incident-finally-explained-qa-fundamentals-3-e847b46b39d4?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/e847b46b39d4</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 08:26:31 GMT</pubDate>
            <atom:updated>2026-10-26T08:26:31.691Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O3OAQv1LapSDzYb-.jpeg" /></figure><p>Ask five QA engineers what the difference is between a bug and a defect, and you’ll likely get five different answers. Ask them where a failure ends and an incident begins, and the answers get even less clear.</p><p>That isn’t just a vocabulary problem. When a team uses these words loosely, bug reports get misclassified, defect metrics stop meaning anything, root cause analysis looks in the wrong place, and interview answers sound memorized instead of understood.</p><p>This article covers all five terms: what each one means, how they connect, where people get them wrong, and how to use them in real QA work.</p><h3>The chain in one line</h3><p>Before the details, here’s the overall picture:</p><p><strong>A person makes an error → the error leaves a defect (also called a bug) in a work product → the defect is triggered at runtime and causes a failure → a failure in production that affects users or the business becomes an incident.</strong></p><p>Each term describes a different stage of the same problem. Once you see it as a chain, the definitions are easy to remember.</p><h3>1. Error: where it starts</h3><p>An <strong>error</strong> is a human mistake. It happens in someone’s thinking or in their work before it shows up anywhere else.</p><p>Some examples:</p><ul><li>A developer misreads a requirement.</li><li>A business analyst leaves out an edge case.</li><li>An architect assumes a downstream service will always respond in time.</li><li>A tester writes the wrong expected result in a test case.</li></ul><p>You can’t test for an error directly, because it happens inside someone’s head. What you can find is what it leaves behind.</p><p><strong>Why it matters to QA:</strong> When you do root cause analysis, you’re looking for the error. “The code had a wrong condition” describes the defect. “The developer misread an ambiguous requirement” describes the error, and that’s the part that tells you what process needs to change.</p><h3>2. Defect: what the error leaves behind</h3><p>A <strong>defect</strong> is a flaw in a work product that can stop it from doing what it’s supposed to do. It’s what the error produces.</p><p>Many people miss that defects aren’t limited to code. They can be found in:</p><ul><li><strong>Requirements</strong>: missing, ambiguous, or contradictory rules</li><li><strong>Design</strong>: wrong assumptions about scale, flow, or integration</li><li><strong>Code</strong>: wrong logic, wrong conditions, unhandled exceptions</li><li><strong>Configuration</strong>: wrong values, missing feature flags, incorrect environment settings</li><li><strong>Test assets</strong>: wrong expected results, outdated assertions, broken locators</li></ul><p>A defect is static. It sits in the product and does nothing until something triggers it.</p><p><strong>Why it matters to QA:</strong> The earlier you find a defect, the cheaper it is to fix. A defect found during a requirement review costs one conversation. The same defect found in production can cost a hotfix, refunds, and customer trust. That’s why reviews and static testing count as testing too.</p><h3>3. Bug: the word everyone uses</h3><p>So where does <strong>bug</strong> fit in?</p><p>In standard terminology, including ISTQB, <strong>bug, defect, and fault are synonyms</strong>. They all mean a flaw in a work product.</p><p>In practice, teams often draw their own lines:</p><ul><li>Some use <strong>bug</strong> for coding problems found during testing and <strong>defect</strong> for any deviation from requirements, including requirements and design problems.</li><li>Some separate them by timing: problems caught <strong>before release</strong> are bugs, and problems that <strong>escape to customers</strong> are defects.</li><li>Some use <strong>defect</strong> as the formal term in trackers and reports and <strong>bug</strong> as everyday shorthand.</li></ul><p>None of these is wrong, but they can’t all apply at once in the same team.</p><p><strong>What to do in practice:</strong></p><ol><li><strong>Learn your team’s definitions.</strong> If your tracker has separate issue types such as Bug, Defect, and Improvement, find out what each one means for your project.</li><li><strong>Classify consistently.</strong> Choosing the wrong type distorts metrics like defect leakage, escape rate, and defect density. Leadership decisions get made from those numbers.</li><li><strong>Don’t argue about the label.</strong> A developer cares much more about whether your report is clear, reproducible, and shows the impact than about what you called it.</li></ol><h3>4. Failure: what users see</h3><p>A <strong>failure</strong> happens when the system doesn’t behave as expected while it’s running.</p><p>If a defect is static, a failure is dynamic. It only happens when the faulty code runs under the conditions that trigger the flaw.</p><p>Take a payment function with a wrong rounding rule. That rule is a <strong>defect</strong>. If no transaction ever hits that rounding case, nobody sees a problem. When one does, the customer is charged the wrong amount, and that’s the <strong>failure</strong>.</p><p>There are three points here that many QA engineers miss:</p><p><strong>A defect doesn’t always cause a failure.</strong> If a code path never runs, its defects stay hidden. This is why coverage matters. Tests that never reach a piece of code can’t show what’s wrong with it. It’s also why a product can run for years before a rare input finally exposes a long-standing defect.</p><p><strong>A failure doesn’t always come from a product defect.</strong> Environment instability, network problems, hardware faults, bad test data, expired certificates, and misconfigured deployments can all cause failures while the code itself is correct. This is why you should reproduce and isolate a failure before you log it as a product defect.</p><p><strong>Your test can be the defect.</strong> A failing automated test doesn’t automatically mean the product is broken. The script might have a bad locator, an outdated assertion, a timing problem, or a hardcoded value. Experienced automation engineers check their own test first before they blame the application.</p><p><strong>A useful way to frame it:</strong> testing reveals failures, and debugging finds the defect behind them. They’re separate activities, often done by different people, and mixing them up creates confusion in triage.</p><h3>5. Incident: when the business feels it</h3><p>An <strong>incident</strong> is an unplanned event that disrupts or degrades a live service and needs a managed response.</p><p>Not every failure becomes an incident. It depends on <strong>where</strong> the failure happens and <strong>how much</strong> it affects users or the business.</p><ul><li>A failure in a test environment is a <strong>finding</strong>. You log it, someone triages it, and it gets fixed.</li><li>A failure in production that blocks users, corrupts data, breaches an SLA, or creates a security risk is an <strong>incident</strong>. It gets a severity level, an owner, a response timeline, and often a war room.</li></ul><p>Teams typically declare an incident when:</p><ul><li>Users can’t complete a core journey such as login, checkout, payment, or booking</li><li>Data is lost, corrupted, or exposed</li><li>Performance drops below agreed thresholds</li><li>A downstream system, partner, or customer integration is affected</li><li>Error rates or monitoring alerts cross a defined threshold</li></ul><p><strong>A note on terminology:</strong> older ISTQB material used “incident” for any unexpected event during testing that needed investigation, and “incident report” was close to what we now call a bug report. Most of the industry now follows ITIL and SRE practice, where an incident means a problem affecting a live service. If you see the older usage in a certification syllabus or an old process document, that’s the reason.</p><p><strong>Why it matters to QA:</strong> Incidents are where software quality becomes visible to the business. Strong QA engineers read incident reports and postmortems, ask which test should have caught the problem, and close that gap so it doesn’t happen again.</p><h3>One problem, start to finish</h3><p>Here’s the full chain using one realistic example.</p><p><strong>The requirement:</strong> Orders of ₹1,000 or more get a 10% discount.</p><p><strong>Error:</strong> The developer reads it as “more than ₹1,000.” It’s a small misunderstanding, and nobody notices.</p><p><strong>Defect:</strong> The code says: if (total &gt; 1000) applyDiscount(0.10);</p><p>It should say: if (total &gt;= 1000) applyDiscount(0.10);</p><p>The flaw is now in the codebase and nobody has seen it yet.</p><p><strong>Failure:</strong> A customer places an order for exactly ₹1,000 and gets no discount. The system has behaved incorrectly at runtime.</p><p><strong>Incident:</strong> During a festive sale, the marketing team promotes a “₹1,000 combo” and it becomes the best-selling offer. Thousands of customers are charged full price. Support tickets spike, complaints spread on social media, and the business declares a Sev-2 incident. Engineering ships a hotfix and finance starts processing refunds.</p><p>One misread word ended up costing money and customer trust.</p><h3>Where QA could have stopped it</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7DjUyvkGiH6qLJRR.png" /></figure><p>Every stage gives you a chance to stop the problem, and each later stage costs more. Good QA tries to catch problems as close to the original error as possible.</p><h3>Common mistakes QA engineers make with these terms</h3><ul><li><strong>Treating every failed test as a product defect.</strong> Check the environment, the data, and the test script first.</li><li><strong>Assuming defects only exist in code.</strong> Some of the most expensive defects are in requirements.</li><li><strong>Calling every production issue an incident.</strong> A cosmetic issue in production is a defect that escaped. It isn’t automatically an incident unless it affects the service.</li><li><strong>Writing “root cause: code bug” in RCA.</strong> That describes the defect. The real root cause is the error and the process gap that allowed it.</li><li><strong>Arguing over labels during triage.</strong> Classify according to your team’s rules and spend the time on reproduction steps and impact.</li></ul><h3>How to use this in daily QA work</h3><p><strong>When writing a bug report:</strong> describe the failure you saw (expected vs actual), give the conditions that trigger it, and if you’ve isolated it, point to the likely defect location. Don’t guess at the error.</p><p><strong>When triaging a failed automation run:</strong> ask in order whether it’s the environment, the data, the test, or the product. Only the last one is a product defect.</p><p><strong>When contributing to an RCA or postmortem:</strong> follow the chain backwards from incident to failure to defect to error. Then ask at which stage a test, review, or monitor could have caught it, and add that safeguard.</p><p><strong>When reviewing requirements:</strong> remember that you’re looking for defects before they reach the code. Ambiguous words like “more than,” “up to,” “within,” and “approximately” are where boundary defects usually come from.</p><h3>Interview questions you should be ready for</h3><p><strong>1. What is the difference between an error, a defect, and a failure?</strong> An error is a human mistake. A defect is the flaw that mistake leaves in a work product. A failure is the incorrect behavior you observe when the defect is triggered at runtime.</p><p><strong>2. Are bug and defect the same?</strong> In standard terminology such as ISTQB, yes, they’re synonyms. Some organizations separate them by type or timing, for example bugs found before release and defects that escape to customers, so it’s worth following the convention your team uses.</p><p><strong>3. Can a defect exist without causing a failure?</strong> Yes. If the faulty code path never runs, or the triggering conditions never happen, the defect stays hidden. This is why test coverage and boundary testing matter.</p><p><strong>4. Can a failure happen without a defect in the product?</strong> Yes. Environment problems, network faults, bad test data, or misconfiguration can cause failures while the code is correct. A faulty test script can also produce a false failure.</p><p><strong>5. When does a failure become an incident?</strong> When it happens in a live service and affects users, data, SLAs, security, or business operations enough to need a managed response with severity, ownership, and resolution tracking.</p><p><strong>6. Can defects exist in documents, not just code?</strong> Yes. Requirements, designs, test cases, and configurations can all contain defects. Finding them through reviews is usually the cheapest way to prevent failures.</p><p><strong>7. Walk me through how a small mistake becomes a production incident.</strong> Use a boundary example like the ₹1,000 discount. Show each stage and explain which QA practice could have stopped it at each point. Interviewers usually value this answer more than a memorized definition.</p><p><strong>8. In RCA, why isn’t “code bug” an acceptable root cause?</strong> Because it only names the defect. A useful root cause identifies the error and the process gap behind it, such as an ambiguous requirement, a missing review, or no boundary tests, so the team can stop it from happening again.</p><h3>Final thought</h3><p>These five words describe the stages of a single problem. An <strong>error</strong> starts it, a <strong>defect</strong> carries it, a <strong>failure</strong> exposes it, and an <strong>incident</strong> is the point where users and the business feel it.</p><p>A QA engineer who understands this chain does more than find bugs. They know where a problem started, where it could have been caught, and what to change so it doesn’t happen again.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e847b46b39d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DevOps for QA Engineers: What Actually Changes for Testing? | DevOps Foundations # 1]]></title>
            <link>https://medium.com/@codinghoum/devops-foundations-1-devops-for-qa-engineers-what-actually-changes-for-testing-1e6ba8dcaa2e?source=rss-50da0710f1ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e6ba8dcaa2e</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[QASimplifiedByAkash]]></dc:creator>
            <pubDate>Sun, 25 Oct 2026 08:31:01 GMT</pubDate>
            <atom:updated>2026-10-26T07:53:40.424Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oTnERzgU8yObXmKf.png" /></figure><p><em>When code can reach users in hours, the “testing phase” has nowhere to live. Here is what takes its place.</em></p><p>A team finishes a story on Tuesday morning. The code is merged by noon. The pipeline builds it, deploys it to a test environment and then… waits.</p><p>It waits for QA. A tester picks it up on Wednesday, runs the regression checklist by hand and signs off on Thursday. It reaches production on Friday.</p><p>The team calls this DevOps. They have a pipeline, they have Jenkins and they deploy every week. But the story spent four days waiting for one manual step, and it will do the same next week.</p><p>They adopted the tools. They didn’t change how quality works.</p><h3>What DevOps is, without the buzzwords</h3><p>DevOps is a way of working where the people who build software and the people who run it share responsibility for getting it to users quickly and safely.</p><p>It started as a fix for an old problem. Developers wrote code and threw it over the wall to an operations team, who had to deploy and run it. Developers wanted to ship fast. Operations wanted stability. Each side blamed the other when things broke.</p><p>DevOps removes the wall. In practice, that usually means:</p><ul><li><strong>Shared ownership.</strong> The team that builds it also cares how it runs in production.</li><li><strong>Automation.</strong> Build, test and deploy steps run through a pipeline, not a manual checklist.</li><li><strong>Small, frequent releases.</strong> Many small changes are easier to test and roll back than one big release.</li><li><strong>Fast feedback.</strong> Monitoring and test results tell the team quickly when something is wrong.</li></ul><p>DevOps is not a job title, a tool or a team you hire. Jenkins, Docker and Kubernetes support it, but they aren’t DevOps themselves.</p><h3>DevOps vs Agile: what actually changed</h3><p>Agile fixed a planning problem. Instead of a year-long plan and a big-bang delivery, teams work in short sprints, get feedback and adapt.</p><p>But many Agile teams hit a wall. They built working software every two weeks, then waited weeks for it to be deployed, because release was still manual, risky and owned by someone else.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ND3bmYpsPz1oe-Ep.png" /></figure><p>They aren’t competitors. They solve different halves of the same problem.</p><p>For testing, the consequence is significant. In a sprint-based world, testing could sit in a “testing phase” near the end. When code can reach production in hours, that phase disappears. Testing has to happen continuously and automatically, inside the pipeline.</p><h3>What actually changes for testing</h3><p>This is the heart of it. Here are the shifts QA engineers feel most.</p><h3>1. From a gate to a safety net</h3><p>In older models, QA sat between development and release. Code arrived, QA tested it and a sign-off said whether it could go.</p><p>In DevOps, that single gate is replaced by quality checks at every stage. QA’s role moves from <em>being the gate</em> to <em>designing and strengthening the safety net</em>.</p><h3>2. From a phase to a continuous activity</h3><p>Quality work now happens along the whole path:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6soKpRkVyZdlA_eQ.png" /></figure><p>If a stage on that table is empty in your team, that’s where QA input is missing.</p><h3>3. From manual regression to fast, trusted automation</h3><p>When you release often, manual regression before every release stops scaling. If deployments double, so does the manual effort. Repetitive checks have to move into the pipeline.</p><p>But the pipeline only helps if its tests are <strong>fast, stable and trusted</strong>. A slow or flaky suite gets ignored, and people start re-running builds until they go green. That’s worse than having no gate at all.</p><h3>4. From finding defects to managing risk</h3><p>With small, frequent releases, the question changes. It’s less “have we found every bug?” and more “do we know what could go wrong, and could we recover quickly if it does?”</p><p>That brings in practices like:</p><ul><li><strong>Feature flags</strong>, so risky changes can be switched off without a redeploy</li><li><strong>Canary or gradual releases</strong>, so a new version reaches a small group first</li><li><strong>Rollback plans</strong>, so recovery is routine</li><li><strong>Monitoring and alerting</strong>, so problems are caught within minutes</li></ul><p>QA’s job extends to asking whether those safety measures exist and work.</p><h3>5. From owning testing to sharing it</h3><p>In a DevOps team, quality isn’t one person’s job. Developers write unit and component tests. QA and SDETs design strategy and automation. DevOps engineers keep environments and pipelines reliable. Everyone is accountable for quality, and QA helps the team do it well.</p><h3>DevOps engineer vs QA vs SDET: who owns what?</h3><p>These roles overlap, and the exact split differs between companies. A rough, commonly used version:</p><ul><li><strong>QA engineer:</strong> product quality and risk. Test strategy, test design, exploratory testing, defect analysis and acceptance from the user’s point of view.</li><li><strong>SDET:</strong> a developer-minded tester. Builds and maintains the automation framework, test tooling, test data utilities and CI integration for tests.</li><li><strong>DevOps engineer:</strong> the delivery platform. CI/CD pipelines, infrastructure, environments, deployment, monitoring and release reliability.</li></ul><p>The overlap is where things get fuzzy:</p><ul><li>The <strong>pipeline</strong> is built by DevOps, but the <strong>tests inside it</strong> are owned by QA and SDET.</li><li><strong>Environments</strong> are provisioned by DevOps, but <strong>test data</strong> and <strong>test readiness</strong> often need QA input.</li><li><strong>Flaky tests</strong> can come from test code, infrastructure or the application. Someone has to own the triage.</li></ul><p>The better question isn’t “whose job is it?” but “who is accountable, and who is consulted?” Unclear ownership is where failures hide, such as a broken pipeline stage that everyone assumes someone else is fixing.</p><p>In smaller teams, one person may wear two or three of these hats. That’s fine, as long as the responsibilities are explicit.</p><p><strong>A quick exercise:</strong> list three recurring problems, such as flaky tests, broken environments and slow builds. Write an owner next to each. Any problem without a name is a gap.</p><h3>Scenario: daily deployments, manual testing before release</h3><p>A team deploys daily, but a manual testing step sits before every release. Is that really continuous delivery?</p><p>First, what continuous delivery means: the software is <strong>always in a releasable state</strong>, and the path to production is <strong>automated and repeatable</strong>, so releasing is a routine business decision, not a risky event.</p><p>Questions to ask about the manual step:</p><ul><li><strong>How long does it take?</strong> If it takes most of the day, that’s the real limit on speed.</li><li><strong>Is it checking the same regression flows every time?</strong> If so, those are automation candidates.</li><li><strong>What happens when it finds something?</strong> If it blocks the release, it’s acting as a gate.</li><li><strong>Does it scale?</strong> If deployments double, does the testing time double too?</li></ul><p>My honest answer: <strong>it’s an early stage, not full continuous delivery.</strong> It’s frequent deployment, but the manual step is what the pipeline waits for.</p><p>Manual testing as such isn’t the problem. Exploratory testing, usability checks and new-feature investigation are valuable and don’t need to block every deploy. Manual <em>regression</em> is the part that doesn’t scale.</p><p>A practical path forward:</p><ol><li><strong>Automate the repetitive regression checks first</strong>, starting with the highest-risk flows.</li><li><strong>Run them in the pipeline</strong> on every change.</li><li><strong>Move manual testing into exploratory sessions</strong> on new or risky changes, running alongside the pipeline instead of in front of it.</li><li><strong>Use feature flags and monitoring</strong> so risk is also managed after release.</li></ol><p>To find your starting point, time the manual testing step for a week. If it’s the longest stage on the path to production, that’s your first automation target.</p><h3>How to tell whether your testing fits DevOps</h3><p>Some quick questions that give an honest read:</p><ul><li>Can a change go from commit to production <strong>without anyone doing manual regression</strong>?</li><li>Does the pipeline <strong>fail fast</strong>, with clear reasons?</li><li>Can the team <strong>trust a red build</strong>, or do they assume it’s flaky?</li><li>Is there a <strong>rollback or feature-flag</strong> option for risky changes?</li><li>Does anyone look at <strong>production monitoring</strong> as part of quality?</li><li>Is <strong>ownership of each pipeline stage</strong> clear?</li><li>Is exploratory testing still happening, <strong>in parallel</strong> instead of as a gate?</li></ul><p>If most answers are “no,” the team has adopted DevOps tooling more than DevOps practice.</p><h3>Skills that help a QA engineer in a DevOps team</h3><p>You don’t need to become a DevOps engineer. But these give you a real advantage:</p><ul><li><strong>CI/CD basics:</strong> reading a pipeline definition and knowing what runs at each stage</li><li><strong>Version control habits:</strong> branches, pull requests and reviewing test code</li><li><strong>Containers (Docker):</strong> running tests in consistent environments</li><li><strong>API testing:</strong> the layer pipelines can check quickly and reliably</li><li><strong>Reading logs and dashboards:</strong> finding the cause of a failure or an incident</li><li><strong>Test data and environment awareness:</strong> knowing what your tests depend on</li><li><strong>Risk-based thinking:</strong> deciding what must be checked on every change and what can wait</li></ul><h3>The takeaway</h3><p>DevOps doesn’t remove the need for testing. It removes the place where testing used to sit. When code reaches users in hours, quality can’t be a phase at the end. It has to be built into every stage of the path.</p><p>For QA engineers, that’s an opportunity. The role moves from checking at the end to designing the system that keeps quality visible all the time.</p><p>If you remember one line from this article, make it this:</p><blockquote><em>In DevOps, QA isn’t the gate at the end. QA is the safety net that runs the whole way.</em></blockquote><p><strong>Your turn:</strong> Does your team’s testing fit the pipeline, or does the pipeline wait for testing? What’s the biggest blocker? Reply or leave a comment. I’d like to hear it.</p><p><em>This is part of the </em><strong><em>DevOps Foundations</em></strong><em> series. Next: From Git Commit to Production: The Software Delivery Pipeline.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e6ba8dcaa2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>