Common Testing Terms Every QA Should Know

 

Common Testing Terms Every QA Should Know

Day-1

🚀 What is Software Testing?

Software Testing is a process of evaluating a software application to identify defects, errors, or missing requirements — ensuring that the product meets customer expectations before release.

Think of it like this:
If developing software is like cooking a meal…
Software Testing is the tasting before serving it to the guests!
Would you serve a dish without tasting it first? 🍽️

Benefits of Software Testing:
✔️ Improves Product Quality
✔️ Ensures Customer Satisfaction
✔️ Reduces Business Risks
✔️ Saves Costs in the Long Run
Testing is not just a phase — it’s a culture of quality.

hashtag#SoftwareTesting hashtag#QualityMatters hashtag#TestEarly hashtag#BugFree hashtag#QA hashtag#SDLC

Day-2:

🧑‍💻 Types of Software Testing — Every Tester Should Know!
Software Testing is a broad field with different testing techniques — each designed to catch specific issues and ensure quality.

Let’s explore some of the most commonly used types of testing in the industry:

1️⃣ Manual Testing
Testing is done manually without the use of automation tools. Testers follow test cases and use the application like end-users.
Example: Manually checking whether a "Forgot Password" feature sends a reset link.

2️⃣ Automation Testing
Writing scripts or using tools to automate test case execution — faster, repeatable, and ideal for regression testing.
Example: Using Selenium to test login functionality across multiple browsers.

3️⃣ Functional Testing
Verifying that all features of the application work as per the requirements.
Example: Testing if a user can add items to a shopping cart and place an order.

4️⃣ Performance Testing
Testing how the system performs under different conditions — load, stress, and scalability.
Example: Testing whether a website loads within 2 seconds with 1000 concurrent users.

5️⃣ Security Testing
Identifying vulnerabilities or security loopholes in the application to protect against attacks.
Example: Testing for SQL Injection, XSS, or data leakage in sensitive fields.

6️⃣ Usability Testing
Ensuring the application is user-friendly and provides a good user experience.
Example: Checking whether users can easily navigate through the app.

7️⃣ Integration Testing
Testing how different modules or components of a system interact with each other.
Example: Testing if the payment gateway successfully communicates with the bank server.

8️⃣ Regression Testing
Re-testing the existing features after changes or bug fixes to ensure no new issues are introduced.
Example: After fixing a payment bug, testers recheck the entire checkout process.

9️⃣ User Acceptance Testing (UAT)
Testing is done by the client or end-users to validate if the product meets their expectations.
Example: A client verifies the developed HR portal before final release.

1️⃣0️⃣ Compatibility Testing
Ensuring the application works seamlessly across different devices, browsers, OS, and networks.
Example: Testing an e-commerce website on Chrome, Firefox, Safari, and Edge browsers.

Activate to view larger image,

Day 3: 

Human-Led vs Tool-Assisted Testing – A Clearer Perspective

In the world of software testing, terms like "Manual Testing" and "Automation Testing" are widely used, but they often create confusion, especially among newcomers. These are not different types of testing, but rather approaches we use to perform testing activities.
Let’s take a moment to understand what each really means and why we should think differently about them.

🔍 Human-Led Testing
Also known (though less accurately) as “manual testing,” this is a testing approach where humans actively perform the tests without the help of scripts. But it’s far from “just clicking.” It involves:
Critical thinking
Exploration and intuition
Analyzing unexpected behavior
Assessing usability and user experience

✅ Best suited for:
Exploratory Testing
Ad-hoc Testing
Usability Testing
Tests with frequently changing UI/UX

🧪 Example:
While testing a travel booking app, a tester might observe that users naturally expect a calendar pop-up when they click the "Departure Date" field. The app opens a dropdown instead — technically functional, but not intuitive. This insight can only be caught by human judgment.

🤖 Tool-Assisted Testing
Often called “automation testing,” this is a technique where scripts or tools are used to perform tests. However, those scripts' design, development, and maintenance are still human-led.
✅ Best suited for:
Regression Testing
Performance Testing
Load Testing
Repetitive test cases with stable UIs
Example:
If a retail app has 200+ test cases to verify after every minor update, automating these scenarios using Selenium or Cypress ensures quick, consistent feedback, saving hours of manual effort.

⚖️ Key Takeaway
Both approaches are essential. One explores and uncovers, while the other ensures consistency and efficiency. It’s time we move past the misnomers of “manual” and “automated” and recognize the tester’s role as central, no matter the tool.

Day 4: 

SDLC vs STLC — Understanding the Key Differences & Their Role in Software Quality

In the Software Industry, two of the most fundamental processes are:
SDLC (Software Development Life Cycle)
STLC (Software Testing Life Cycle)

Both SDLC and STLC play vital roles in delivering a high-quality software product, but they are often misunderstood or interchanged by beginners.

In reality, SDLC and STLC are two different life cycles with unique objectives and phases — yet they work in synchronization for successful project delivery.

Let’s understand their differences, purpose, and how they complement each other in the software development process.

What is SDLC?
Software Development Life Cycle (SDLC) is a process followed by the development team to design, develop, and deliver a fully functional software product based on business requirements.

Key Objective:
To build software that meets client expectations within cost, time, and quality constraints.

What is STLC?
Software Testing Life Cycle (STLC) is a systematic process followed by the testing team to ensure the software product is error-free, meets quality standards, and works as expected.

Key Objective:
To validate and verify the quality of the software before release.

SDLC Phases:
Requirement Gathering
System Design
Development (Coding)
Testing
Deployment
Maintenance

STLC Phases:
Requirement Analysis
Test Planning
Test Case Design
Test Environment Setup
Test Execution
Test Closure

Real-Time Example:
Scenario: Online Shopping Application Development
SDLC:
Developers work on features like Product Search, Add to Cart, Payment Integration, and Order Placement.
STLC:
Testers create test cases for each feature, verifying if the search returns correct results, the payment gateway is secure, and orders are processed without errors.
Without STLC — Even if SDLC is completed, the product might have defects affecting customer experience.

Conclusion:
SDLC and STLC are Two Sides of the Same Coin.
SDLC focuses on building the Product.
STLC focuses on testing the Product.

For any organization to deliver a successful product, both SDLC and STLC should go hand-in-hand.

Testing should not be seen as a phase that happens only after development, but a continuous activity integrated throughout SDLC.

Day 5:

🚀 Why Software Testing is Essential in 2025
As technology rapidly evolves, software testing has shifted from a support role to a strategic driver of quality, trust, and innovation. In 2025, it's not just about "does it work?" — it’s about how securely, ethically, and efficiently it works.

🔍 Why Is Testing So Important in 2025?
✅ 1. AI-Driven Systems Demand Accuracy & Ethics
From healthcare to finance, AI systems now make critical decisions. These models are complex and dynamic.
🔹 Testing ensures fairness, transparency, and that AI behaves responsibly across real-world scenarios.

✅ 2. Speed from Agile & CI/CD Requires Stability
Modern development teams ship faster than ever.
🔹 Continuous testing — including automation, regression, and integration — keeps pace without sacrificing quality.

✅ 3. Security Is Mission Critical
Ransomware, phishing, and supply-chain attacks are rising. Businesses can’t afford reputational or financial loss due to vulnerabilities.
🔹 Embedding security testing and vulnerability scanning into the pipeline is key for proactive defense. In 2025, DevSecOps isn't a trend — it's a necessity.

✅ 4. Multi-Platform, Multi-Device Expectations
Apps run across phones, wearables, browsers, and smart devices.
🔹 Testing must ensure consistent performance across OS versions, screen sizes, and network conditions.

✅ 5. Great UX Is a Competitive Advantage
A clunky or slow app drives users away.
🔹 Performance, usability, and accessibility testing help ensure seamless and inclusive experiences.

✅ 6. Regulatory Compliance Is Evolving
With AI regulations, GDPR updates, and industry-specific mandates, compliance is complex.
🔹 Testing supports legal readiness through checks for data privacy, consent, and reporting mechanisms.

✅ 7. Real-Time & Big Data Needs Precision
With ML-based personalization, recommendation engines, and dashboards relying on real-time data, bad input = bad decisions
🔹 QA validates data integrity, pipeline performance, and alert systems to avoid costly errors.

✅ 8. Trust Is the True Product
Whether it's a healthcare app or a payment gateway, reliability builds trust.
🔹 Testing ensures consistency across edge cases, giving confidence to developers, users, and stakeholders alike.

🧠 Real-World Example
Picture a wearable health tracker that flags abnormal heart rhythms. If the testing missed an edge case, the device might delay or ignore alerts, potentially putting users at serious risk.
✔️ With proper test coverage, simulation, and fault injection, such high-stakes bugs can be prevented.

Day 6:

🔧 Top 10 Testing Tools Every QA Engineer Should Know in 2025

QA is no longer just about catching bugs — it's a critical enabler of fast, secure, and scalable software delivery. As projects grow more complex and timelines shrink, the right tools can make or break your testing strategy.

🛠️ Top 10 Testing Tools Shaping QA in 2025

Selenium
The industry standard for web automation testing. Selenium supports multiple languages and browsers, making it a top choice for regression and functional testing.

Postman
A powerful platform for API development and testing, offering automation via scripts, mock servers, and robust integrations. A go-to for backend and service validation.

Apache JMeter
A performance testing tool is widely used to simulate heavy loads on servers and measure application behavior under stress. Essential for web and API performance testing.

TestNG
A versatile testing framework inspired by JUnit but more powerful—great for complex testing suites, parallel test execution, and data-driven testing, especially with Selenium.

Appium
The leading open-source tool for mobile automation testing. Supports native, hybrid, and mobile web apps on both Android and iOS using a single codebase.

Cypress
A modern end-to-end testing framework for JavaScript applications. Loved for its speed, debuggability, and real-time reloading—ideal for frontend UI tests.

Playwright
Developed by Microsoft, this fast-rising tool enables reliable cross-browser testing across Chromium, Firefox, and WebKit with headless support and full automation features.

Burp Suite
The gold standard for web security testing. Ideal for penetration testing, detecting vulnerabilities like XSS, CSRF, and more, vital in DevSecOps pipelines.

TestRail
A comprehensive test case management platform that helps teams organize, track, and manage testing efforts with integrations to tools like Jira and CI/CD pipelines.

QTest by Tricentis
Enterprise-grade test management with support for Agile workflows, real-time reporting, and seamless integration with automation frameworks and DevOps tools.

These ten tools are among the most widely used, but countless others are chosen by teams worldwide based on their unique project needs, tech stacks, and testing goals.

✅ Real-World Scenario: How These Tools Work Together

Imagine testing a banking app:
Selenium for UI automation
Postman to validate transaction APIs
JMeter to simulate 1,000+ users
Burp Suite to ensure data security

By combining tools across layers, you ensure full test coverage, from functionality to performance and security.

Day 7

🔄 Bug Life Cycle (with Real-World Examples)
The Bug Life Cycle defines each stage a software bug goes through from discovery to closure. Understanding this process improves tracking, communication, and overall product quality.

Life Cycle Stages with Examples:
1) New
A tester finds a bug and logs it in the system.
Example: On an e-commerce app, clicking “Apply Coupon” crashes the app. The tester logs this with steps and screenshots.

2) Assigned
QA leads review and assign it to the concerned developer.
Example: The bug is assigned to the frontend developer who manages the cart module.

3) Open
The developer starts analyzing and working on the fix.
Example: The dev checks the coupon component and identifies a missing null check.

4) Fixed
The developer fixed the issue and marked the bug as fixed.
Example: The crash is resolved by adding proper error handling for invalid coupon responses.

5) Pending Retest
The fix is deployed to the QA environment.
Example: The updated version is now available on staging, ready for QA validation.

6) Retest
Tester verifies the fix by replicating the original steps.
Example: Tester applies various coupons and confirms the app no longer crashes.

7) Verified
The bug is confirmed as resolved.
Example: Tester validates both valid and invalid coupon scenarios. All works fine.

8) Closed
The QA lead or manager closes the bug.
Example: Since all tests pass, no further action is needed. The bug is closed.

Alternative Bug Outcomes After Opening a Bug:
✅ Reopened
The bug reappears or isn’t fully fixed.
Example: Another tester finds that the same crash happens when a coupon is applied on the Wishlist page. The bug is reopened.

✅ Duplicate
Same issue logged earlier.
Example: Another tester reported the coupon crash in a different module. This bug is marked as duplicate.

✅ Deferred
Bug postponed to future release.
Example: A visual glitch on the help page is minor and pushed to the next sprint.

✅ Rejected
The bug isn’t valid.
Example: Tester misunderstood a feature. Coupon logic was working as designed.

✅ Not a bug
Reported behavior is expected.
Example: Tester thinks prices should update automatically, but the system requires manual refresh due to business logic.

✅ Every stage ensures traceability, accountability, and clear communication between QA and Dev teams.

Day 8:

Common Testing Terms Every QA Should Know-

In software testing, mastering terminology is key to mastering the craft. Here's a quick, professional refresher on 20 key testing terms with mini examples to bring them to life. 👇

🔹 Bug/Defect
An error causing incorrect behavior.
Example: Clicking “Add to Cart” increases item quantity instead.

🔹 Smoke Testing
Basic checks to ensure the build is stable.
Example: App opens and homepage loads without crashing.

🔹 Regression Testing
Re-checking old features after changes.
Example: Testing payment after updating the shipping module.

🔹 Unit Testing
Testing smallest units in isolation.
Example: Validate if a “Submit” button triggers correct event.

🔹 Integration Testing
Testing combined components progressively.
Example: Ensure user profile fetch works after login.

🔹 System Testing
Testing the complete, integrated software.
Example: Simulate end-to-end shopping and payment flow.

🔹 UAT (User Acceptance Testing)
Testing by end users before go-live.
Example: Client tests if invoice generation meets business logic.

🔹 Non-Functional Testing
Tests performance, usability, security, etc.
Example: Load test checks if site handles 1000 users.

🔹 Sanity Testing
Quick checks after minor fixes.
Example: Confirming “Reset Password” works after UI update.

🔹 Black Box Testing
Testing based on output, no code knowledge.
Example: Tester enters input and verifies result without checking backend logic.

🔹 White Box Testing
Testing with access to internal code.
Example: Developer writes tests for conditional logic in a payment service.

🔹 Exploratory Testing
Simultaneous learning, testing, and thinking.
Example: Tester clicks around a new feature without formal scripts to discover issues.

🔹 Boundary Testing
Testing input limits.
Example: Check form accepts names of exactly 50 characters.

🔹 Functional Testing
Tests if features work as expected.
Example: Search bar returns accurate product results.

🔹 Test Suite
A group of related test cases.
Example: Checkout test suite contains all cart, shipping, and payment test cases.

🔹 Test Case
A set of steps to verify a specific function.
Example: Check if login succeeds with valid credentials.

🔹 Test Plan
Document describing scope, strategy, and deliverables.
Example: Plan outlines timelines, tools, and testers for Sprint.

🔹 Test Script
Detailed steps for running a test.
Example: “Step 1: Enter username, Step 2: Enter password, Step 3: Click Login.”

🔹 Test Scenario
High-level idea of what to test.
Example: “Verify user registration with valid email.”

🔹 Test Environment
Setup where tests are executed.
Example: A staging server replicating production setup for safe testing.