Software Testing

Beginner path · lesson 2 of 35

BeginnerFundamentals5 min readPublished November 12, 2026

The 7 principles of software testing, explained simply

Seven short ideas that explain why testing works the way it does, from 'you can't test everything' to 'bug-free isn't the same as useful'. They're in every ISTQB Foundation exam and in many junior interviews.

On this page

Key takeaways

  • The ISTQB Foundation syllabus lists seven principles of testing. They're less rules than truths about how testing works, and they explain most of the decisions testers make.
  • The big three for beginners: you can't prove there are no bugs, you can't test everything, and the earlier you test, the cheaper it is.
  • Interviewers ask about them often. Don't recite them: explain each with an example from an app you know.

Why principles?

Testing can feel like a list of techniques. The principles explain the why behind them: why testers pick some tests and skip others, why they want to be involved early, and why "we found no bugs" isn't the end of the story.

The list below follows the current ISTQB Certified Tester Foundation Level syllabus (version 4.0).

1. Testing shows the presence of defects, not their absence

A test that fails proves a bug exists. A test that passes proves only that this case worked.

No amount of passing tests proves the software is bug-free. Testing lowers the risk of undiscovered bugs; it can't make it zero.

In practice: say "we found no bugs in the areas we tested", not "there are no bugs".

2. Exhaustive testing is impossible

Take a simple form with one text field that accepts up to 20 characters. Counting only letters and digits, the number of possible inputs has more than 30 digits. Add more fields, browsers and devices, and testing everything becomes impossible.

So testers choose. Techniques like equivalence partitioning and boundary value analysis pick a few inputs that represent many. Risk decides where to look hardest.

3. Early testing saves time and money

A mistake caught in a requirement costs minutes to fix. The same mistake found in production can cost days, money and customers.

That's why testers review requirements and designs, and ask questions before code exists. This is often called shift left.

4. Defects cluster together

Bugs aren't spread evenly. A small number of modules usually holds most of the defects: the complex ones, the recently changed ones, the ones touched by many people.

In practice: when you find several bugs in one area, look harder there, not less. And use bug history to decide where to test first.

5. Tests wear out

If you run the same tests again and again, they eventually stop finding new bugs. The code they cover gets fixed, and new bugs appear in places they don't look.

Older versions of the syllabus called this the pesticide paradox: insects become resistant to a pesticide used too often.

In practice: review and refresh your tests. Add new cases, vary the data, and mix in exploratory testing. Tests that stay unchanged are still useful for catching regressions, just not for finding new bugs.

6. Testing is context dependent

There's no single right way to test. A medical device, a mobile game and a bank's payment system need very different testing: different risks, rules, depth and documentation.

In practice: before deciding how to test, ask what the product is, who uses it, and what happens if it fails.

7. The absence-of-defects fallacy

Software can be technically flawless and still fail. If it solves the wrong problem, or is too confusing to use, finding and fixing all the bugs won't save it.

That's why testing includes validation: checking the product meets users' real needs, not just the specification. See verification vs validation.

Real-world exampleThe bug-free app nobody used

A team built an internal app for warehouse staff to record deliveries. Testing was thorough: hundreds of test cases, all bugs fixed, every requirement checked.

In the first week, almost nobody used it. Staff wore thick gloves, worked in poor light and needed to record deliveries with one hand while holding a scanner. The app had small buttons, light grey text and a five-step form.

The specification had never mentioned gloves or lighting. Nobody had tested the app where and how it would really be used.

Lesson: several principles at once. Testing is context dependent (6); a defect-free app that doesn't fit users' needs still fails (7); and asking about real working conditions during requirements review (3) would have been far cheaper than a redesign.

All seven on one page

#PrincipleIn one sentence
1Testing shows presence of defectsPassing tests don't prove there are no bugs.
2Exhaustive testing is impossibleChoose tests by technique and risk.
3Early testing saves time and moneyTest requirements and designs, not just code.
4Defects cluster togetherLook harder where bugs have already been found.
5Tests wear outRefresh tests so they keep finding new bugs.
6Testing is context dependentTest a game differently from a pacemaker.
7Absence-of-defects fallacyBug-free but useless is still a failure.

Do

In an interview: "Exhaustive testing is impossible. For example, a date field has thousands of valid values, so I'd use boundary values like the first and last day of a month, plus a leap day, instead of testing them all."

Don't

Recite the seven names from memory without showing you understand what they mean for your daily work.

Check yourself

Your team has run the same 300 automated regression tests for two years. They all pass every time, but customers keep reporting new bugs. Which principle explains this, and what would you do?

Show answer

Tests wear out (principle 5), with a nod to principle 1: passing tests don't prove there are no bugs. The suite still protects against regressions, so keep it. But add new tests where the customer bugs appear (they likely cluster, principle 4), vary the test data, and spend time on exploratory testing of new and changed features.