all_topics()

What is Software Testing?

// understand what software testing is, why it matters, and what a tester actually does.

Why is Software Testing Important?

// real-world consequences of poor testing and the value qa brings to a team.

SDLC — Software Development Life Cycle

// the phases of software development and where testing fits in.

STLC — Software Testing Life Cycle

// the dedicated life cycle for testing — from requirements analysis to closure.

V-Model in Software Testing

// how testing maps to each development phase in the v-model.

Verification vs Validation

// are we building the product right? are we building the right product?

Static Testing vs Dynamic Testing

// testing without running the code vs testing with execution.

7 Principles of Software Testing

// the fundamental rules every tester should follow.

QA vs QC — What is the Difference?

// quality assurance vs quality control — roles, responsibilities, and differences.

Software Tester vs SQA Engineer

// understanding the difference in scope, responsibility, and mindset.

Error vs Defect vs Failure

// three terms everyone uses interchangeably — but they mean very different things.

Levels of Testing

// unit, integration, system, and acceptance testing — the four levels explained.

Types of Testing — Overview

// a high-level map of all testing types: functional, non-functional, manual, automated.

Risk-Based Testing

// test the highest-risk areas first — how to prioritise when time is limited.

How to Write a Test Case

// the anatomy of a well-written test case — every field, why it matters, and what makes it good or bad.

Test Plan vs Test Strategy

// two documents every qa engineer must know — what each is, who writes it, and when to use which.

Black Box Testing

// testing without knowing the internal code — purely based on inputs and outputs.

White Box Testing

// testing with full knowledge of the internal code structure.

Grey Box Testing

// a mix of black box and white box — partial knowledge of the system.

Equivalence Partitioning

// divide inputs into valid and invalid groups to reduce test cases without losing coverage.

Boundary Value Analysis (BVA)

// test at the edges of input ranges where bugs love to hide.

Decision Table Testing

// model complex business rules as a table to ensure every condition is tested.

State Transition Testing

// test how a system moves between states in response to events.

Use Case Testing

// design tests based on how real users interact with the system.

Error Guessing & Experience-Based Testing

// leverage experience and intuition to find bugs that structured techniques miss.

Exploratory Testing

// simultaneous learning, test design, and execution — no scripts needed.

Checklist-Based Testing

// use structured checklists to ensure consistent, repeatable coverage without writing full test cases.

Pairwise Testing

// cut test case count by 80%+ by covering every pair of parameter values — where most bugs hide.

Cause-Effect Graphing

// map conditions to outcomes visually, then derive a complete test suite from the logical relationships.

Functional vs Non-Functional Testing

// what the system does vs how well it performs.

Manual Testing

// testing performed by humans without automation tools.

Automation Testing (Intro)

// when and why to automate — the fundamentals.

Unit Testing

// testing the smallest individual units of code in isolation.

Integration Testing

// testing how different modules or services work together.

System Testing

// end-to-end testing of the complete system.

User Acceptance Testing (UAT)

// final validation that the software meets business requirements.

Regression Testing

// ensuring new changes haven't broken existing functionality.

Smoke Testing vs Sanity Testing

// two critical quick checks before deeper testing begins.

Ad-hoc Testing

// informal, unstructured testing without any documentation.

Alpha Testing vs Beta Testing

// internal vs external testing before a full product release.

Positive & Negative Testing

// test what should work — and what should fail gracefully.

Retesting vs Regression Testing

// two similar but very different concepts explained clearly.

End-to-End Testing

// testing the full user journey from start to finish.

What is a Test Plan?

// the master document that defines what, how, when, and who tests.

Test Strategy vs Test Plan

// high-level approach vs detailed execution plan — know the difference.

How to Write Test Cases

// components of a great test case with templates and real examples.

Test Scenario vs Test Case vs Test Script

// three terms that confuse every beginner — explained once and for all.

Requirements Traceability Matrix (RTM)

// map every requirement to its test case to ensure nothing is missed.

Test Data Preparation

// how to prepare clean, realistic, and effective test data.

Test Environment Setup

// what is a test environment and how to set one up properly.

Entry & Exit Criteria

// when should testing start and when should it stop?

Bug vs Defect vs Error vs Fault vs Failure

// five terms everyone uses interchangeably — but they mean different things.

Defect Life Cycle

// the complete journey of a bug from discovery to closure.

How to Write a Good Bug Report

// a well-written bug report gets fixed faster. learn what to include.

Severity vs Priority

// impact on the system vs urgency of the fix — a critical distinction.

Defect Categories

// types of defects — functional, performance, security, ui, and more.

Latent & Masked Defects

// defects hiding in plain sight — what they are and why they matter.

Defect Removal Efficiency (DRE)

// measure how effective your testing is at catching bugs before production.

What are Test Metrics?

// why we measure testing and what good metrics actually tell you.

Test Coverage — Types Explained

// requirements coverage, code coverage, risk coverage — and how they differ.

Why Test Metrics Are Important

// why testing without metrics creates blind spots and how metrics improve decisions.

Process vs Product Metrics

// separating how well testing is running from how healthy the product actually is.

Code Coverage vs Test Coverage

// why 100% code coverage does not mean 100% tested.

Test Execution Metrics

// pass rate, fail rate, blocked rate — measuring the health of your test run.

Defect Metrics

// defect density, defect arrival rate, age, and leakage — the numbers behind bug management.

Defect Removal Efficiency (DRE)

// how to measure how effective your testing is at catching bugs before production.

Requirement Coverage Metrics

// measuring whether agreed requirements are actually covered by test cases.

Test Effectiveness & Efficiency

// are your tests finding real bugs? are you finding them fast enough?

Defect Leakage

// how many defects escaped testing and were found in later stages or by real users.

Defect Density

// relating defect count to product size for fairer quality comparisons.

Reporting Metrics to Stakeholders

// how to present testing data clearly to managers and non-technical stakeholders.

Test Reporting Dashboard

// bringing the most useful metrics together in one clear view for stakeholders.

Test Summary Report

// how to write a professional test summary report at the end of a testing cycle.

Pitfalls of Test Metrics

// how wrong metrics create bad behavior and push teams in the wrong direction.

Testing in Agile — The Shift

// how agile changes the tester's role — continuous testing, not a final gate.

Testing Within a Sprint

// how qa fits into sprint planning, execution, and review ceremonies.

Shift-Left Testing

// involving qa earlier in the sdlc to prevent defects instead of just finding them.

BDD — Behaviour-Driven Development

// writing tests in plain language with given-when-then using tools like cucumber.

TDD — Test-Driven Development

// write the test before the code — the red-green-refactor cycle explained.

CI/CD Pipelines for Testers

// how automated tests plug into ci/cd pipelines — github actions, jenkins, and more.

Testing in DevOps Culture

// the qa role in a devops team — continuous feedback, monitoring, and collaboration.

Feature Flags & Canary Releases

// how modern teams release features safely — and how testers verify them.

Shift-Right Testing & Production Monitoring

// testing in production — canary deployments, a/b testing, and observability.

Definition of Done (DoD) for QA

// what "done" really means from a qa perspective in an agile team.

What is an API?

// how apis work, what rest means, and why api testing matters.

REST vs SOAP APIs

// the two main api styles — when to use which and how they differ.

HTTP Methods: GET, POST, PUT, PATCH, DELETE

// what each http method does, when to use it, and real examples.

HTTP Status Codes

// 1xx to 5xx — every status code a tester must know explained clearly.

API Terms You Must Know

// resource, payload, pagination, rate limiting, crud, cache — 16 key terms.

Authentication vs Authorization

// who you are vs what you are allowed to do.

Token-Based Auth (JWT, OAuth 2.0, API Keys)

// how modern authentication works and how to test it.

API Testing with Postman

// step-by-step guide to testing apis manually with postman.

Assertions in API Testing

// what to validate in every api response — status, body, headers, time.

Testing Pagination

// how to verify paginated api responses work correctly.

Testing Rate Limiting

// simulate 429 responses and verify the api enforces its limits.

Path Parameters vs Query Parameters

// /users/123 vs /users?age=25 — differences, use cases, and testing.

How to Test APIs with Authentication

// bearer tokens, api keys, oauth flows — practical testing guide.

API Performance Testing Basics

// how to check response time and load test your apis.

Common API Bugs & How to Find Them

// real bugs testers find in apis — and the techniques to catch them.

REST API Testing Checklist

// a complete checklist to ensure thorough api test coverage.

What is Performance Testing?

// why performance testing matters and what it covers.

Load Testing

// testing under expected user load to ensure stable performance.

Stress Testing

// push the system beyond its limits to find the breaking point.

Spike Testing

// sudden surge of traffic — can your app handle it?

Endurance (Soak) Testing

// long-duration testing to find memory leaks and degradation.

Scalability Testing

// how well does the system grow when more resources are added?

Key Performance Metrics

// response time, throughput, latency, rps, error rate — explained.

95th Percentile Response Time

// what p95 means, why it matters more than average, and how to use it.

Baseline Testing

// setting a benchmark to compare future performance results against.

Performance Testing with K6

// write and run your first k6 load test — step by step.

Ramp-Up, Steady State & Ramp-Down

// the three phases of a performance test script explained.

Thresholds in K6

// set pass/fail conditions for automated performance gates in ci/cd.

Identifying Performance Bottlenecks

// how to read test results and pinpoint what is slowing your app down.

Performance Testing in CI/CD

// integrate k6 or jmeter into github actions / jenkins pipelines.

Performance Testing Tools Comparison

// k6 vs jmeter vs gatling vs locust — which one to use?

What is Security Testing?

// the goals, scope, and types of security testing every qa engineer should know.

OWASP Top 10 Overview

// the ten most critical web application security risks — explained for testers.

SQL Injection

// how sql injection works, how to test for it, and why it is still the top attack vector.

Cross-Site Scripting (XSS)

// stored, reflected, and dom-based xss — how to detect and test for each.

Broken Access Control

// the #1 owasp risk — testing that users can only access what they are authorized to.

Authentication Testing

// testing login flows for weak passwords, brute force, session fixation, and more.

API Security Testing

// owasp api top 10 — the most critical vulnerabilities in rest apis.

Sensitive Data Exposure

// testing for pii leakage, insecure storage, and unencrypted data transmission.

Security Testing with OWASP ZAP

// using zap to scan web applications for vulnerabilities — beginner guide.

Security Testing Checklist

// a practical checklist to verify security across authentication, api, and data layers.

What is Test Automation?

// what automation is, why it matters, and when not to automate.

What to Automate vs What to Keep Manual

// the key decision framework every automation engineer uses.

Locator Strategies (CSS, XPath, data-testid)

// how to reliably find elements — the right way vs the brittle way.

Page Object Model (POM)

// the industry-standard design pattern for clean, maintainable test code.

Automation Framework Design

// how to structure a scalable test automation framework from scratch.

Handling Waits: Explicit vs Static vs Polling

// why sleep() is bad and what to use instead.

Flaky Tests — Causes & Fixes

// why tests fail randomly and how to make them stable.

Parallel Test Execution

// run tests faster by executing them in parallel.

Test Data Management in Automation

// dynamic data, faker libraries, and avoiding stale test data.

CI/CD Integration for Automation

// plug your automation suite into github actions or jenkins.

Reporting Tools (Allure, HTML Reports)

// generate rich, readable reports from your automation runs.

What is Playwright?

// microsoft's modern automation framework and how it compares to selenium.

Browser, Context & Page in Playwright

// the three-layer hierarchy you must understand to use playwright correctly.

async/await & Promises in JavaScript

// the javascript concepts every playwright automation engineer must know.

Handling Popups, Alerts & File Uploads

// real automation challenges and how to solve them in playwright.

Network Interception & API Mocking

// intercept api calls in your ui tests to control and verify backend behavior.

JIRA for Testers

// how qa engineers use jira — writing bugs, tracking progress, and using boards.

Postman — API Testing Tool

// a practical introduction to postman for sending requests, writing tests, and organizing collections.

Selenium WebDriver Overview

// what selenium is, how it works, and when to use it vs modern alternatives.

Playwright Overview

// why playwright is replacing selenium — features, architecture, and getting started.

K6 — Performance Testing Tool

// writing and running performance tests with k6 — setup, scripts, and results.

Apache JMeter Overview

// gui-based performance testing with jmeter — when to choose it over k6.

Swagger / OpenAPI for Testers

// how to read api documentation in swagger and use it to derive test cases.

Browser DevTools for Testers

// network tab, console, application storage — what every tester can do without writing code.

GitHub & Version Control for Testers

// git basics every qa engineer needs — clone, branch, commit, pr review.

Test Management Tools (TestRail, Zephyr)

// how to manage test cases, test runs, and test reporting professionally.

How to Become a QA Engineer

// the roadmap from zero to your first qa job — skills, tools, and portfolio.

QA Engineer Skills — Technical & Soft

// the must-have skills employers actually look for in 2026.

ISTQB Foundation Level — What It Is

// the world's most recognized testing certification — what it covers and who should get it.

ISTQB Study Guide & Exam Tips

// how to prepare for istqb ctfl — syllabus breakdown, sample questions, and strategy.

Building a QA Portfolio

// what to put in your portfolio — bug reports, automation projects, and test plans.

Writing a QA Resume

// what recruiters look for in a qa resume — and what to avoid.

Common QA Interview Questions

// the most frequently asked qa interview questions with model answers.

QA Career Progression & Salary

// junior → mid → senior → lead — what each level expects and what they pay.

What is Web Testing?

// overview of web testing scope — what to test and why it differs from other testing types.

Browser Compatibility Testing

// ensure the application works correctly across chrome, firefox, safari, and edge.

Responsive Design Testing

// verify layouts adapt correctly across desktops, tablets, and mobile screens.

Cross-Browser Testing Tools

// browserstack, lambdatest, and playwright multi-browser runs explained.

Cookies & Session Testing

// validate cookie creation, expiry, session persistence, and logout behavior.

Cache Behavior Testing

// test how the browser caches assets and what happens when cache is stale.

Frontend Validation Testing

// client-side vs server-side validation — what to test and common bypass techniques.

Forms & Input Field Testing

// edge cases for text, number, date, file upload, and multi-select inputs.

Navigation & Broken Links

// verify all links, redirects, and navigation paths work as expected.

Web Performance & Core Web Vitals

// lcp, cls, fid — google's performance metrics and how to test them.

Security Basics in Web Testing

// xss, csrf, and open redirect — the web vulnerabilities every tester should check.

Accessibility Testing for Web

// screen readers, keyboard navigation, and wcag 2.1 compliance for web apps.

Web Testing Checklist

// a comprehensive checklist covering all web testing areas before any release.

Responsive Testing

// test layouts across screen sizes using browser devtools and real devices.

Cookies & Session Testing

// validate cookie creation, expiry, session persistence, and logout behavior.

Cache Testing

// test how the browser caches assets and what happens when cache is stale or invalid.

Cross-Browser Bugs

// common rendering and behavior bugs that only appear in specific browsers.

Network Handling in Web Apps

// test offline behavior, slow networks, timeouts, and failed api responses in web apps.

Web Performance Basics

// page load time, render-blocking resources, and basic performance testing for web.

SEO Testing Basics

// meta tags, canonical urls, sitemaps, and what testers should verify for seo.

Accessibility Basics

// wcag principles, keyboard navigation, screen readers, and contrast testing basics.

Browser DevTools for Testers

// master the 5 devtools panels — elements, console, network, application, and lighthouse — for daily testing work.

What is Mobile App Testing?

// unique challenges of mobile testing vs web testing.

Android vs iOS Testing Differences

// platform-specific behaviors, gestures, and testing considerations.

Types of Mobile Apps: Native, Hybrid, Web

// how app type affects what and how you test.

Installation & Update Testing

// fresh install, update from old version, uninstall — common bugs to check.

Interruption Testing

// calls, sms, low battery, push notifications — how the app handles interruptions.

Network Condition Testing

// test on 2g, 3g, 4g, wi-fi, and offline — using throttling and airplane mode.

Device Fragmentation Testing

// how to test across hundreds of screen sizes, os versions, and manufacturers.

Permissions Testing

// camera, location, contacts, notifications — grant/deny and verify behavior.

Battery & Memory Usage Testing

// profile cpu, ram, and battery drain during normal and heavy app usage.

Gesture & Touch Testing

// swipe, pinch, tap, long press — testing touch interactions correctly.

Usability Testing for Mobile

// screen size constraints, thumb zones, readability — mobile ux testing.

Mobile Automation Overview (Appium)

// introduction to appium — automating android and ios app tests.

Mobile Testing Checklist

// complete checklist for mobile app releases across ios and android.

Manual vs Automated API Testing

// when to automate api tests and what you gain vs manual testing.

Postman Scripts & Pre-request Hooks

// write javascript in postman to automate token extraction, variable setting, and pre-steps.

Postman Collections & Test Scripts

// organise requests into collections and write pm.test() assertions.

Running Postman with Newman (CLI)

// run postman collections from the terminal and integrate into ci/cd.

Newman in GitHub Actions

// automate api test runs on every push or pr using newman in ci.

API Testing with Jest + Supertest

// write api tests in javascript using jest and supertest for node.js apps.

Schema Validation

// use json schema or zod to validate api response structure programmatically.

Auth Token Handling in Automation

// login once, reuse the token — patterns for authenticated automated api tests.

Data-Driven API Testing

// run the same test with multiple data sets using csv, json, or parameterization.

Environment Variables & Config Management

// manage dev/staging/prod configs without hardcoding values into tests.

Contract Testing Basics (Pact)

// verify that api consumers and providers agree on the contract — intro to pact.

API Automation Checklist

// what to cover in a mature api automation suite — coverage, speed, reliability.

What is Database Testing?

// why testers need to verify data — not just the ui.

Data Integrity Testing

// validate that data is accurate, consistent, and not corrupted.

CRUD Testing in the Database

// verify create, read, update, delete operations at the database level.

Testing Stored Procedures & Triggers

// how to test database logic that runs automatically.

Database Migration Testing

// verify schema changes and data migrations run safely without data loss.

SQL Basics for Testers

// select, where, join, count — the sql every qa engineer must know.

Testing with Seed & Fixture Data

// set up repeatable test data in the database for consistent test results.

Database Performance Testing

// slow queries, index usage, and connection pool limits — how to find them.

NoSQL Database Testing

// testing mongodb, firebase, and dynamodb — differences from sql testing.

Database Security Testing

// sql injection, excessive privileges, and unencrypted sensitive data.

What is Compatibility Testing?

// ensuring software works across environments — browsers, os, devices, networks.

Browser Compatibility

// chrome, firefox, safari, edge — differences that break your ui.

OS Compatibility Testing

// windows, macos, linux, ios, android — os-specific behaviors to test.

Screen Resolution & Display Testing

// how apps render at different resolutions and pixel densities.

Network Compatibility Testing

// testing behind proxies, firewalls, vpns, and on restricted networks.

Backward & Forward Compatibility

// does the new version still support old data and old clients?

Hardware Compatibility Testing

// printers, scanners, keyboards, peripherals — embedded and iot devices.

Compatibility Testing Tools

// browserstack, sauce labs, lambdatest — cloud-based compatibility testing.

What is Usability Testing?

// testing whether users can use the product effectively, efficiently, and with satisfaction.

Heuristic Evaluation

// evaluate ui against nielsen's 10 usability heuristics.

User Research Methods for Testers

// usability labs, think-aloud testing, surveys, and a/b testing basics.

What is Accessibility Testing?

// why accessibility matters legally, ethically, and practically.

WCAG 2.1 — The Standard Explained

// perceivable, operable, understandable, robust — the four wcag principles.

Keyboard Navigation Testing

// tab order, focus indicators, and keyboard-only user flows.

Screen Reader Testing

// nvda, jaws, voiceover — how to test with and for screen reader users.

Colour Contrast & Visual Accessibility

// contrast ratios, colour-blind safe palettes, and zoom/text resize testing.

Accessibility Testing Tools

// axe, lighthouse, wave — automated and manual accessibility test tools.

Writing Accessibility Bug Reports

// how to document accessibility defects clearly for developers to fix.

What is Bug Triage?

// the process of evaluating, prioritising, and routing defects to the right person.

How to Run a Triage Meeting

// roles, agenda, outputs, and common anti-patterns in triage meetings.

Go / No-Go Decision Making

// how qa leads make the call to release or hold — criteria and frameworks.

Release Readiness Checklist

// what must be true before any software ships — the full readiness checklist.

Hotfix Testing Process

// testing under pressure — how to verify emergency fixes quickly and safely.

Regression Strategy for Releases

// what to retest before each release and how to decide scope.

Managing Known Issues & Workarounds

// document accepted risks, known bugs, and workarounds for release notes.

Post-Release Monitoring & Validation

// what to watch after deploy — error rates, logs, support tickets.

Who Joins Bug Triage

// roles in a triage meeting — dev, qa, pm, and why each voice matters.

Severity vs Priority in Triage

// how severity and priority are used to make triage decisions.

Duplicate, Invalid, Won't Fix, Deferred

// the four common triage outcomes and when to use each one.

Triage Meeting Flow

// a practical step-by-step flow for running an effective triage meeting.

Release Readiness

// what defines a release-ready build and who decides it.

Go / No-Go Decision

// how qa leads make the final call to ship or hold a release.

Regression Scope Before Release

// how to decide what to retest and what to skip before each release.

Hotfix vs Patch vs Major Release

// the three release types and how testing scope differs for each.

Release Checklist

// a complete pre-release checklist every qa team should run through.

How QA Interviews Work

// the typical qa interview structure — rounds, formats, and what interviewers look for.

Most Asked QA Interview Questions

// top 30 questions with model answers — testing fundamentals, defects, and planning.

API Testing Interview Questions

// common api testing questions and how to answer them confidently.

Automation Interview Questions

// playwright, selenium, pom, flaky tests — questions and answers.

Behavioural Questions for QA

// star method answers for "tell me about a time..." questions.

Live Testing Exercises

// practise the test-this-now tasks interviewers give — with model answers.

Resume Tips for QA Engineers

// how to write a qa resume that gets past ats and impresses hiring managers.

Building Your QA Portfolio

// side projects, github repos, and test reports to show employers.

Salary Negotiation for QA Roles

// market rates, negotiation tactics, and how to evaluate offers.

Practice Project Overview

// an overview of the real-world projects used in this module.

Project 1: E-commerce Checkout Flow

// write test cases, find bugs, and create a test report for a live checkout flow.

Project 2: REST API Testing

// test a public api end-to-end — postman collection, assertions, and automation.

Project 3: Mobile App Walkthrough

// test a real android/ios app for functionality, usability, and performance.

Project 4: Automation with Playwright

// build a small playwright automation suite from scratch with pom and ci/cd.

How to Write a Test Report

// document your project results professionally — format, metrics, and summary.

What is Testing in Production?

// shift-right testing — why and how teams test safely in live environments.

Feature Flags for Safe Releases

// deploy code but control who sees it — testing behind feature flags.

Canary Releases & Blue-Green Deployments

// gradual rollouts and instant rollbacks — strategies for safe production testing.

Observability: Logs, Metrics & Traces

// the three pillars of observability and how testers use them.

Synthetic Monitoring

// simulated user journeys that run continuously in production.

Chaos Engineering Basics

// intentionally break things to find weaknesses before users do.

Alerting & On-Call for QA

// how qa engineers participate in incident response and on-call rotations.

How AI is Changing QA

// the current state of ai in testing — what is real and what is hype.

AI-Assisted Test Case Generation

// use llms to generate test cases from requirements and user stories.

Prompt Engineering for Testers

// how to write prompts that produce useful test cases, bug reports, and scripts.

AI Testing Tools Overview

// testim, mabl, applitools, functionize — what ai-powered tools actually do.

Visual AI Testing

// pixel-diff and ai-based visual regression testing with applitools.

Self-Healing Automation

// how ai repairs broken locators automatically to reduce test maintenance.

AI for API Test Generation

// generate postman collections and automation scripts from openapi specs using ai.

Limitations & Risks of AI in Testing

// hallucinations, false coverage, over-reliance — what ai cannot replace.