Waterfall, Agile, the V-model, the test pyramid and exploratory testing aren't the same kind of thing. A clear map of testing methodologies and how to choose between them.
Ask ten teams for their software testing methodology and you'll hear "Agile," "the test pyramid," "we're risk-based," "mostly automated" and "V-model, because we're regulated." Every answer is reasonable. They just aren't answers to the same question.
Most guides list these side by side as if you pick one. That's where confusion starts. A team says "we're Agile, so we don't need a test strategy," or "we have a pyramid, so we're covered." It helps to separate four questions, each with its own set of answers.
Four Questions, Four Kinds of Answer
Question | What answers it | Examples |
|---|---|---|
How is development organized? | Lifecycle model | Waterfall, V-model, iterative and Agile (Scrum, Kanban) |
Where do we invest testing effort? | Test strategy model | Test pyramid, testing honeycomb, Agile testing quadrants |
How do we decide what to test and how? | Test approach | Risk-based, scripted, exploratory, context-driven |
What qualities are we evaluating? | Test types | Functional, and non-functional such as performance, security, usability |
Your team has an answer to all four, whether or not anyone wrote it down. Most teams choose the lifecycle model at the organization level. The other three are where testers and quality leaders have real choices to make.
Lifecycle Models: The Context Testing Lives In
Waterfall runs phases in sequence: requirements, design, build, test, deploy. It's often credited to Winston Royce's 1970 paper. Royce's paper actually described the purely sequential version as "risky and invites failure" and argued for iteration and feedback between steps, and it never used the word "waterfall." For testing, the lesson holds: when testing waits until the end, defects are found when they cost the most to fix.
The V-model pairs each development phase with a test level: requirements with acceptance testing, architecture with integration testing, detailed design with component testing. It makes the difference between verification ("are we building it right?") and validation ("are we building the right thing?") explicit. Regulated industries still use it because it produces clear traceability.
Iterative and Agile approaches, delivered through frameworks such as Scrum and Kanban, build in small increments with frequent feedback. Testing becomes continuous, and testers work inside the team rather than at a hand-off point. Agile is a way of organizing work, not a testing method. An Agile team still needs a test strategy and a test approach.
Test Strategy Models: Where to Put the Effort
These models describe how to spread testing across levels. They're heuristics, not laws.
The test pyramid, introduced by Mike Cohn in Succeeding with Agile, recommends many fast, low-level tests (unit), fewer service or integration tests, and a small number of end-to-end UI tests. Ham Vocke's "The Practical Test Pyramid" on Martin Fowler's site gives the two rules I find most useful: push tests as far down the pyramid as you can, and when a higher-level test catches a bug no lower test caught, add a lower-level test.
The testing honeycomb, described by Spotify engineers in 2018, fits microservices better. It puts integration tests, which check one service in isolation through its real interfaces, at the center. It keeps fewer "implementation detail" tests and tries to avoid "integrated" tests, whose result depends on the correctness of another system.
The Agile testing quadrants, from Brian Marick in 2003, sort tests by two questions. Are they business-facing or technology-facing? Do they guide development or critique the product? They're a useful reminder that exploratory and usability testing (business-facing critique) belong in the plan alongside unit tests.
Pick the shape that matches your architecture and risk, not the one in the most popular diagram.
Test Approaches: How Decisions Get Made
This is the layer most methodology articles skip. It's the one that most affects whether testing finds important problems.
- Risk-based testing sets depth and priority by the likelihood and impact of failure. ISTQB's principle that exhaustive testing is impossible makes some form of this unavoidable.
- Scripted testing designs tests up front and executes them as written. It's strong for repeatability, compliance evidence and handoffs.
- Exploratory testing designs and executes at the same time, guided by what the tester learns. It's strong for finding problems nobody anticipated.
- Context-driven testing treats the right practice as dependent on the project. ISTQB states the same idea in its principle that testing is context dependent. Rapid Software Testing, from James Bach and Michael Bolton, puts the tester's skill and judgment at the center.
Scripted and exploratory testing are ends of a continuum, not rival camps. Most good testing mixes them, and the mix should shift with risk.
Standards fit here as a shared vocabulary. ISO/IEC/IEEE 29119-2 defines test processes that apply to any lifecycle model. That's a useful reminder that being Agile doesn't exempt you from planning, and being regulated doesn't require you to give up exploration.
Test Types: What Qualities You Evaluate
Functional testing asks whether the system does what it should. Non-functional testing asks how well it does it. ISO/IEC 25010:2023 defines a product quality model of nine characteristics, including security, reliability and performance efficiency. It's a good checklist to confirm that your plan covers more than features.
How to Choose
- Accept the lifecycle you're in, and understand what it means for when feedback arrives.
- Pick a strategy model that fits your architecture. A pyramid for a monolith, a honeycomb for microservices, quadrants to check for blind spots.
- Choose your approach by risk. Script what must be repeatable and evidenced; explore where the unknowns are.
- Check your types against a quality model so non-functional risk doesn't get forgotten.
Where Katalon Fits
Katalon supports testing across the layers of most strategy models, including web, mobile, API and desktop automation in Katalon Studio. Katalon True manages manual and automated testing together, so scripted checks and exploratory session results can be reported side by side. The platform doesn't pick your methodology. It works best when your team has answered the four questions above and uses it to carry out those answers.
Frequently asked questions
The term covers four kinds of answer. Lifecycle models (Waterfall, V-model, iterative and Agile) describe how development is organized. Test strategy models (test pyramid, testing honeycomb, Agile testing quadrants) say where to invest effort. Test approaches (risk-based, scripted, exploratory, context-driven) describe how decisions get made, and test types (functional and non-functional) say which qualities you evaluate.
No. Agile, delivered through frameworks such as Scrum and Kanban, is a way of organizing work in small increments with frequent feedback. Testing becomes continuous and testers work inside the team, but an Agile team still needs a test strategy and a test approach.
The test pyramid, introduced by Mike Cohn, recommends many fast unit tests, fewer service or integration tests and a small number of end-to-end UI tests. The testing honeycomb, described by Spotify engineers in 2018, fits microservices better: it puts integration tests at the center and keeps fewer implementation-detail tests.
Scripted testing designs tests up front and executes them as written, which is strong for repeatability, compliance evidence and handoffs. Exploratory testing designs and executes at the same time, guided by what the tester learns, which is strong for finding problems nobody anticipated. They are ends of a continuum, and the mix should shift with risk.
Answer the four questions in order. Accept the lifecycle you are in, pick a strategy model that fits your architecture, choose your approach by risk (script what must be repeatable and evidenced, explore where the unknowns are), and check your test types against a quality model so non-functional risk doesn't get forgotten.

Test everything. Ship with confidence.
From generating test cases to spotting failures, Katalon's AI works across your entire pipeline, automatically.



