Linear, modular, data-driven, keyword-driven and hybrid frameworks are design choices, not products. How to choose a test automation framework by what will change and who maintains it.
Most guides to test automation frameworks list six types, describe each one and suggest you pick. In practice, almost every serious framework ends up hybrid. The types aren't rival products. They're design decisions about what to separate from what.
So the useful question isn't "which type?" It's this: what will change most in our system, and who will maintain the tests when it does? A framework exists to keep automated checks cheap to change and failures quick to diagnose. Judge every design choice by those two outcomes.
What a Framework Is, and What It Isn't
A test automation framework is the set of conventions, libraries and tools a team uses to design, run and maintain automated tests. It decides where test logic lives, where data lives, how the application is accessed and how results are reported. If your team works in Java, our guide to Java testing frameworks compares the common options.
It's worth being precise about what it produces. Automation runs checks: mechanistic verifications of expected behavior. That's enormously valuable, and it isn't the whole of testing. A framework makes good checks scalable. It can't tell you which checks are worth having. That still comes from risk analysis and from people exploring the product.
The Types as Design Decisions
Type | What it separates | Pays off when | Watch out for |
|---|---|---|---|
Linear (record and playback) | Nothing; each script stands alone | Spikes, demos, learning a tool | Duplication; one UI change breaks many scripts |
Modular | Application areas into reusable test modules | Apps with distinct, stable functional areas | Modules that grow too large to understand |
Library architecture | Common actions into shared functions | Many tests repeat the same operations | Libraries that hide what a test actually checks |
Data-driven | Test data from test logic | One flow must be checked across many inputs | Data files nobody reviews; weak oracles per row |
Keyword-driven | Test intent from implementation | Domain experts help design tests | Keyword sprawl; keywords that are just clicks |
Hybrid | Combinations of the above | Most real systems, sooner or later | Complexity without conventions |
Read the second column as a menu, not a list of products. You might separate data from logic for checkout tests, use a library of shared actions for authentication, and express business flows as keywords so product owners can review them.
One pattern belongs alongside these types: the page object, which wraps each screen or component behind an interface that describes what a user can do there. When the UI changes, you update one page object instead of every test that touches that screen. For UI automation, it's the single design choice that most reduces maintenance cost. Our guide to the Page Object Model goes deeper.
Keyword-Driven Testing Has a Standard
Keyword-driven testing is the one framework type with its own international standard. ISO/IEC/IEEE 29119-5 was updated to a second edition in December 2024. It describes hierarchical keywords, in which generic low-level keywords combine into business-level keywords. It also defines a common data format so tools from different vendors can exchange test cases, keywords and results.
That's a practical guide to avoiding the most common failure of keyword frameworks: keywords like "Click" and "Type" that describe mechanics rather than intent. A business-level keyword such as "Submit claim with missing policy number" tells a reviewer what's being checked. A sequence of clicks doesn't.
How to Choose
Work through four questions before you write framework code:
- What changes most? UI churn calls for page objects. Many input combinations call for data-driven design. Changing business rules call for readable business-level keywords.
- Who maintains the tests? If domain experts review or write them, invest in keywords. If only engineers do, a code-first library may be simpler.
- Where should most checks live? Push checks toward the API and service layer where you can. They run faster and break less. Keep UI automation for critical user journeys.
- How will failures be diagnosed? Decide up front what a failed check reports: screenshots, logs, request and response data, the data row that failed. A failure that takes an hour to understand costs more than the check saves.
Principles That Keep a Framework Healthy
- Independent checks. Each test sets up its own state. Order dependencies are a leading source of flakiness.
- Deterministic data. Know exactly what data each test uses, and reset it.
- Explicit oracles. Every check asserts something observable and specific. "No error was thrown" is rarely enough.
- Test code is production code. Review it, refactor it and delete it when its risk is gone.
- Automate by risk and repetition. Automate checks that are stable, valuable and frequent. Leave one-off checks and judgment calls, such as usability, to people.
To know whether your framework is working, watch three numbers: how much effort goes into maintaining existing tests compared with writing new ones, the flake rate, and how long it takes to diagnose a typical failure. If maintenance is crowding out new coverage, the framework's design is costing you more than its type.
Where Katalon Fits
Katalon Studio is built as a hybrid framework. It offers keyword-based test steps (built-in and custom keywords), data files for data-driven runs, an object repository that serves the same purpose as page objects, and full scripting when you need it. AI assistance can draft and explain test code. The platform gives you the building blocks. Deciding what to separate, what to automate and what to leave to human testers is the architecture work that makes a framework last.
Frequently asked questions
A test automation framework is the set of conventions, libraries and tools a team uses to design, run and maintain automated tests. It decides where test logic lives, where data lives, how the application is accessed and how results are reported.
The common types are linear (record and playback), modular, library architecture, data-driven, keyword-driven and hybrid. Each separates something different: nothing, application areas, common actions, test data from test logic, test intent from implementation, or a combination of these. They are design choices rather than rival products.
Ask four questions before writing framework code: what changes most, who maintains the tests, where most checks should live (push them toward the API and service layer where you can), and how failures will be diagnosed. UI churn calls for page objects, many input combinations call for data-driven design, and changing business rules call for readable business-level keywords.
A page object wraps each screen or component behind an interface that describes what a user can do there. When the UI changes, you update one page object instead of every test that touches that screen, which makes it the design choice that most reduces maintenance cost in UI automation.
Keep checks independent, data deterministic and oracles explicit, treat test code as production code, and automate by risk and repetition. To know whether it is working, watch the effort spent maintaining existing tests compared with writing new ones, the flake rate, and the time it takes to diagnose a typical failure.

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



