<?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 Sunanda Jakeral on Medium]]></title>
        <description><![CDATA[Stories by Sunanda Jakeral on Medium]]></description>
        <link>https://medium.com/@jakeralbsunanda?source=rss-9cabf3ebfc91------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*LSPbxvY3VLCAwUYROZKU5g.jpeg</url>
            <title>Stories by Sunanda Jakeral on Medium</title>
            <link>https://medium.com/@jakeralbsunanda?source=rss-9cabf3ebfc91------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:55:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jakeralbsunanda/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[Is AI Making QA Engineers Lazy — Or More Powerful?]]></title>
            <link>https://medium.com/@jakeralbsunanda/is-ai-making-qa-engineers-lazy-or-more-powerful-ca230b75e5d6?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca230b75e5d6</guid>
            <category><![CDATA[qa-automation]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Mon, 30 Mar 2026 13:45:12 GMT</pubDate>
            <atom:updated>2026-03-30T13:45:12.338Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uUnhape_2dau78GlYDeXyg.png" /></figure><p>AI is rapidly changing how QA engineers work. From generating test cases to debugging failures, tools like ChatGPT and Copilot can do in seconds what used to take hours.</p><p>But this raises a key question:</p><p><strong>Is AI making QA engineers more powerful — or just more dependent?</strong></p><h3>The Convenience Problem</h3><p>AI makes things easy:</p><ul><li>Generate test cases instantly</li><li>Debug errors quickly</li><li>Write automation scripts faster</li></ul><p>But here’s the catch — <strong>easy can reduce thinking</strong>.</p><p>When you rely too much on AI:</p><ul><li>You accept outputs without questioning</li><li>You miss edge cases</li><li>You understand systems less deeply</li></ul><p>It’s like using GPS all the time — you reach faster, but lose your sense of direction.</p><h3>The Illusion of Productivity</h3><p>AI increases speed, but not always quality.</p><p>You might:</p><ul><li>Write more test cases</li><li>Ship faster</li></ul><p>But still miss:</p><ul><li>Real user scenarios</li><li>Business-critical bugs</li></ul><p>Because <strong>AI predicts — it doesn’t truly understand your system</strong>.</p><h3>Where AI Makes You Powerful</h3><p>AI becomes a superpower when used intentionally:</p><ul><li><strong>As a starting point, not the final answer</strong></li><li><strong>To explore faster, not think less</strong></li><li><strong>To debug smarter, not blindly fix</strong></li></ul><p>Strong QA engineers:</p><ul><li>Question AI outputs</li><li>Add domain knowledge</li><li>Focus on risk and impact</li></ul><h3>The Real Shift</h3><p>QA isn’t going away — it’s evolving.</p><p>Less valuable now:</p><ul><li>Repetitive test writing</li><li>Basic scripting</li></ul><p>More valuable:</p><ul><li>Critical thinking</li><li>System understanding</li><li>Test strategy</li><li>Asking the right questions</li></ul><h3>Lazy vs Powerful</h3><p>Same AI, different outcomes:</p><p><strong>Lazy use:</strong> Copy → Paste → Done<br><strong>Powerful use:</strong> Ask → Challenge → Improve</p><h3>Final Thought</h3><p>AI doesn’t make QA engineers lazy.</p><p><strong>It reveals who is — and empowers those who aren’t.</strong></p><p>The future belongs to engineers who don’t just use AI,<br>But <strong>think better because of it</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca230b75e5d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Give Useful Code Review Feedback]]></title>
            <link>https://medium.com/@jakeralbsunanda/how-to-give-useful-code-review-feedback-801b89984528?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/801b89984528</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Thu, 26 Feb 2026 11:22:39 GMT</pubDate>
            <atom:updated>2026-02-26T11:22:39.498Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cWMPUy25cZqU2__uW3SV2g.png" /></figure><p>Code reviews are not just about finding bugs — they’re about improving code quality, sharing knowledge, and helping teams grow. Giving useful feedback requires clarity, empathy, and focus.</p><p>First, <strong>be constructive, not critical</strong>. Instead of saying <em>“This is wrong,”</em> explain the issue and suggest improvements. For example, mention why a change improves performance, readability, or maintainability.</p><p>Second, <strong>focus on the code, not the person</strong>. Keep feedback objective and solution-oriented. Use neutral language like <em>“Consider refactoring this function to improve readability”</em> rather than sounding personal.</p><p>Third, <strong>prioritize meaningful issues</strong>. Highlight problems related to logic, security, performance, or design rather than minor style preferences (unless they violate standards). This helps developers focus on what truly matters.</p><p>Fourth, <strong>provide context and examples</strong>. Sharing alternative approaches, documentation links, or small code snippets makes feedback actionable and educational.</p><p>Finally, <strong>acknowledge good work</strong>. Recognizing well-written code builds trust and encourages collaboration.</p><p>Good code review feedback strengthens both the codebase and the team. When done thoughtfully, it becomes a powerful tool for continuous learning and better software development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=801b89984528" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ 10 Test Automation Hacks Every QA Should Know]]></title>
            <link>https://medium.com/@jakeralbsunanda/10-test-automation-hacks-every-qa-should-know-841f5b2a1005?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/841f5b2a1005</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[test-automation]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 06:16:37 GMT</pubDate>
            <atom:updated>2026-01-29T06:16:37.203Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(That Saves Time &amp; Sanity)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ddV2LfgjHzkmaMZVELxUUw.png" /></figure><p>Test automation is more than just writing scripts — it’s about creating tests that are reliable, maintainable, and valuable to the team. When done right, automation saves time, improves product quality, and reduces stress. When done wrong, it creates flaky tests and frustration.</p><p>Here are ten practical test automation hacks every QA professional should know to work smarter and stay sane.</p><h3>1. Automate What Matters Most</h3><p>Not every test case should be automated. Focus on high-impact scenarios such as regression tests, critical business flows, and stable features. Avoid automating areas that change frequently or require constant updates. Smart automation starts with choosing the right candidates.</p><h3>2. Use Stable and Meaningful Locators</h3><p>Unstable locators are the biggest cause of flaky tests. Always prefer dedicated attributes like data-testid or data-qa. Avoid relying on dynamic CSS classes or long XPath expressions. A strong locator strategy makes your automation reliable and easy to maintain.</p><h3>3. Keep Tests Small and Focused</h3><p>Each automated test should validate one clear behavior. Large end-to-end flows that test multiple features at once are difficult to debug and fragile. Smaller, focused tests make failures easier to understand and maintenance much simpler.</p><h3>4. Replace Hard Waits with Smart Waits</h3><p>Hard waits slow down tests and make them unreliable. Instead of using fixed delays, wait for specific conditions such as elements becoming visible or API calls completing. Let the automation framework handle retries intelligently rather than guessing timeouts.</p><h3>5. Reuse Code Through Utilities and Commands</h3><p>Avoid duplicating logic across test files. Common actions like login, data setup, and navigation should be extracted into reusable helpers or custom commands. This keeps tests clean and speeds up updates when application behavior changes.</p><h3>6. Make Every Test Independent</h3><p>Tests should not depend on the outcome of other tests. Each test must prepare its own data and environment. Independent tests are more reliable and can be executed in parallel, which significantly reduces execution time.</p><h3>7. Write Test Names Like Business Scenarios</h3><p>Well-written test names act as documentation. A good test name clearly explains what business behavior is being validated. This helps developers, testers, and product managers understand coverage without reading the code.</p><h3>8. Run Automation in CI Early and Often</h3><p>Automation provides real value only when it runs continuously. Integrate your tests into CI pipelines and execute them on every pull request or deployment. Early detection of failures saves time and prevents defects from reaching production.</p><h3>9. Debug with Evidence, Not Guesswork</h3><p>When a test fails, use logs, screenshots, videos, and API responses to understand the root cause. Avoid guessing. Structured debugging shortens investigation time and improves confidence in your automation results.</p><h3>10. Treat Automation as a Software Product</h3><p>Test automation needs the same care as production code. Apply code reviews, refactoring, documentation, and regular cleanup of obsolete tests. Well-maintained automation remains valuable over time, while neglected automation becomes technical debt.</p><h3>Conclusion</h3><p>Test automation is not just a technical skill — it is a mindset. By following these hacks, you can build automation that is stable, scalable, and meaningful. The goal is not to automate everything, but to automate intelligently so that testers can focus more on exploration, creativity, and quality improvement.</p><blockquote><strong>Good automation saves time. Great automation saves sanity.</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=841f5b2a1005" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quality Debt: The Silent Killer of Engineering Teams]]></title>
            <link>https://medium.com/@jakeralbsunanda/quality-debt-the-silent-killer-of-engineering-teams-28228d951f74?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/28228d951f74</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[product-quality]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Mon, 19 Jan 2026 11:18:58 GMT</pubDate>
            <atom:updated>2026-01-19T11:18:58.902Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3sPNhK4nlMx_aSthnPCaKA.png" /></figure><p>Quality debt is what happens when teams ship faster today by borrowing against tomorrow.</p><p>It doesn’t show up as a single bug or a failed release.<br>It hides in flaky tests, skipped reviews, unclear requirements, and “we’ll fix it later” decisions.</p><p>At first, everything seems fine. Velocity looks great. Releases are frequent.<br>But slowly, things start to break:</p><p>• Every change feels risky<br>• Bugs keep resurfacing<br>• Releases need more rollbacks than confidence<br>• Engineers spend more time firefighting than building<br>• Teams lose trust — in the code and in each other</p><p>Unlike technical debt, <strong>quality debt compounds quietly</strong>.<br>And by the time it’s visible, it’s already expensive.</p><p>The fix isn’t “<em>more testing</em>.”<br>It’s an <strong><em>intentional quality</em></strong>:</p><p><em>✔ Clear ownership of quality<br>✔ Tests that build trust, not noise<br>✔ Strong collaboration between QA, Dev, and Product<br>✔ Prioritizing stability as much as speed</em></p><p>High-performing teams don’t move fast <em>despite</em> quality.<br>They move fast <strong>because</strong> of it.</p><p><strong>Quality isn’t a safety net. <br>It’s the engine.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28228d951f74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Makes a Test Automation Framework Scale?]]></title>
            <link>https://medium.com/@jakeralbsunanda/what-makes-a-test-automation-framework-scale-193a071a2622?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/193a071a2622</guid>
            <category><![CDATA[testing-framework]]></category>
            <category><![CDATA[cypress]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[qa-automation]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Thu, 18 Dec 2025 13:23:19 GMT</pubDate>
            <atom:updated>2025-12-18T13:23:19.784Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CFmKVlxTiw47wY1rRv5SSA.png" /></figure><p><strong>A framework that works for 10 tests can collapse at 300.</strong></p><p><em>Most automation frameworks don’t fail because of tools.</em><br>They fail because they weren’t designed to grow. So what actually helps a framework scale?</p><h3>1️⃣ Clear Folder Structure</h3><p>A scalable framework reduces cognitive load.<br> Tests should be easy to read, easy to find, and easy to extend — even for someone new to the codebase.</p><h3>2️⃣ Reusable Utilities (With Intent)</h3><p>Copy-paste works early.<br> At scale, it becomes debt.<br> Well-designed utilities keep business logic in one place, making changes safer.</p><h3>3️⃣ A Solid Test Data Strategy</h3><p>Hard-coded data leads to flaky tests and CI failures.<br> Stable, isolated, and environment-aware test data keeps suites reliable as they grow.</p><h3>4️⃣ CI Performance as a First-Class Citizen</h3><p>If tests only work locally, the framework isn’t ready.<br> Parallel execution, predictable runtimes, and fast feedback are non-negotiable at scale.</p><h3>5️⃣ Reporting That Builds Trust</h3><p>Good reporting doesn’t just show failures — it explains them.<br> When results are clear, teams trust automation. When they aren’t, they ignore it.</p><h3>Final Thought</h3><p>Scaling test automation is less about <strong>adding more tests</strong><br>and more about <strong>reducing friction</strong> — for writing, running, and debugging tests.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=193a071a2622" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automation Framework Structure — The Right Way]]></title>
            <link>https://medium.com/@jakeralbsunanda/automation-framework-structure-the-right-way-0b5e0dc6278f?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b5e0dc6278f</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[automation-framework]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[qa-engineering]]></category>
            <category><![CDATA[cypress]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Mon, 24 Nov 2025 12:02:14 GMT</pubDate>
            <atom:updated>2025-11-24T12:02:14.860Z</atom:updated>
            <content:encoded><![CDATA[<h3>Automation Framework Structure — The Right Way</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ycLHZf_2aabBjWhOqUWRcg.png" /></figure><p>A strong automation framework isn’t defined by how many tests you write — it’s defined by how well your architecture supports scalability, stability, and maintainability. A clean structure helps teams onboard faster, debug quicker, and avoid flaky, tightly-coupled tests.</p><p>Here’s what a well-designed Cypress framework usually looks like:</p><p>📁 <strong>Folder Structure That Actually Works:</strong></p><pre>cypress/<br>│── fixtures/<br>│     ├── test-data.json<br>|     └── propertyResponse // for stubbing/mocking<br>│── e2e/<br>|     ├── login.cy.ts<br>|     ├── order.cy.ts<br>|     └── booking.cy.ts <br>│<br>└── support<br>       ├── utils/<br>       |     └── utils.ts<br>       |<br>       └── custom-commands/<br>            ├── order/<br>            |  ├── orderCommands.ts<br>            |  ├── locators.ts<br>            |  └── index.ts  <br>            |<br>            └── login/<br>                ├── loginCommands.ts<br>                ├── locators.ts<br>                └── index.ts</pre><h3>📌 Why This Structure Works</h3><h3>1️⃣ Fixtures — Keep Test Data Centralized</h3><p>All reusable test data stays in one folder.<br> No hard-coded values inside tests → cleaner, readable &amp; maintainable. Also, the mock responses can be placed here.</p><h3>2️⃣ e2e — Your Actual Test Specs</h3><p>Each test file focuses only on <strong>test logic</strong>, not selectors or long workflows.<br> Thanks to commands and utils, these files stay short and readable.</p><h3>3️⃣ Utils — Shared Helpers</h3><p>All helper functions (formatting, parsing, IDs, common ops) stay here.<br> This keeps tests clean and improves DRY (Don’t Repeat Yourself).</p><h3>4️⃣ Custom Commands — Your Reusable Workflows</h3><p>Each module has its own encapsulated command set, e.g.:</p><ul><li>loginCommands.ts</li><li>orderCommands.ts</li></ul><p>Plus dedicated locators.ts files for selectors.</p><p><em>This gives you:</em></p><p><em>✔ Cleaner test scripts<br> ✔ Centralized updates when UI changes<br> ✔ Reusable logic across specs<br> ✔ Better separation by feature/module</em></p><h3>🚀 Final Thought</h3><p>A great automation framework doesn’t happen by accident — it’s planned, structured, and evolved with intention.<br> When your architecture is solid, your tests naturally become stable and scalable.</p><p><strong>Good structure = less flakiness, faster development, and happier teams.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b5e0dc6278f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ QAOps — The Next Evolution in Continuous Quality]]></title>
            <link>https://medium.com/@jakeralbsunanda/qaops-the-next-evolution-in-continuous-quality-0da469505735?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/0da469505735</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[qaops]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[continuous-testing]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Mon, 13 Oct 2025 10:18:50 GMT</pubDate>
            <atom:updated>2025-10-13T10:18:50.863Z</atom:updated>
            <content:encoded><![CDATA[<h3>🧩 QAOps — The Next Evolution in Continuous Quality</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nD-gzeVTPPRStD-Y0BrxwA.png" /></figure><p>Software delivery has changed dramatically — and so has the role of QA. Gone are the days when testing happened only after development. With modern DevOps pipelines, testing must move just as fast. That’s where <strong>QAOps</strong> (or <strong>TestOps</strong>) comes in.</p><h3>🔹 What is QAOps?</h3><p>QAOps brings the <strong>DevOps mindset to quality assurance</strong>. It integrates testing, automation, infrastructure, and monitoring into a single continuous process. Instead of QA being a final checkpoint, it becomes an <strong>ongoing operational discipline</strong> that runs throughout the software lifecycle.</p><h3>🔹 Core Pillars of QAOps</h3><ol><li><strong>Continuous Testing</strong> — Every commit, build, or deployment triggers automated tests.</li><li><strong>Integration with CI/CD</strong> — QA pipelines plug directly into tools like Jenkins, GitHub Actions, or Bitbucket.</li><li><strong>Environment as Code</strong> — Test infrastructure and data are version-controlled for consistency.</li><li><strong>Observability &amp; Feedback</strong> — Production insights and logs help refine test coverage.</li><li><strong>Collaboration &amp; Visibility</strong> — QA, Dev, and Ops share dashboards, alerts, and metrics.</li></ol><h3>🔹 Why It Matters</h3><p>QAOps ensures <strong>faster feedback</strong>, <strong>fewer defects</strong>, and <strong>greater release confidence</strong>. Teams can detect issues earlier, measure quality continuously, and deliver updates without compromising reliability.</p><h3>🔹 The Bottom Line</h3><p>QAOps turns QA into a <strong>continuous, data-driven process</strong> that powers modern delivery pipelines. It’s not just testing faster — it’s testing smarter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0da469505735" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Shift-Left Is Good, But Don’t Forget Shift-Right: The Case for Continuous Quality]]></title>
            <link>https://medium.com/@jakeralbsunanda/shift-left-is-good-but-dont-forget-shift-right-the-case-for-continuous-quality-2940d826995c?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/2940d826995c</guid>
            <category><![CDATA[software-testing]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Mon, 06 Oct 2025 09:02:26 GMT</pubDate>
            <atom:updated>2025-10-06T09:04:40.950Z</atom:updated>
            <content:encoded><![CDATA[<h4>For years, QA has focused on <strong>Shift-Left</strong> — testing early, catching bugs before release, and integrating automation into every commit.<br>And yes, it works. 🚀</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2dghz7nnNp3kXGD8t_SE5A.png" /></figure><p>But here’s the truth — <em>no matter how early you test, real users will always surprise you.</em><br>That’s why <strong>Shift-Right</strong> matters as much.</p><p>Shift-Right means learning from production:<br> ✅ Real-user monitoring<br> ✅ Synthetic tests<br> ✅ Canary deployments<br> ✅ Observability &amp; performance insights</p><p>It’s about improving quality through real-world data — not just preventing failures, but <strong>learning from them</strong>.</p><p>When teams combine both sides, they reach <strong>Continuous Quality</strong> — a loop where testing, monitoring, and feedback never stop.</p><blockquote><em>Shift-Left prevents.<br>Shift-Right perfects.<br>Continuous Quality sustains. 💫</em></blockquote><p>QA is no longer just a gatekeeper — it’s a continuous learner, connecting development and operations to deliver smarter, more reliable releases.</p><p>#ShiftLeft #ShiftRight #ContinuousQuality #AutomationTesting #QALeadership #DevOps</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2940d826995c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Cypress and Test Data: Strategies That Saved Me Hours]]></title>
            <link>https://medium.com/@jakeralbsunanda/cypress-and-test-data-strategies-that-saved-me-hours-0c52dca9ee20?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c52dca9ee20</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[cypress-test-automation]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Mon, 06 Oct 2025 07:28:01 GMT</pubDate>
            <atom:updated>2025-10-06T07:28:01.249Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the trickiest parts of UI test automation isn’t writing the tests — it’s managing <strong>test data</strong>. Over the last few months, I’ve tried different strategies in Cypress, and a few of them have saved me countless hours (and reduced test flakiness).</p><h3>🔹 1. Dynamic Data with Faker.js</h3><p>Hard-coding values like email or phone numbers always caused collisions in my tests. Switching to @faker-js/faker helped generate fresh data on the fly (unique emails, random names, etc.), ensuring my tests never clashed with existing records.</p><h3>🔹 2. Reusable Fixtures + Custom Commands</h3><p>For repetitive flows (like creating a hotel, booking, or user), I combined <strong>fixtures</strong> with <strong>custom Cypress commands</strong>. This made the test setup consistent and avoided bloated test files.</p><h3>🔹 3. API Calls for Setup &amp; Teardown</h3><p>Instead of relying on the UI for creating test data, I started <strong>using backend APIs</strong> to set up and clean up data before the tests run. It cut execution time drastically and made tests more reliable.</p><h3>🔹 4. Environment-Specific Test Data</h3><p>Some data only exists in Sandbox vs Test environments. Using CYPRESS_ENV variables and cypress.config.tsI could load the right dataset dynamically instead of duplicating tests.</p><h3>🔹 5. Idempotent Data Creation</h3><p>Making test data idempotent (check if record exists → reuse; else create new) saved a lot of rerun headaches, especially in parallel CI runs.</p><p>✅ <strong>Key takeaway:</strong> Treat test data as a <strong>first-class citizen</strong> in your automation strategy. A few smart patterns can save hours of debugging and give you stable, repeatable tests</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c52dca9ee20" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unlocking Cross-Origin Testing with Cypress cy.origin()]]></title>
            <link>https://medium.com/@jakeralbsunanda/unlocking-cross-origin-testing-with-cypress-cy-origin-6e99f9571133?source=rss-9cabf3ebfc91------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e99f9571133</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[cypress]]></category>
            <category><![CDATA[cypress-testing]]></category>
            <category><![CDATA[test-automation-framework]]></category>
            <category><![CDATA[test-automation]]></category>
            <dc:creator><![CDATA[Sunanda Jakeral]]></dc:creator>
            <pubDate>Fri, 26 Sep 2025 07:18:13 GMT</pubDate>
            <atom:updated>2025-09-26T10:11:11.248Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rYlmktEo5sMdWvCyDNT5WQ.png" /></figure><p>Web applications today rarely live on a single domain. From authentication redirects (Google SSO, Okta) to third-party widgets (such as payments, bookings, and embedded tools), cross-origin workflows are ubiquitous. Historically, Cypress limited automation to a single origin, making it hard to cover these scenarios.</p><p>That changed with <strong>cy.origin()</strong>, a Cypress feature introduced in v9.6.0 that allows you to test across multiple domains <em>safely and predictably</em>.</p><p>Why Do We Need <strong>cy.origin()</strong>?</p><p>Imagine a booking application where:</p><ul><li>The user browses properties on <strong>myapp.com</strong></li><li>On checkout, they are redirected to <strong>secure.payments.com</strong></li><li>After successful payment, they are redirected back to <strong>myapp.com/confirmation</strong></li></ul><p>Previously, Cypress would block you from automating steps on secure.payments.com because of same-origin restrictions. Withcy.origin()You can now declare controlled execution blocks that run in the context of that second domain.</p><h4><strong>Syntax Basics</strong></h4><pre>cy.origin(&#39;https://secure.payments.com&#39;, () =&gt; {<br>  // Commands inside here run as if we are visiting secure.payments.com<br>  cy.get(&#39;#card-number&#39;).type(&#39;1111111111111111&#39;);<br>  cy.get(&#39;#expiry-date&#39;).type(&#39;12/30&#39;);<br>  cy.get(&#39;#pay-now&#39;).click();<br>});</pre><ul><li>The first argument is the target origin (protocol://host:port).</li><li>The callback contains Cypress commands specific to that domain.</li><li>Cypress automatically handles switching contexts back and forth.</li></ul><h3>A Practical Example: Embedded Payment Gateway (Stripe Checkout)</h3><p>Many e-commerce apps don’t handle payments directly but redirect users to a <strong>hosted checkout page</strong> (like Stripe) on a separate domain. Withcy.origin(), you can finally automate this.</p><pre>describe(&#39;Cross-Origin Checkout Flow&#39;, () =&gt; {<br>  it(&#39;completes a purchase via Stripe Checkout&#39;, () =&gt; {<br>    // Step 1: Add product to cart on main domain<br>    cy.visit(&#39;https://shopmyapp.com&#39;);<br>    cy.get(&#39;[data-testid=&quot;add-to-cart&quot;]&#39;).click();<br>    cy.get(&#39;[data-testid=&quot;checkout&quot;]&#39;).click();<br><br>    // Step 2: Switch to Stripe domain<br>    cy.origin(&#39;https://checkout.stripe.com&#39;, () =&gt; {<br>      cy.url().should(&#39;include&#39;, &#39;checkout.stripe.com&#39;);<br><br>      cy.get(&#39;input[name=&quot;cardnumber&quot;]&#39;).type(&#39;4242414242414240&#39;);<br>      cy.get(&#39;input[name=&quot;exp-date&quot;]&#39;).type(&#39;12/30&#39;);<br>      cy.get(&#39;input[name=&quot;cvc&quot;]&#39;).type(&#39;123&#39;);<br>      cy.contains(&#39;Pay&#39;).click();<br>    });<br><br>    // Step 3: Confirm success back on app<br>    cy.url().should(&#39;include&#39;, &#39;/order/confirmation&#39;);<br>    cy.contains(&#39;Thank you for your purchase!&#39;).should(&#39;be.visible&#39;);<br>  });<br>});</pre><h3>Why this example stands out</h3><ul><li><strong>Widely used</strong> → Stripe, Razorpay, Adyen, PayPal… almost every online store uses a 3rd-party gateway.</li><li><strong>Clear cross-origin switch</strong> → App → Stripe → back to App.</li><li><strong>Critical test</strong> → Payment is the lifeline of any business. Automating this builds huge confidence.</li><li><strong>Safe Isolation:</strong> Each cy.origin() block runs in a sandboxed context to respect browser security.</li><li><strong>Arguments Passing:</strong> You can pass variables into the origin block usingargs, making tests more dynamic.</li><li><strong>Improved Coverage:</strong> End-to-end tests now truly cover full user journeys, including SSO, payments, and embedded content.</li></ul><h3>Best Practices</h3><ol><li><strong>Group logically</strong> — Keep each cy.origin() block small and focused.</li><li><strong>Validate redirects</strong> — Always assert cy.url() when switching origins.</li><li><strong>Share data carefully</strong> — Pass only what you need via the args option.</li><li><strong>Avoid overuse</strong> — Only use cy.origin() when multi-domain is unavoidable. For single-domain interactions, use standard Cypress commands.</li></ol><h3>Final Thoughts</h3><p>Cross-origin flows are part of modern web reality. With cy.origin(), Cypress bridges that gap and makes it possible to write <strong>realistic, end-to-end automation</strong> that mirrors your users’ actual journeys.</p><p>If you’ve been skipping payment tests, OAuth logins, or external widgets because of Cypress restrictions, it’s time to revisit them. Your automation suite just got a lot more powerful.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e99f9571133" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>