<?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 Dasun Sooriyabandara on Medium]]></title>
        <description><![CDATA[Stories by Dasun Sooriyabandara on Medium]]></description>
        <link>https://medium.com/@dasunsooriyabandara?source=rss-61bc2d350b9a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*-cGxycG99nIyQwAy</url>
            <title>Stories by Dasun Sooriyabandara on Medium</title>
            <link>https://medium.com/@dasunsooriyabandara?source=rss-61bc2d350b9a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 07:38:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dasunsooriyabandara/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[ Why Finding a Bug Isn’t Enough: The Art of Writing a Good Bug Report]]></title>
            <link>https://medium.com/@dasunsooriyabandara/why-finding-a-bug-isnt-enough-the-art-of-writing-a-good-bug-report-a40579ad2dd9?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a40579ad2dd9</guid>
            <category><![CDATA[market-research-reports]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[bugs]]></category>
            <category><![CDATA[bug-report]]></category>
            <category><![CDATA[bug-bounty-tips]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Thu, 30 Jul 2026 17:25:23 GMT</pubDate>
            <atom:updated>2026-07-30T17:25:23.516Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/738/0*ErrrkBGuTtetla0K" /></figure><p>Every QA engineer celebrates finding a bug. But here&#39;s the truth:</p><p><strong>Finding a bug is only half the job.</strong></p><p>If developers can&#39;t understand, reproduce, or fix it, then that bug report has very little value.</p><p>A well-written bug report can save hours of investigation, reduce back-and-forth communication, and help teams deliver fixes faster.</p><h3>🎯 Why Bug Reporting Matters</h3><p>Imagine receiving a bug report that simply says:</p><blockquote><em>&quot;Login doesn&#39;t work.&quot;</em></blockquote><p>As a developer, the first questions would be:</p><ul><li>Which environment?</li><li>Which browser?</li><li>What credentials?</li><li>What exactly happened?</li><li>Can you reproduce it?</li><li>Was there an error message?</li></ul><p>Now compare that with a report that provides all the necessary details. The difference is huge.</p><p>Good bug reports don&#39;t just report problems—they help solve them.</p><h3>📝 What Makes a Great Bug Report?</h3><p>A good bug report should answer the following questions:</p><ul><li><strong>What is the issue?</strong></li><li><strong>Where did it happen?</strong></li><li><strong>How can it be reproduced?</strong></li><li><strong>What was expected?</strong></li><li><strong>What actually happened?</strong></li><li><strong>How serious is the issue?</strong></li><li><strong>Can you provide screenshots, logs, or videos?</strong></li></ul><p>The clearer your report, the faster the issue gets fixed.</p><h3>📌 Essential Elements of a Bug Report</h3><ul><li><strong>Bug ID</strong></li><li><strong>Summary</strong></li><li><strong>Environment</strong></li><li><strong>Steps to Reproduce</strong></li><li><strong>Expected Result</strong></li><li><strong>Actual Result</strong></li><li><strong>Severity</strong></li><li><strong>Priority</strong></li><li><strong>Attachments (Screenshots/Videos/Logs)</strong></li></ul><p>These details eliminate guesswork and improve communication between QA and developers.</p><h3>🚫 Common Mistakes QA Engineers Make</h3><p>❌ Writing vague titles</p><p>❌ Missing reproduction steps</p><p>❌ Not attaching evidence</p><p>❌ Confusing severity with priority</p><p>❌ Reporting multiple issues in one ticket</p><p>❌ Assuming developers already know the context</p><h3>💡 A Good Bug Report Saves Everyone Time</h3><p>A developer shouldn&#39;t spend an hour trying to understand a five-minute bug.</p><p>Likewise, QA shouldn&#39;t have to answer multiple follow-up questions because important details were left out.</p><p>The goal is simple:</p><p><strong>One report. One clear problem. Everything needed to reproduce it.</strong></p><h3>🤝 Bug Reporting Is Teamwork</h3><p>A bug report isn&#39;t about proving someone wrote bad code.</p><p>It&#39;s about helping the team improve the product.</p><p>The best QA engineers don&#39;t write bug reports to criticize developers—they write them to make fixes easier.</p><h3>🎯 Final Thoughts</h3><p>Anyone can identify a bug.</p><p>A great QA engineer knows how to communicate it effectively.</p><p>Clear bug reports lead to:</p><ul><li>Faster fixes</li><li>Better collaboration</li><li>Less confusion</li><li>Higher-quality software</li></ul><p>Remember:</p><blockquote><strong><em>A bug isn&#39;t truly valuable until someone can reproduce and fix it.</em></strong></blockquote><p>That&#39;s the real power of a well-written bug report.</p><p>#SoftwareTesting #QualityAssurance #BugReporting #QA #Testing #Agile #AutomationTesting #SoftwareQuality #TestEngineer #Tech</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a40579ad2dd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Lead-Level Roles Need Strong Soft Skills]]></title>
            <link>https://medium.com/@dasunsooriyabandara/why-lead-level-roles-need-strong-soft-skills-6dfd97ef60f9?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6dfd97ef60f9</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[soft-skills]]></category>
            <category><![CDATA[leadership-skills]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Mon, 15 Dec 2025 17:29:14 GMT</pubDate>
            <atom:updated>2025-12-15T17:34:39.225Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>As professionals move into lead-level positions, technical expertise alone is no longer enough. While technical skills help someone become a strong individual contributor, <strong>soft skills are what make a great leader</strong>.</blockquote><p>At the lead level, success depends less on <em>what you do yourself</em> and more on <em>how well you guide others</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zt3wQhFByQk4OsqDrex5uA.jpeg" /></figure><h3>What Are Soft Skills?</h3><p>Soft skills are interpersonal and behavioral skills that help leaders work effectively with people. These include:</p><ul><li>Communication</li><li>Emotional intelligence</li><li>Empathy</li><li>Conflict management</li><li>Decision-making</li><li>Adaptability</li><li>Coaching and mentoring</li></ul><h3>Why Soft Skills Are Critical at the Lead Level</h3><p>1️⃣ Leaders Work Through People</p><p>Leads are responsible for team outcomes, not just individual tasks. Strong soft skills help leaders motivate, guide, and support their teams to perform at their best.</p><p>2️⃣ Clear Communication Prevents Confusion</p><p>Leads must translate business goals into clear, actionable tasks. Poor communication causes misunderstandings, delays, and rework.</p><p>3️⃣ Soft Skills Build Trust and Respect</p><p>Trust is the foundation of leadership. Empathy, honesty, and active listening help leaders build strong relationships and psychological safety within teams.</p><p>4️⃣ Conflict Is Inevitable — Handling It Matters</p><p>Disagreements happen in every team. Leaders with good soft skills resolve conflicts calmly and fairly without damaging morale or productivity.</p><p>5️⃣ Better Decision-Making Under Pressure</p><p>Lead roles often involve making tough decisions with limited information. Emotional intelligence and critical thinking help leaders stay calm and choose wisely.</p><p>6️⃣ Coaching and Growth of Team Members</p><p>A strong lead focuses on growing others, not controlling them. Soft skills enable effective feedback, mentoring, and career guidance.</p><p>7️⃣ Managing Change Effectively</p><p>Projects, tools, and priorities change constantly. Leaders with adaptability and empathy help teams navigate change with confidence.</p><p>8️⃣ Prevents Micromanagement</p><p>Leaders with strong soft skills trust their teams, delegate effectively, and focus on outcomes instead of controlling every detail.</p><h3>What Happens Without Soft Skills?</h3><p>When lead-level professionals lack soft skills:</p><ul><li>Teams feel misunderstood or undervalued</li><li>Communication breaks down</li><li>Conflicts escalate</li><li>Motivation drops</li><li>High performers leave</li></ul><p>Strong technical skills can’t compensate for weak leadership behavior.</p><h3>Final Thoughts</h3><p>Technical skills may get you promoted to a lead role, but <strong>soft skills help you succeed in it</strong>.</p><p>Great leaders inspire, communicate, and empower.<br> They don’t just manage work — they manage people.</p><p>In today’s workplaces, <strong>soft skills are not optional for leaders — they are essential</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6dfd97ef60f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Error Guessing — A Practical Test Design Technique]]></title>
            <link>https://medium.com/@dasunsooriyabandara/error-guessing-a-practical-test-design-technique-cd893c2e7dd3?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd893c2e7dd3</guid>
            <category><![CDATA[experience-based-testing]]></category>
            <category><![CDATA[istqb]]></category>
            <category><![CDATA[error-guessing]]></category>
            <category><![CDATA[istqb-sinhala]]></category>
            <category><![CDATA[sinhala-testing]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Mon, 15 Dec 2025 17:17:58 GMT</pubDate>
            <atom:updated>2025-12-15T17:17:58.719Z</atom:updated>
            <content:encoded><![CDATA[<h3>Error Guessing — A Practical Test Design Technique</h3><p><strong>Error guessing</strong> is an experience-based test technique where testers anticipate possible <strong>errors, defects, and failures</strong> in a system based on their knowledge and experience.</p><p>Instead of relying only on formal test cases, testers use their intuition and understanding of how systems usually fail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z-o4ye4nVY40E349t-MHOg.jpeg" /></figure><h3>What Does Error Guessing Rely On?</h3><p>Error guessing is based on the tester’s knowledge of:</p><ul><li>How the application behaved in the past</li><li>Common mistakes developers tend to make</li><li>Defects found in similar or previous applications</li><li>Historical defect data</li><li>Real-world usage patterns</li></ul><p>This makes it especially effective when documentation is limited or time is constrained.</p><h3>Common Areas Where Errors Occur</h3><p>In general, errors, defects, and failures often relate to the following areas:</p><h3>1️⃣ Input Errors</h3><ul><li>Valid input not accepted</li><li>Invalid input accepted</li><li>Missing or incorrect parameters</li></ul><h3>2️⃣ Output Errors</h3><ul><li>Wrong format</li><li>Incorrect values</li><li>Missing or incomplete output</li></ul><h3>3️⃣ Logic Errors</h3><ul><li>Missing conditions</li><li>Incorrect operators</li><li>Wrong business rules</li></ul><h3>4️⃣ Computation Errors</h3><ul><li>Incorrect calculations</li><li>Wrong operands</li><li>Rounding or precision issues</li></ul><h3>5️⃣ Interface Errors</h3><ul><li>Parameter mismatches</li><li>Incompatible data types</li><li>Incorrect API contracts</li></ul><h3>6️⃣ Data Errors</h3><ul><li>Incorrect initialization</li><li>Wrong data type</li><li>Data not saved or retrieved correctly</li></ul><h3>Fault Attacks — A Structured Way to Apply Error Guessing</h3><p><strong>Fault attacks</strong> are a practical way to implement error guessing.</p><p>In fault attacks, the tester:</p><ul><li>Creates or collects a list of possible errors, defects, and failures</li><li>Designs test cases specifically to expose those issues</li><li>Uses past experience, defect reports, and common failure patterns</li></ul><p>These lists can be built from:</p><ul><li>Previous project experience</li><li>Defect and failure data</li><li>Industry knowledge about common software failures</li></ul><h3>Why Error Guessing Is Important</h3><ul><li>Finds defects formal techniques may miss</li><li>Works well when requirements are unclear</li><li>Highly effective in exploratory testing</li><li>Improves test coverage with minimal effort</li><li>Leverages tester expertise</li></ul><h3>Final Thoughts</h3><p>Error guessing is not random testing — it is <strong>smart, experience-driven testing</strong>.<br> When combined with structured techniques, it significantly improves defect detection and overall software quality.</p><p>As experience grows, a tester’s ability to guess errors becomes one of their most valuable skills.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd893c2e7dd3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why UI/UX Testing Matters]]></title>
            <link>https://medium.com/@dasunsooriyabandara/why-ui-ux-testing-matters-d8d8603a32ba?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8d8603a32ba</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[istqb]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Fri, 21 Nov 2025 16:22:17 GMT</pubDate>
            <atom:updated>2025-11-21T16:22:17.206Z</atom:updated>
            <content:encoded><![CDATA[<p>In today’s digital world, users expect apps to be <strong>simple, beautiful, and frustration-free</strong>. They don’t separate UI and UX — they just experience the product. That’s why <strong>UI/UX Testing</strong> plays a crucial role in delivering products people love using.</p><p>To understand this better, take a look at the image below. It perfectly shows the difference between <strong>UX (User Experience)</strong> and <strong>UI (User Interface)</strong> and how both work together:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*DOKHBD7uVMcZRm41" /></figure><p><strong>UX = User Research, Wireframes, Information Architecture, Prototype</strong><br> <strong>UI = Visual Design, Colors, Layouts, Typography</strong></p><p>Your uploaded graphic clearly highlights how each part contributes to the final product. UI shapes how things <em>look</em>. UX shapes how things <em>feel and flow</em>. UI/UX Testing ensures both sides are polished and user-friendly.</p><h4>1️⃣ First Impressions Matter</h4><p>Users judge your application within seconds. A messy layout, confusing buttons, or inconsistent colors can instantly drive them away.<br> UI/UX testing ensures the design is clean, modern, and aligned with user expectations.</p><h4>2️⃣ Ensures Smooth and Intuitive User Journeys</h4><p>If users struggle to complete simple tasks — like placing an order, updating a profile, or finding a feature — they won’t come back.<br> UX testing checks:</p><ul><li>Navigation flow</li><li>Button behavior</li><li>Page transitions</li><li>Input validations</li><li>Accessibility</li></ul><p>This guarantees that every action feels natural and effortless.</p><h4>3️⃣ Reduces Support Tickets and Rework</h4><p>Most customer complaints come from confusing interfaces, not technical bugs.<br> By catching UI/UX issues early, teams avoid costly redesigns and reduce the load on customer support.</p><h4>4️⃣ Improves User Satisfaction &amp; Retention</h4><p>A pleasant experience keeps users engaged.<br> Good UI/UX directly improves:</p><ul><li>Conversion rates</li><li>Task completion time</li><li>Customer happiness</li><li>Long-term loyalty</li></ul><p>Happy users return. Confused users leave.</p><h4>5️⃣ Enhances Brand Image</h4><p>Your product’s UI/UX reflects your company’s professionalism.<br> A polished interface builds trust; a poor one damages credibility instantly.</p><h4>6️⃣ Ensures Accessibility for All Users</h4><p>UI/UX testing ensures your app is inclusive by checking:</p><ul><li>Font visibility</li><li>Color contrast</li><li>Screen-reader compatibility</li><li>Keyboard navigation</li></ul><p>This opens your product to a wider audience and meets global accessibility standards.</p><h4>7️⃣ Supports Better Business Decisions</h4><p>Insights from UI/UX testing reveal how users think, behave, and interact.<br> This helps:</p><ul><li>Prioritize features</li><li>Improve design</li><li>Optimize workflows</li><li>Reduce friction points</li></ul><h3>Final Thoughts</h3><p>UI/UX testing isn’t just about making things “look nice.”<br> It’s about:<br> ✔ Improving usability<br> ✔ Increasing engagement<br> ✔ Reducing frustration<br> ✔Building trust<br> ✔Strengthening your brand</p><p>Simply put<br> <strong>Good UI attracts users.<br> Great UX keeps them.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8d8603a32ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Advantages of Early as Well as Regular Feedback in QA]]></title>
            <link>https://medium.com/@dasunsooriyabandara/the-advantages-of-early-as-well-as-regular-feedback-in-qa-e88fee9d6329?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e88fee9d6329</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[customer-feedback]]></category>
            <category><![CDATA[early-retirement]]></category>
            <category><![CDATA[feedback]]></category>
            <category><![CDATA[collaboration]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Mon, 29 Sep 2025 16:33:27 GMT</pubDate>
            <atom:updated>2025-09-29T16:33:27.289Z</atom:updated>
            <content:encoded><![CDATA[<p>In building software, perhaps the strongest technique to product build faster, faster is early, frequent feedback. It’s not just “nice to have” as the practice is a game-changer as part of the role of the Quality Assurance (QA) department.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Hc-ZeQCf0UR8EJiN9M3SA.png" /></figure><p><strong>Why Early Feedback Is Important</strong></p><p>Catching problems early keeps them cheaper &amp; easier to fix. That bug spotted during the design or build phase may take minutes to resolve. That same bug spotted during production? Hours, days, or even weeks — and disgruntled users.</p><p><strong>Early feedback to QA teams guarantees:</strong></p><ul><li><strong>Smpler requirements:</strong> Testers know what they’re getting before code is even produced.</li><li><strong>Better collaboration:</strong> QA, developers, and product owners align up front.</li><li><strong>Less rework:</strong> Problems are identified before they blow up into something considerably larger.</li></ul><p><strong>The Power of Regular Feedback</strong></p><p>Progress shouldn’t be provided once, after the project — that progress has to be continuous. Regular feedback loops keep quality front and center during development.</p><p><strong>Benefits include:</strong></p><ul><li><strong>Continuous Improvement: </strong>Teams become wiser after each iteration and improve continuously.</li><li><strong>Quicker Releases:</strong> Prompt release of feedback decreases wait time as it comes quickly.</li><li><strong>Confidence in Changes:</strong> Frequent releases engender trust that modifications won’t disable current functionality.</li><li><strong>Happier Teams:</strong> Nobody experiences progress exclusion, and no last-minute fire drills.</li></ul><p><strong>Real-World Example</strong></p><p>Imagine working on a banking app. If QA only tests after the final build, they might find issues with login, payments, or security very late — causing delays and costly fixes.</p><p><strong>But if QA provides input during the design debate, sprint review, and each little build:</strong></p><ul><li>Login problems are identified before the live go-to</li><li>Payment flows are verified step-wise</li><li>Security screenings occur regularly and early</li></ul><p><strong>The pay-off? Fewer surprises, increased confidence, and smoother releases.</strong></p><p><strong><em>Final Thoughts</em></strong></p><p>Early and frequent feedback during QA, as follows:</p><p>✔️ <strong>Improved collaboration</strong></p><p>✔️ <strong>Bug debugging faster</strong></p><p>✔️ <strong>Better product quality</strong></p><p>✔️ <strong>Less stress for the entire team</strong></p><p>Quality is not something that gets bolted on afterwards — it’s crafted line by line, line after line, with ongoing feedback as the guide.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e88fee9d6329" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Mastering Exploratory Testing: The Human-Centered Approach to QA]]></title>
            <link>https://medium.com/@dasunsooriyabandara/mastering-exploratory-testing-the-human-centered-approach-to-qa-147097c1337a?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/147097c1337a</guid>
            <category><![CDATA[bookingcom]]></category>
            <category><![CDATA[no-test-plan-testing]]></category>
            <category><![CDATA[experience-based-testing]]></category>
            <category><![CDATA[exploratory-testing]]></category>
            <category><![CDATA[qa-testing]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Thu, 26 Jun 2025 15:18:04 GMT</pubDate>
            <atom:updated>2025-06-27T14:55:24.361Z</atom:updated>
            <content:encoded><![CDATA[<p>In today’s fast-moving Agile world, where requirements evolve and releases are frequent, <strong>exploratory testing</strong> has become an essential skill for any Quality Assurance professional. Unlike scripted testing, exploratory testing is a hands-on, human-centric approach to discovering issues that often go unnoticed with automated or predefined tests.</p><p>In this article, we’ll explore:</p><ul><li>What is exploratory testing?</li><li>Why is it valuable?</li><li>How to approach it effectively?</li><li><strong>MOST IMPORTANT</strong> — Real-world video examples on popular platforms</li></ul><figure><img alt="https://youtu.be/gF-D0C-_23w?si=4Od80j4I4nYDJEFk" src="https://cdn-images-1.medium.com/max/1024/1*1NlTMNM8BS_Ic-lPtqeFfw.jpeg" /><figcaption><a href="https://youtu.be/gF-D0C-_23w?si=4Od80j4I4nYDJEFk">https://youtu.be/gF-D0C-_23w?si=4Od80j4I4nYDJEFk</a></figcaption></figure><h3>🧠 What is Exploratory Testing?</h3><p><strong>Exploratory testing</strong> is an informal but structured testing approach where the tester actively explores the application to learn, design, and execute tests at the same time. It emphasizes <strong>creativity</strong>, <strong>critical thinking</strong>, and <strong>domain knowledge</strong> over strict test scripts.</p><p>As defined by <strong>Cem Kaner</strong>, one of the pioneers of exploratory testing:</p><blockquote><em>“Exploratory testing is simultaneous learning, test design, and test execution.”</em></blockquote><h3>🎯 Why Exploratory Testing Matters</h3><p>Here’s why exploratory testing is an essential part of a balanced QA strategy:</p><ul><li>✅ <strong>Finds hidden defects</strong> missed by automation</li><li>✅ <strong>Reveals usability issues</strong> and confusing UI/UX flows</li><li>✅ <strong>Adaptable</strong> to rapid changes in the application</li><li>✅ Encourages <strong>deep product understanding</strong></li><li>✅ Allows testers to use <strong>intuition and creativity</strong></li></ul><p>It’s especially powerful during:</p><ul><li>Smoke testing newly released features</li><li>Regression testing high-risk areas</li><li>User acceptance testing (UAT) simulations</li><li>Testing during tight deadlines or incomplete specs</li></ul><h3>🛠️ How to Do Exploratory Testing Effectively</h3><p>Although exploratory testing is unscripted, it still benefits from a structured approach. Here are some useful steps:</p><h4>1. Set a Charter</h4><p>Define the goal or focus area of your session.</p><blockquote>Example:<em> “Explore the checkout flow on mobile to find validation issues.”</em></blockquote><h4>2. Timebox Your Session</h4><p>Keep focus with 30–60 minute sessions, also known as <strong>Session-Based Testing</strong>.</p><h4>3. Take Notes or Use a Mind Map</h4><p>Document what you tested, what you observed, and what bugs or ideas came up.</p><h4>4. Use Personas</h4><p>Test from the perspective of real users. For example: a first-time buyer, a returning user, or a senior citizen.</p><h4>5. Log Defects Immediately</h4><p>File bugs while the context is fresh, or capture recordings/screenshots for review.</p><h3>📹 Real Exploratory Testing Examples</h3><p>To better understand how exploratory testing works in practice, here are video demonstrations of exploratory sessions on popular web applications:</p><ul><li><strong>Booking.com — Hotel Search and Booking Flow</strong><br> ▶️ Part 1 — <a href="https://youtu.be/gF-D0C-_23w?si=53QLKnbc0zASQLmj">https://youtu.be/gF-D0C-_23w?si=53QLKnbc0zASQLmj</a><br> ▶️ Part 2— <a href="https://youtu.be/GAZhnJ7yE8w?si=22tjNRlSLF7qpcbZ">https://youtu.be/GAZhnJ7yE8w?si=22tjNRlSLF7qpcbZ</a></li><li><strong>Dialog.lk — Mobile Top-up and Bill Payment</strong><br> ▶️ Part 1— <a href="https://youtu.be/W_5sVjbAwas?si=I9lA4DPYbExXLybF">https://youtu.be/W_5sVjbAwas?si=I9lA4DPYbExXLybF</a><br> ▶️ Part 2— <a href="https://youtu.be/GzB4b2nhs5w?si=26Ze5tWxk-8m0ufi">https://youtu.be/GzB4b2nhs5w?si=26Ze5tWxk-8m0ufi</a></li><li><strong>Cargills Bank — Online Banking Login &amp; Transfers</strong><br> ▶️</li></ul><blockquote><em>These real-world sessions show how testers think on their feet, navigate unexpected behavior, and uncover real usability or functional issues.</em></blockquote><h3>🔍 Exploratory Testing vs. Scripted Testing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MEvnxnoyWJP9EjbBzL6bGA.png" /></figure><h3>💡 Tips for Success</h3><ul><li>Pair with a developer or product owner for deeper insights.</li><li>Use browser dev tools to observe network requests or errors.</li><li>Record your session for future learning or bug reporting.</li><li>Practice with real-world apps to sharpen your intuition.</li></ul><h3>✅ Conclusion</h3><p>Exploratory testing isn’t a replacement for scripted or automated testing — it’s a powerful complement. By adding human insight, creativity, and adaptability, exploratory testing helps QA teams catch critical issues that tools can’t detect.</p><p>Whether you’re a beginner or an experienced tester, practicing exploratory testing regularly will help you develop sharper instincts, stronger domain knowledge, and a deeper understanding of the product you’re testing.</p><h3>📍 Your Turn</h3><p>Watch the real exploratory testing videos above and try running your own sessions on similar platforms. Pick a scenario, define a goal, timebox your session, and see what you discover!</p><p>Need help creating your first exploratory test charter or report?</p><p>Just visit my channel! — <a href="https://www.youtube.com/@ISTQB_Guide_SInhala">https://www.youtube.com/@ISTQB_Guide_SInhala</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=147097c1337a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 7 Principles of Software Testing — A Quick Guide]]></title>
            <link>https://medium.com/@dasunsooriyabandara/the-7-principles-of-software-testing-a-quick-guide-2321b81032af?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/2321b81032af</guid>
            <category><![CDATA[testing-basics]]></category>
            <category><![CDATA[seven-principles]]></category>
            <category><![CDATA[testing-principles]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Tue, 03 Jun 2025 08:23:41 GMT</pubDate>
            <atom:updated>2025-06-03T08:26:06.949Z</atom:updated>
            <content:encoded><![CDATA[<h3>The 7 Principles of Software Testing — A Quick Guide</h3><p>Software testing is not just about finding bugs — it’s about ensuring quality. To guide testers in delivering effective and efficient results, the <strong>ISTQB (International Software Testing Qualifications Board)</strong> defined <strong>seven key principles</strong> that serve as the foundation for good testing practices.</p><p>Let’s take a quick look at each principle</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/318/1*2dtx43TNapTpuOKFS9JXWA.png" /></figure><h3>1. Testing Shows Presence of Defects</h3><blockquote><em>Testing can show that bugs exist — but it cannot prove that there are none.</em></blockquote><p>Even after thorough testing, we can never say the software is 100% bug-free. Testing reduces the chance of undetected defects but cannot guarantee perfection.</p><h3>2. Exhaustive Testing is Impossible</h3><blockquote><em>Testing everything (all inputs, combinations, and paths) is not feasible — except for the simplest systems.</em></blockquote><p>Therefore, risk-based and priority-based testing are used to focus on the most critical areas.</p><h3>3. Early Testing Saves Time and Money</h3><blockquote><em>The earlier you catch defects, the cheaper they are to fix.</em></blockquote><p>Starting testing activities from the requirements or design phase helps prevent bugs before they reach production.</p><h3>4. Defect Clustering</h3><blockquote><em>A small number of modules often contain most of the bugs.</em></blockquote><p>This is known as the <strong>Pareto Principle (80/20 rule)</strong>. Testers can focus efforts on areas known to be problematic or complex.</p><h3>5. Pesticide Paradox</h3><blockquote><em>Running the same tests repeatedly will eventually stop finding new bugs.</em></blockquote><p>To overcome this, tests must be regularly reviewed and updated to catch new or hidden defects.</p><h3>6. Testing is Context Dependent</h3><blockquote><em>The approach to testing depends on the software being tested.</em></blockquote><p>For example, safety-critical systems need more rigorous testing than an internal web tool.</p><h3>7. Absence-of-Errors Fallacy</h3><blockquote><em>Finding no bugs doesn’t mean the product is useful or correct.</em></blockquote><p>If the system doesn’t meet user needs, even a bug-free product can be a failure.</p><h3>Conclusion</h3><p>These seven principles help testers plan smarter, test better, and focus on quality that matters. By following them, QA professionals can ensure their testing efforts are not only efficient but also aligned with real-world goals.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2321b81032af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding the Agile Testing Quadrants: A Practical Guide]]></title>
            <link>https://medium.com/@dasunsooriyabandara/understanding-the-agile-testing-quadrants-a-practical-guide-ea5ac7c9a6d9?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea5ac7c9a6d9</guid>
            <category><![CDATA[istqb]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[istqb-foundation-level]]></category>
            <category><![CDATA[testing-quadrants]]></category>
            <category><![CDATA[agile-testing-quadrants]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Thu, 24 Apr 2025 17:14:29 GMT</pubDate>
            <atom:updated>2025-04-24T17:14:29.709Z</atom:updated>
            <content:encoded><![CDATA[<p>Testing in Agile isn’t just about finding bugs — it’s about building the right product, the right way, from the very start. If you’ve ever felt overwhelmed by the different types of tests in Agile, the <strong>Agile Testing Quadrants</strong> can help bring clarity.</p><p>Originally introduced by <strong>Brian Marick</strong> and later refined by <strong>Lisa Crispin and Janet Gregory</strong>, this model organizes testing into four key areas. It’s not a strict rulebook but a flexible guide to ensure you’re covering all the bases — from code-level checks to real-world user experience.</p><h3>The Agile Testing Quadrants Explained</h3><p>The model splits testing into <strong>four quadrants</strong> based on two key questions:</p><ol><li><strong>Who is this test for?</strong> (Business vs. Technology)</li><li><strong>What’s the goal?</strong> (Supporting development vs. Evaluating the product)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ROiOAbo0GSWXhfZjvjTs_A.png" /></figure><h3>Quadrant 1 (Q1): Tech-Facing Tests Supporting the Team</h3><p><strong>What’s tested?</strong></p><ul><li>Unit tests (small pieces of code)</li><li>Component tests (larger modules)</li><li>Integration tests (how parts work together)</li></ul><p><strong>Who does it?</strong><br>Mostly <strong>developers</strong>, often using <strong>Test-Driven Development (TDD)</strong>.</p><p><strong>Why does it matter?</strong><br>These tests catch bugs early, making development faster and smoother.</p><p><strong>Example:</strong><br>✔ You’re building a payment system. A unit test checks if calculateTax(100) correctly returns 10.</p><h3>Quadrant 2 (Q2): Business-Facing Tests Supporting the Team</h3><p><strong>What’s tested?</strong></p><ul><li>Automated acceptance tests (Does the feature work as expected?)</li><li>API tests (Is the backend logic correct?)</li><li>UI automation (Does the frontend behave correctly?)</li></ul><p><strong>Who does it?</strong><br><strong>Developers, testers, and product owners</strong> work together.</p><p><strong>Why does it matter?</strong><br>Ensures the software solves the business problem it was built for.</p><p><strong>Example:</strong><br>✔ A test verifies that users can add items to a cart, apply a discount, and check out successfully.</p><h3>Quadrant 3 (Q3): Business-Facing Tests Critiquing the Product</h3><p><strong>What’s tested?</strong></p><ul><li>Exploratory testing (freestyle testing to uncover unexpected issues)</li><li>Usability testing (Is the interface intuitive?)</li><li>User acceptance testing (Do real users approve?)</li></ul><p><strong>Who does it?</strong><br><strong>QA testers, product owners, and even real users</strong>.</p><p><strong>Why does it matter?</strong><br>Helps catch things automation can’t — like confusing workflows or missing features.</p><p><strong>Example:</strong><br>✔ Manually testing a new mobile app to see if navigation feels natural or frustrating.</p><h3>Quadrant 4 (Q4): Tech-Facing Tests Critiquing the Product</h3><p><strong>What’s tested?</strong></p><ul><li>Performance testing (Can it handle 10,000 users?)</li><li>Security testing (Is it vulnerable to attacks?)</li><li>Load &amp; stress testing (Does it crash under pressure?)</li></ul><p><strong>Who does it?</strong><br><strong>Specialized testers, security experts, or DevOps engineers</strong>.</p><p><strong>Why does it matter?</strong><br>Even a perfectly functional app is useless if it’s slow, unstable, or easily hacked.</p><p><strong>Example:</strong><br>✔ Simulating a Black Friday sale to see if the website stays fast when flooded with traffic.</p><h3>🚀 How to Use the Quadrants in Real Life</h3><ul><li><strong>Q1 &amp; Q2</strong> help you <strong>build the product right</strong> (correct functionality).</li><li><strong>Q3 &amp; Q4</strong> help you <strong>build the right product</strong> (good UX, performance, security).</li></ul><p>Don’t ignore any quadrant. Developers, testers, and business stakeholders should work together.</p><h3>Final Thoughts</h3><p>The Agile Testing Quadrants aren’t about rigid rules — they’re a <strong>mental model</strong> to help teams:<br>✅ <strong>Plan testing efforts</strong> more effectively.<br>✅ <strong>Avoid missing critical tests</strong> (like security or usability).<br>✅ <strong>Encourage teamwork</strong> between devs, QA, and business teams.</p><p>By using this framework, you’ll ensure your software isn’t just bug-free — it’s <strong>user-friendly, scalable, and secure</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea5ac7c9a6d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Difference Between type() and fill() in Playwright]]></title>
            <link>https://medium.com/@dasunsooriyabandara/difference-between-type-and-fill-in-playwright-f616651fd3e5?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/f616651fd3e5</guid>
            <category><![CDATA[fill-vs-type-playwright]]></category>
            <category><![CDATA[playwrights]]></category>
            <category><![CDATA[type-playwright]]></category>
            <category><![CDATA[fill-vs-type]]></category>
            <category><![CDATA[fill-playwright]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Wed, 26 Mar 2025 17:59:40 GMT</pubDate>
            <atom:updated>2025-03-26T17:59:40.715Z</atom:updated>
            <content:encoded><![CDATA[<p>Interaction with input fields is common when automating Playwright web applications. Playwright offers two main methods for entering text into input fields: type() and fill(). Both are used for input operations, and they have different behaviors and use cases.</p><p>Here’s a detailed comparison of type() and fill()</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*O2MEpoHkXtiN8wepOqH6gw.png" /></figure><h3>Using type() in Playwright (Java)</h3><p>Simulates real user keystrokes with a delay between each character.</p><pre>import com.microsoft.playwright.*;<br><br>public class TypeExample {<br>    public static void main(String[] args) {<br>        try (Playwright playwright = Playwright.create()) {<br>            Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(false));<br>            Page page = browser.newPage();<br><br>            page.navigate(&quot;https://example.com&quot;);<br><br>            // Typing each character individually, simulating real user input<br>            page.locator(&quot;#username&quot;).type(&quot;JohnDoe&quot;);<br><br>            browser.close();<br>        }<br>    }<br>}</pre><p><strong>Real-World Use Case:</strong><br> type() simulates each keystroke, which is useful when testing scenarios like:</p><ul><li>Auto-suggestion dropdowns.</li><li>Validation that occurs on each keystroke.</li></ul><h3>Using fill() in Playwright (Java)</h3><p>Directly sets the input field value without simulating typing.</p><pre>import com.microsoft.playwright.*;<br><br>public class FillExample {<br>    public static void main(String[] args) {<br>        try (Playwright playwright = Playwright.create()) {<br>            Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(false));<br>            Page page = browser.newPage();<br><br>            page.navigate(&quot;https://example.com&quot;);<br><br>            // Directly setting the input field value<br>            page.locator(&quot;#username&quot;).fill(&quot;JohnDoe&quot;);<br><br>            browser.close();<br>        }<br>    }<br>}</pre><p><strong>Real-World Use Case:</strong><br> fill() directly sets the input value, making it ideal for:</p><ul><li>Quickly populating fields in forms.</li><li>Situations where typing simulation is unnecessary.</li><li>For <strong>bulk filling of form fields</strong> during test setup or execution.</li></ul><h3>Performance Comparison</h3><p>If performance is a concern, it fill() is significantly faster as it skips the simulation of typing. For tests that do not require detailed interaction, using fill() is recommended to save execution time.</p><h3>Conclusion</h3><ul><li><strong>Use </strong><strong>type()</strong> When you need to simulate real user typing behavior.</li><li><strong>Use </strong><strong>fill()</strong> When you want to quickly and efficiently set a value in an input field.</li></ul><p>Understanding these differences will help you write more precise and effective Playwright scripts tailored to your testing needs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f616651fd3e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with Playwright: Basic Browser Operations in Java]]></title>
            <link>https://medium.com/@dasunsooriyabandara/getting-started-with-playwright-basic-browser-operations-in-java-a44af6a43693?source=rss-61bc2d350b9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a44af6a43693</guid>
            <category><![CDATA[playwright-automation]]></category>
            <category><![CDATA[playwright-with-java]]></category>
            <category><![CDATA[playwright-test]]></category>
            <category><![CDATA[playwrights]]></category>
            <category><![CDATA[playwright-community]]></category>
            <dc:creator><![CDATA[Dasun Sooriyabandara]]></dc:creator>
            <pubDate>Thu, 02 Jan 2025 16:19:56 GMT</pubDate>
            <atom:updated>2025-01-02T16:19:56.483Z</atom:updated>
            <content:encoded><![CDATA[<p>Playwright is a modern end-to-end testing framework developed by Microsoft. It enables developers to automate browsers for testing web applications with speed, reliability, and flexibility. One of the key strengths of Playwright is that it supports multiple browser engines: Chromium, Firefox, and WebKit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/299/0*7k9GC-s4xR16jgkM" /></figure><p>In this article, we will look at how to do basic browser operations in Playwright in <strong>Java</strong>, such as launching a browser, closing it, maximizing, and minimizing.</p><h3>Setting Up Playwright</h3><p>Before starting, ensure you have the Playwright library installed in your Java project. You can do this by adding the Playwright dependency to your pom.xml file if you&#39;re using Maven</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;com.microsoft.playwright&lt;/groupId&gt;<br>    &lt;artifactId&gt;playwright&lt;/artifactId&gt;<br>    &lt;version&gt;1.39.0&lt;/version&gt;<br>&lt;/dependency&gt;</pre><h3>Launching a Browser</h3><p>Launch a browser to start automating with Playwright. It currently supports three major browser types: Chromium, Firefox, and WebKit.</p><p>Here is how you could launch a browser in Playwright</p><pre>import com.microsoft.playwright.*;<br><br>public class BrowserOperations {<br>    public static void main(String[] args) {<br>        try (Playwright playwright = Playwright.create()) {<br>            Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(false));<br>            BrowserContext context = browser.newContext();<br>            Page page = context.newPage();<br>            page.navigate(&quot;https://example.com&quot;);<br>            System.out.println(&quot;Page Title: &quot; + page.title());<br>            browser.close();<br>        }<br>    }<br>}</pre><h3>Launching a Browser in Headed and Headless Modes</h3><p>By default, Playwright launches browsers in headless mode. That is, the browser runs in the background and is not visible. To see the browser when it runs, you should run it in headed mode</p><pre>Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(true)); // Headless mode</pre><h3>Closing the Browser</h3><p>Once you have completed your tasks, it is necessary to close the browser in order to free up the resources</p><pre>browser.close();</pre><h3>Maximizing the Browser Window</h3><p>Playwright doesn’t have a direct maximize option, but you can achieve this by setting the viewport to screen dimensions, such as Full HD (1920x1080).</p><pre>BrowserContext context = browser.newContext(new Browser.NewContextOptions().setViewportSize(1920, 1080));<br>Page page = context.newPage();<br>page.navigate(&quot;https://example.com&quot;);</pre><h3>Minimizing the Browser Window</h3><p>Native minimization isn’t supported in Playwright, but it can be simulated by handling focus or using custom commands.</p><h3>Running Multiple Pages</h3><p>Playwright allows opening multiple tabs in a single browser instance, enabling tests that simulate real-world scenarios where users open multiple links simultaneously.</p><pre>BrowserContext context = browser.newContext();<br>Page page1 = context.newPage();<br>Page page2 = context.newPage();<br><br>page1.navigate(&quot;https://example.com&quot;);<br>page2.navigate(&quot;https://playwright.dev&quot;);<br><br>System.out.println(&quot;Page 1 Title: &quot; + page1.title());<br>System.out.println(&quot;Page 2 Title: &quot; + page2.title());</pre><h3>Summary</h3><p>With these Java examples, you can perform essential browser operations using Playwright:</p><ol><li>Launching browsers in headless and headed modes.</li><li>Closing browsers and freeing up resources.</li><li>Maximizing window size via viewport settings.</li><li>Running multiple pages in a single browser instance.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a44af6a43693" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>