AI in Testing: The Focus Shifts from Writing to Testing
AI in testing writes tests, explores apps and generates test data. It also becomes a test object itself, from chatbots to RAG search.
Testing Fundamentals & Test Design
Software testing creates transparency about whether a system meets business expectations and behaves reliably under realistic conditions. This topic connects testing fundamentals with systematic test design, from objectives, levels, and techniques to reviews, exploratory testing, and traceable test cases.
The articles, podcast episodes, and foundation pages show how teams translate risks into useful test ideas, select appropriate techniques, and communicate results clearly. They support people who are entering testing, refining an established approach, or building a shared vocabulary across a team. The focus is not on producing the largest possible number of tests, but on generating relevant information for better quality decisions.
Foundations
Articles
AI and Learning: What We Lose When We Only Take the Output
AI delivers results fast, and the learning process passes us by. Testers grow through questions, debugging and system knowledge, not generated tests.
Testability: Why Software Architecture Must Keep Evolving
Software architecture is a cornerstone of testability and has to keep evolving. That works best when testers and architects talk, ideally over coffee.
Requirements Engineering: Every Test Case Design Is a Review
Requirements engineering decides how good testing can be. Test case design exposes gaps, and traceability shows which tests a change affects.
SAP Testing: Why Business Processes Set the Strategy
SAP testing starts with business processes and risk. PRACTICES UP covers eleven focus areas, and five data classes structure the test data.
AI for Testers: Why Good Testers Won't Be Replaced
AI for testers helps with analysis, test cases, bug hunting and test data. Weak testers may lose out, good ones build AI into the way they work.
Scenario-Based Testing and the Future of Software Testing
Scenario-based testing is emerging because autonomous vehicles and robots must be tested in dynamic environments, not on a lab bench.
Data Warehouse Testing: Assertions from Transformation Rules
Data warehouse testing needs more than plausibility checks. Assertions generated automatically from transformation rules make results checking reliable.
Automated Test Design: Higher Automation Levels Cut Costs
Automated test design spans five levels, from capture & replay to model-based. Higher levels pay off when frequent changes drive up maintenance.
Living Software Quality as an Attitude: Four Milestones
Software quality becomes a team attitude in stages: from testing basics via reflection and experiments to a culture where testing is part of the work.
AI Evaluation Metrics: Why Pass or Fail Falls Short
AI evaluation metrics like precision, recall, and the F1 score judge a model across many test cases. Evaluating AI also covers its training data.
Test Dimensions for Integration Testing: Identifying Gaps
Test dimensions structure integration testing: objectives, test objects, level, test basis and typical errors. Mapping them reveals the gaps.
Agile Testing Quadrants: How Testing Changes in Agile Teams
The agile testing quadrants by Gregory and Crispin put all test types in one picture. With test pyramid and exploratory testing, the team owns quality.
Automation in Testing: From a Nice-to-Have to a Must-Have
Automation in testing is now a must-have. It reaches well beyond test execution to static analysis, test data, environments and non-functional tests.
Static Analysis: Finding Security Flaws Before Testing
Static analysis security testing finds many flaws in Java code before dynamic testing starts. In one study it took 2 person-months, dynamic testing 12.
Analytical Quality Assurance: Testing and Measuring Artifacts
Improve your software quality with analytical quality assurance, efficiently measuring software artifacts to detect issues early.
Be Good, Get Better: Customer View and Creative Test Methods
Software testing is an established profession, yet testers get better by seeing the app through the customer's eyes and using test methods creatively.
Testing Cloud Services: Static Analysis and Dynamic Analysis
Testing cloud services takes two phases: static analysis checks requirements against the interface spec, dynamic analysis validates real responses.
Migration Testing: Proving the New System Matches the Old
With no specification, migration testing compares the new system with the old one. Seven steps, from code measurement to coverage, prove both match.
Test Estimation: Test Points, Test Cases, and COCOMO-II
Test estimation from requirements: count test points and test cases, factor in testability and productivity, then feed a modified COCOMO-II formula.
Requirements Testing: Why Testers Should Review Specs Early
Requirements testing brings testers in early to find incomplete and incorrect requirements in the specification, before they turn into costly defects.
Test Center: Centralizing Test Activities Within the Company
A test center bundles scattered testing work in one internal or external unit. Four success factors: competence, staff, infrastructure and integration.
Web Service Testing: Generate Requests, Verify Responses
Web service testing with WSDLTest: test data comes from the WSDL schema, pre-conditions shape requests, and post-conditions check responses.
Podcast Episodes
Kubernetes Load Testing: Start with a Risk Question
CPU and RAM are rarely the bottleneck in Kubernetes load testing, caching or an external login more often. A test pays off once a decision follows.
Quality Hunting: Testing for Information Instead of Bugs
In quality hunting, teams of about four people explore a system for half a day and report what stakeholders need to know about its quality.
Hardware-in-the-Loop Testing: Kernels on Real CPUs
A kernel has to run on every CPU generation, so hardware-in-the-loop testing puts it on real devices. Developers and CI reserve clean machines.
Mutation Coverage: Why Green Tests Can Still Be Worthless
Mutation coverage measures how many deliberately planted bugs your tests catch. It says more than code coverage, especially when AI agents write tests.
How to Build Rules and Skills So That Agents Can Remember
AI coding agents need fewer manual reviews once you work on the system itself: rules, hooks and retro skills make their corrections stick for good.
AI in Software Testing Raises the Value of Expert Testers
AI in software testing leaves a faulty fraction: hallucinated requirements, invented test cases. Business knowledge keeps expert testers in demand.
Performance Monitoring: Set a 70% CPU Alert Before Failure
Performance monitoring catches slowdowns users abandon after five seconds. Alerts, AI log analysis and a small replica find the exact query at fault.
Branch Coverage: Full Coverage Still Lets Bugs Through
Even 100% branch coverage let an off-by-one bug slip through. Coverage is only as good as its assertions, and loops need several iterations.
End-to-End Test Automation Without the Maintenance Trap
End-to-end test automation stays maintainable with a dedicated HTML test attribute, a central mapper, a three-layer framework and one naming convention.
LLM Testing: A Second Model Acts as the Judge
LLM testing can be automated if you accept non-determinism: rubrics and acceptance ranges replace yes/no asserts, and a calibrated LLM judges outputs.
API Testing: Agent-Optimized Design Cuts Token Costs
API testing depends on the protocol: REST, GraphQL, webhooks or MCP. It runs more stably than browser testing, and agent-friendly APIs save tokens.
LLMs in Software Testing: Start with Small, Bounded Tasks
LLMs in software testing pay off where language is the raw material: keyword docs, rule-based reviews, defect messages. Reasoning models review better.
Children's Book About Testing That Inspired a Future Tester
A children's book explains software testing through dragons and knights, and a 12-year-old at a book fair said she wants it as her profession.
Chatbot Testing: Why Bugs Hide in Prompts and Retrieval
Chatbot testing has to look past the final answer into chunks, embeddings, prompts and fallback logic. How traceability makes these hidden bugs fixable.
AI-Assisted Testing: Testers Keep Control of the Process
AI-assisted testing turns a month of test case and test data work into about a week, and plain-language automation widens who can build tests.
IEC 62443-4-1: A Toolbox for the Cyber Resilience Act
IEC 62443-4-1 builds security into the process from the first design step and covers much of what the Cyber Resilience Act will require from 2027.
Becoming a Test Automation Engineer: Treat Tests Like Code
From developer to test automation engineer: Why clean code principles decide which automation lasts for years and which doesn't.
Empowering Women in Software Testing
Women still navigate assumptions in tech that men rarely face. Here is what assertive-but-kind communication actually looks like in a testing team.
How Stiftung Warentest Keeps Its Product Tests Objective
Stiftung Warentest buys products undercover, runs blind tests with reference devices and double-checks every measurement. Testers can borrow a lot.
QS Barcamp Hamburg: Why Attendance Stays Capped at 80
The QS Barcamp Hamburg caps attendance at 80 and has no fixed agenda, yet the talks go deep. Participants pitch their own sessions at the marketplace.
Structured Exploratory Testing Strategies That Work
Exploratory testing is not just clicking around randomly. Here is how scoping, timeboxing, and risk focus turn it into a sharp quality tool.
Formal Methods: Why Is Functional Programming Helpful?
Formal methods sound like an ivory tower, but they provide what testing alone can never do: mathematical proof of correct behavior.
AI-Generated Test Cases: Compliant Without Tool Validation
AI-generated test cases for medical devices: a RAG system retrieves in-house documents, a human reviews the results, so no tool validation is needed.
Test Coverage: Process Mining Shows What Really Runs
Test coverage needs the right denominator. Process mining shows which workflows run in production, and the top 10 of 600 runs cover about 80 percent.
Quality Metrics: Why Every KPI Needs a Counter Metric
Quality metrics mislead when they stand alone. Pair mean time to resolve with reopen rate, pass rate with escaped defects, and keep the set small.
AI Test Assistant: Test Cases Compliant with ISO 29119
An AI test assistant generates ISO 29119 test cases for business teams without testing know-how. Munich's Sherlock exports them to TestLink or Xray.
Ensemble (Mob) Testing: Test Expertise Grows in the Dev Team
Two years of exploratory ensemble testing in a real project: What the method brings, where it gets stuck and why testing is suddenly fun.
Consumer-Driven Contract Testing: Consumers Define the API
Consumer-driven contract testing with Pact checks what an API sends and what its consumers expect. If a contract breaks, the build fails before release.
Performance Testing vs. Load Testing: Not the Same Thing
Performance testing vs. load testing: capacity tests every sprint waste cloud budget. The real question is how a system behaves and what it costs.
Dynamic Analysis: Embedded Coverage on Real Hardware
Dynamic analysis on real hardware: embedded trace measures code coverage in integration testing without the timing side effects of instrumentation.
Software Testing as Art and Science: Logic and Empathy
Software testing needs logic and imagination alike. What da Vinci's curiosity and love of simplicity teach testers about reports people understand.
Software Testing with Java: JUnit, WireMock, and Selenium
Software testing with Java follows the test pyramid, from unit tests in milliseconds to UI tests that take minutes. Maven controls what runs when.
What Are the Benefits of ASQF Membership in Software Testing?
ASQF membership brings free conference tickets, specialist groups and a say in new certifications. The association has united quality people since 1996.
Testing Collaboration: Business and Testers Share One Model
Testing collaboration improves when business, testers and developers build one model: a single workshop yields better requirements and ready test cases.
Software Testing Value: Frame Quality in Business Terms
Software testing value gets lost when testers pitch defects. Revenue and user satisfaction make a stronger case, and domain knowledge matters more.
Accessible PDFs: Let People with Disabilities Test Them
Accessible PDFs need clean headings, alt text and labeled tables. For contracts, invoices and archives, converting old files is a migration project.
Tester Influence: Frame Bugs by Business Impact
Tester influence is influence without authority: frame each finding for its audience. A 15-second check at standup does more than a big program.
Test Design Board Game: Finding the Tricky Checkout Cases
A test design board game built for checkout software produces around 24 new test cases per round, including tricky promotions, for the next release.
Natural Intelligence Tested: Humans Evaluate AI
Natural intelligence finds bugs no AI would look for, through curiosity, intuition and context. AI unit tests often hit just one equivalence partition.
Quality as an Attitude: Making Testing a Team Habit
Quality as an attitude beats test case checklists. Good testing needs solid methods, automation and trust in the people who vouch for the results.
Changing Careers to Testing: An Internship Beats Certifications
Changing careers to testing works without an IT background, as one path from the French embassy shows. An internship counts for more than certificates.
Test Case Prioritization with a Multidimensional Risk Score
Test case prioritization without gut feeling: five levels, Fibonacci ratings and one risk score decide which test cases run first under time pressure.
When Property-Based Testing Pays Off, and When It Doesn't
Property-based testing generates test cases from a specification and found a 17-step LevelDB bug. It gets costly when every test run is billed.
AI Code Remediation: Two Thirds of the Fixes Work
AI code remediation fixes about two thirds of static analysis findings well. The rest is faulty, and models almost never admit they don't know.
Swiss Testing Board: Measurable Learning Goals for ISTQB
The Swiss Testing Board grew from an SAQ working group and brought measurable learning objectives based on Bloom's taxonomy into the ISTQB syllabi.
Playwright vs Cypress vs WebdriverIO: A Clear Verdict
Playwright vs Cypress vs WebdriverIO on four criteria: why Playwright wins new projects, where WebdriverIO trails, and when a switch isn't worth it.
Custom Fuzz Testing: Random Data That Knows the Format
Custom fuzz testing pairs random inputs with knowledge of the format. Why a random IBAN rarely passes the checksum, and where LLMs fall short.
Choosing Test Case Design Techniques: About Ten Are Enough
Most testers know test case design techniques but rarely use them. Four groups, five techniques, and the right selection logic change that.
AI Code Generation: More Legacy Code, Produced Faster
AI code generation pushed up code churn and duplicates on GitHub by early 2024. Testing, precise questions and fundamentals set developers apart.
Test Oracle: Rebuilding the Software for Target Values
A reference implementation as test oracle computes target values for 2,500 signals automatically. The ISO 26262 review then becomes a code review.
Lightweight Test Plan: Short Modules Replace the Test Manual
A lightweight test plan does not end up in a drawer. The Federal Office of Administration built one from short modules and released it as open source.
Robot Framework: Keyword-Driven Testing for Any Technology
End-to-end across web, desktop, database and 3270 hosts: where Robot Framework earns its place, where web-only tools stop, and why it won't die soon.
Microservices Testing at REWE: Fewer End-to-End Tests
Microservices testing at REWE: unit and API tests per service, few end-to-end tests on the money path, flaky tests in quarantine, production monitoring.
What Informal Networks Mean for How Your Company Works
Informal networks are who people actually turn to when things go wrong. Why they decide how fast teams adapt, and why you cannot order them into being.
UI Testing with Mocks: Test the Frontend Without a Backend
UI testing with mocked API responses checks the frontend as a full app, no backend needed. At Volkswagen, 280 tests run in under three minutes.
AI Test Description: Test Cases Structured Like Code
An AI test description makes AI systems testable: five capabilities and quality criteria like correctness and bias turn standards into concrete tests.
AI-Supported Test Design: Method Knowledge Still Matters
AI-supported test design delivers equivalence partitions and boundary values in minutes, about 80 percent correct. Catching errors takes method skills.
Is Mutation Testing Worth the Runtime? Where It Pays Off
Every mutant reruns your test suite, and that gets slow fast. How incremental analysis in PIT and a focus on core logic make mutation testing pay off.
How to Pick a Test Design Technique Without Learning 30
25 to 30 test design techniques exist, yet about ten from four groups cover most cases in practice. How to pick one by problem type, risk and skills.
Test Infrastructure: Real Combi Steamers, Tested Every Night
RATIONAL's test infrastructure runs around 2,000 system tests every night on real combi steamers, driven by a Python framework and relay modules.
Model-Based Test Case Design: First Abstract, Then Concrete
Model-based test case design often breaks down between model and concrete test. Two phases fix that: high-level tests first, data and scripts later.
Where Formal Methods Get Used, and What a Proof Costs
Type systems, Windows drivers, payments, the seL4 kernel: where formal methods run in practice, and why a proof can cost ten lines per line of code.
Testing Data Processes: Expected Results from the Specification
Testing data processes works best with expected results generated from the business specification, since production data covers only about 70% of cases.
Business Analysts and Testers: Spotting Edge Cases Early
A business analyst who thinks like a tester spots edge cases before any code exists. A data warehouse project shows why testers should question specs.
Testing in German-Speaking Countries: How Agile Are Teams?
Testing in German-speaking countries has been surveyed every few years since 2011. Agile projects now dominate, while classic techniques lose ground.
Hybrid App Testing at ZDF: Manual First, Then Automation
Hybrid app testing at ZDF: 70 to 80% automation, and 90% of failed tests are real bugs. Manual and exploratory testing still catch what scripts miss.
Testing AI Systems: Determinism Decides the Test Strategy
Testing AI systems often boils down to one question: does the system behave deterministically? The answer decides whether classic methods suffice.
ATDD for LLMs: Failed Dialogs as Tests and Training Data
With ATDD for LLMs, each new requirement becomes a dialog-based test. After fine-tuning, the suite shows whether the model learned without regressions.
Stoicism for Product Teams: Don't Confuse Luck with Judgment
Stoicism helps product teams judge a decision by how it was made, not how it turned out. Its tools: premeditatio malorum, 10-10-10, a decision diary.
Test Pyramid: How Test Layers Should Complement Each Other
The test pyramid is often misread: many unit tests, high coverage, still bugs. Why many JUnit tests in microservices are really integration tests.
Shift Left in Acceptance Testing: Build Trust Early
Shift left in acceptance testing means testers shape requirements early. Acceptance tests then build trust instead of hunting bugs just before delivery.
Software Expert Witness: State of the Art Means Proven
A software expert witness checks whether software is state of the art, a legal term meaning proven, and judges its maturity by defect density.
Choosing an E2E Testing Framework: Requirements First
Choosing an E2E testing framework starts with your own requirements, such as Safari support or speed. Why Playwright led a comparison of five tools.
Exploration and AI: Human Context Can't Be Replaced
AI speeds up routine work, but exploration needs human context it lacks. Quality stays hard to sell, so testers should pair with developers and network.
ChatGPT in Software Testing: Strong in Exploratory Testing
Using ChatGPT for test cases, test data and exploratory ideas: What really works, where caution is advised and why prompting matters.
Tests from Rules: Generated Cases for Distributed Systems
Tests from rules replace hand-written cases: describe a system property once and a tool generates thousands. A shrinker traces failures to the cause.
User Story Testing: Make Stories Testable with Examples
User story testing starts with acceptance criteria written as concrete examples. Add specs only where they help, and use the light Three Xs strategy.
Accessibility in Apps: Why Do We Perform Manual Testing?
Mobile accessibility testing is mostly manual: VoiceOver, TalkBack and switch control can block each other, so the test matrix has to log every setting.
Quality Assurance in College: A Topic Throughout All Semesters
Quality assurance can't be one compulsory lecture. Measurement, resource limits and sustainability belong in every semester of a degree.
Classic Test Techniques: Agile Teams Still Need Them
Classic test techniques such as decision tables still apply in agile projects. So why does quality suffer when twelve teams work side by side?
Quality Assurance at Otto: Life Without a Testing Team
Quality assurance at Otto works without a testing team. 15 quality specialists coach 60 teams, helped by Quality Buddies and consumer-driven contracts.
Automotive Testing: Standards Prescribe Testing Methods
In automotive testing, even a windshield wiper is safety-critical. Automotive SPICE and functional safety prescribe boundary value analysis and MC/DC.
Coaching Lessons for Testers: Clarify the Assignment First
Software testing starts with clarifying the assignment, or errors surface late and get expensive. One of several lessons testers can take from coaching.
Software Testing: Pay Based on Performance Rather Than Time
Software testing paid by test cases, coverage and errors found: how Europe's first independent test lab worked in 1978 and which principles still hold.
Liberating Structures: Get Every Voice into the Test Meeting
Liberating Structures like 1-2-4-All, Troika Consulting and TRIZ end meetings where everyone nods at the boss. Testers use them to uncover risks.
Model-Based Testing Without UML: Flowcharts Are Enough
Model-based testing doesn't need UML: boxes, arrows and a flowchart uncover requirement gaps early and generate manual and automated test cases.
Test Intelligence: Finding More Bugs in Less Time
Test intelligence finds 80% of errors in 1% of the runtime with test impact analysis, and test gap analysis shows untested changes before release.
Sociable Unit Testing: Testing Use Cases All the Way to the Database
Why do teams write hundreds of unit tests, yet the software still doesn't run? Because isolated tests alone don't prove that a feature works.
Gamification in Software Testing: Gaming Reveals Edge Cases
Gamification makes manual testing fun and keeps risk analyses out of the drawer. Riskstorming, Bingo Bongo and Maturity Poker reveal edge cases.
Systematic Testing: Exit Criteria Indicate When It’s Enough
Systematic testing picks risky and everyday inputs, and exit criteria show when you have tested enough. Complete testing is mathematically impossible.
User Feedback at MOIA: When Colleagues Are the Users
How MOIA collects user feedback from its own drivers: monthly surveys, mockup interviews, test drives and slow rollouts to 20% of the fleet.
Shift Left: Quality Starts with the User Story
The shift left approach builds quality in early: vertically sliced user stories, feedback in the IDE, solid unit tests and contract testing with PACT.
Cypress Component Testing: Stable Tests in a Real Browser
Cypress component testing runs in a real browser, so tests are more stable than with Jest's emulation. How it rights the test pyramid, and its limits.
Speech Recognition Testing: Every Fix Means Retraining
Speech recognition testing means testing a black box: every fix costs days of retraining. Golden test sets and generated variations find errors early.
Prompt Engineering for Test Cases: Review Remains Mandatory
Prompt engineering for test cases gets better results with few-shot examples and embedded specs. Still, two of eleven generated tests remained wrong.
Software Testers and AI: Routine Goes, Judgment Stays
Software testers and AI: routine checks move to AI, while judging requirements coverage stays a human task. A carpenter explains his path into testing.
Test Case Selection: Only Run the Tests a Change Touches
6.5 hours of test runtime, reduced to 10-15 minutes: How test case selection across C++ and Java makes it possible.
Game Testing at Tibia: Exploratory Testing Before Checklists
Game testing for Tibia means weekly patches for a 25-year-old game with 500,000 players. Exploratory testing and big external tests keep it stable.
ISTQB: President Wants to Review Curricula Every Five Years
The ISTQB runs almost entirely on volunteers across 68 member boards. Its president wants every syllabus, CTFL 4.0 included, revised within five years.
Selenium Automation Testing: A Browser Tool First
In Selenium automation testing, Selenium only drives the browser. Good selectors, page objects and the vendor drivers in Selenium 4 keep tests stable.
Software Reviews: Finding Bugs Before They Become Costly
A software inspection finds errors early, before fixing them costs ten times more with each phase. Perspective-based reading helps, bosses don't.
Agile Quality Assurance: Talking Comes Before Coding
Agile quality assurance starts in the conversation about requirements, long before acceptance testing. Leaving tests out is fine if the risk is known.
Whole-Team Quality: The Three Factors Good Teams Share
Quality as an attitude makes quality the whole team's job. Good test cases, static analysis as a hard gate and test automation back it up.