Study guide
2.1 AI-Based vs Conventional Systems
ISTQB Certified Tester AI Testing CT-AI
Track your progress as you read
Finished sections get a check mark.
1 Introduction & Exam Overview
1.1 Current Exam Facts (CT-AI v2.0) 1.2 Scoring, K-levels & Chapter Weights
2 Introduction to AI: Systems and Capabilities
2.1 AI-Based vs Conventional Systems 2.2 Narrow AI, General AI and Super AI 2.3 Types of AI Technologies 2.4 Generative AI
3 AI Hardware, Hosting, Frameworks and Governance
3.1 Hardware for Machine Learning Systems 3.2 Development and Hosting of AI Models 3.3 Machine Learning Development Frameworks 3.4 Regulations and Standards for AI
4 Quality Characteristics and Acceptance Criteria
4.1 ISO/IEC 25059 AI Quality Characteristics 4.2 AI and Safety 4.3 Acceptance Criteria for AI-Based Systems
5 Machine Learning Forms, Workflow and Data Preparation
5.1 Forms of Machine Learning 5.2 The Machine Learning Workflow 5.3 Pretrained Models, Fine-Tuning and RAG 5.4 Data Preparation Activities
6 Datasets, Classification Metrics and Neural Networks
6.1 Training, Validation and Test Datasets 6.2 Calculating Classification Metrics 6.3 Structure of Deep Neural Networks 6.4 Neural Network Coverage Measures
7 Testing Challenges for AI-Based Systems
7.1 Locked vs Adaptive AI-Based Systems 7.2 Why Statistical Testing Is Needed 7.3 Test Oracles for AI-Based Systems
8 GenAI Testing, Test Levels and Risk-Based Testing
8.1 Testing Generative AI 8.2 Red Teaming for GenAI 8.3 Test Levels for Machine Learning Systems 8.4 Risk-Based Testing of ML Systems
9 Input Data Risks, Bias and Pipelines
9.1 Input Data Risks and Mitigations 9.2 Testing for Bias 9.3 Data Pipeline Testing
10 Representativeness, Constraints and Labels
10.1 Testing for Data Representativeness 10.2 Dataset Constraint Testing 10.3 Label Correctness Testing
11 Model Risks, Documentation and Performance Testing
11.1 ML Model Risks and Mitigations 11.2 ML Model Documentation and Review 11.3 Functional Performance Testing of Probabilistic MLS
12 Adversarial, Metamorphic and Drift Testing
12.1 Adversarial Testing 12.2 Metamorphic Testing 12.3 Drift Testing
13 Overfitting, A/B Testing and Back-to-Back Testing
13.1 Testing for Overfitting and Underfitting 13.2 A/B Testing for ML Systems 13.3 Back-to-Back Testing
14 ML Development and Deployment Testing
14.1 ML Development Risks and Mitigations 14.2 ML System Deployment Testing
2.1 AI-Based vs Conventional Systems
Key Takeaways Explain This Topic AI
Conventional systems encode behavior as explicit imperative instructions such as if-then branches and loops, so the same inputs and state typically produce the same inspectable output.
Many AI-based systems, especially machine learning, infer response patterns from data instead of a complete handwritten rule list, as in a cat classifier trained on example images.
Probabilistic scores, sampling, retraining, and numeric jitter mean testers often need thresholds, ranges, or statistical oracles rather than a single golden byte string.
Deep models with billions of parameters can behave as black boxes, which is a serious concern in healthcare, finance, defence, and transport where a decision must be investigable.
Adaptive AI-based systems can keep changing after release, so they need continuous monitoring; covering code paths in the serving wrapper is necessary and not a complete test strategy.
Last updated: September 2026
2.1 AI-Based vs Conventional Systems
When you test a payroll engine, a tax calculator, or the firmware in a microwave, you are usually testing a conventional system . A person wrote the rules. The code says what to do, in what order, and under which conditions. When you test a photo app that labels cat versus not-cat, a credit model that scores default risk, or a chatbot that drafts an email, you are testing an AI-based system . Ordinary software still wraps the model—APIs, queues, access control—but the important decision procedure often lives in a model that was fitted to data , not in a list of if-then statements a developer typed by hand.
That split is the first testing fork in the road. It changes what you can predict, what you can explain after an incident, what you must watch in production, and what the word coverage even means.
How conventional systems decide
Conventional software is typically written in imperative languages: the programmer specifies step-by-step instructions. The familiar building blocks are not optional decoration; they are the policy:
- Assignments and data structures that hold known business facts (tax tables, speed limits, account flags)
- If-then-else branches that encode rules (if the account is overdue more than 30 days, refuse the withdrawal)
- Loops that walk records, retry a network call, or accumulate a total
- Deterministic functions that, given the same input and the same stored state, produce the same output
Because the rules are explicit, a competent reader can usually trace why a given input produced a given output. That transparency is why classical testing techniques still earn their keep: you can build a decision table from the specification, force every interesting branch, and compare the result with an independently calculated expected value (the test oracle ).
Conventional systems are not simple by definition. A compiler, a database query planner, or a fly-by-wire control law can be extraordinarily sophisticated. The point is not intelligence-looking complexity. The point is where the decision procedure comes from . In a conventional system, humans authored the procedure. If the business changes, humans change the code or the configuration the code interprets. Until someone ships an update, the system's policy is static .
How AI-based systems, especially machine learning, decide
Most AI-based systems that testers meet in production are built with machine learning (ML) . Instead of writing cat-detection rules, a team collects images, labels many of them as cat or not-cat, and runs a training procedure that adjusts a huge set of internal numbers (parameters) until the model does well on that data. The deployed program still has ordinary code around the model, but the classification policy is not a handwritten taxonomy of whiskers and pointed ears.
Try, for a moment, to write a conventional cat classifier. You might start with if the image has triangular ears and vertical pupils, then cat. You immediately drown in exceptions: hats, cartoons, night photos, lynxes, and dogs with pointed ears. An ML classifier does not store that rule list. It stores a pattern extracted from examples. Show it a new photo and it computes a score —often a probability—that the photo belongs to the cat class.
That is a different kind of program:
The requirements for the core decision are partly data , not only a written specification
The same input can yield slightly different outputs across versions, random seeds, sampling settings, or even parallel hardware
Correct is often a rate (for example, recall on a held-out set) rather than a single golden string
The serving code can still be conventional and well specified. Testers who only read that code will miss the product. The product is the composition of pre-processing, model, threshold, and downstream action.
Probabilistic reasoning versus a single right number
Many AI-based systems reason probabilistically . They estimate how likely an outcome is, then a surrounding policy turns that estimate into an action: show the label, block the transaction, or ask a human to review.
A conventional checksum either matches or it does not. A medical-image model might output 0.81 probability of a finding. Downstream software might treat anything above 0.70 as flag for radiologist. Testers must understand both layers. The model can be statistically strong and still be operationally wrong if the threshold is careless. The system can be deterministic in its code and still be non-deterministic in its observable behavior if the model, the decoding temperature, or a retrieval index moves.
Non-determinism shows up in several practical ways:
- Random initialization and data shuffling during training produce different models from the same recipe
- Stochastic decoding in generative models (temperature, top-k sampling) produces different texts for one prompt
- Floating-point parallelism can change low-order bits of a score
- Online learning or periodic retraining means yesterday's expected output is not a lifetime contract
None of this means anything goes. It means your oracle is often a band , a metric , a relationship that should hold across inputs , or a human rubric , not a single hardcoded byte.
Explainability and the black box
A conventional function of a few dozen lines can be stepped through in a debugger. A modern deep model may contain billions of parameters . No tester—and no clinician, loan officer, or accident investigator—can meaningfully inspect each weight. That black-box character is not an insult. It is a structural fact about high-capacity models.
Explainability matters most where a wrong or unjustified decision harms people or the public:
- Domain Why a decision must be investigable
- Healthcare A missed finding or a spurious alert can change treatment
- Finance Credit, fraud, and trading decisions are regulated and contested
- Defence Targeting, triage, and intelligence fusion cannot be unauditable magic
- Transport A perception stack on a vehicle must be investigable after an incident
Around the model you will still find conventional code that can be traced: feature stores, rule-based overrides, audit logs, kill switches. Testers should map that hybrid. Do not pretend the neural net is a flowchart. Do not ignore the flowchart that wraps the neural net.
Techniques such as feature-importance plots, saliency maps, and local surrogate models can give partial stories. Treat them as evidence, not as a proof of internal correctness. A heatmap that highlights the hospital logo instead of the lesion is a defect, not a documentation flourish.
Adaptability versus a static conventional release
Conventional systems typically wait for a human to ship a change. If tax rates change, someone edits a table or a function and regression-tests the release. AI-based systems can be self-learning or frequently retrained: they update their behavior as new data arrives. That adaptability is valuable in fraud detection, recommendation, and speech recognition, where the world does not sit still.
Adaptability is also a testing liability. A model that keeps learning can drift away from the behavior you certified. Data can shift (new phone cameras, new slang, new fraud tactics). Feedback loops can amplify bias. An attacker can poison the training stream. For that reason, adaptive systems demand continuous monitoring : track live metrics, data schemas, slice performance, and incident rates so the system still satisfies the core requirements you accepted at release. A one-time factory test is not a lifetime argument.
Some ML systems are locked after training: the production artifact does not keep fitting itself. Locked systems still age, because the world changes, but they do not silently rewrite their own parameters between releases. Testers must know which kind they have. Later study in this guide returns to locked versus adaptive systems in depth. Here, remember the contrast with conventional software, which is locked by construction until a person changes it.
Comparison testers actually use
Question Conventional system Typical AI-based ML system
Where is the policy? Source code, configuration, rules engines Training data plus learned parameters, plus wrapper policy
- Same input, same output? Usually yes, given the same state Often a distribution or a jittering score
- Can a human trace why? Usually, with enough time Often only approximately, especially with huge models
- How does it acquire new behavior? Manual change and release Retraining, fine-tuning, or ongoing learning
What does coverage mean? Code paths, requirements, interfaces Those, plus data, scenarios, slices, and behavioral checks
Loading diagram...
What testers should change in their habits
If you carry only conventional instincts into AI testing, you will under-test the risky parts and over-trust the easy parts.
Expect non-determinism. Design checks that remain valid when scores jitter. Repeat inference. Fix random seeds in the lab when you need reproducibility, and still exercise the non-seeded production path.
Invest in oracles and thresholds. When there is no single correct caption or bounding box, define acceptance as a metric window, a human grading guide, a set of invariants (the system must not diagnose from the hospital logo), or a comparison against a previous model. Record the threshold policy; a 0.50 cutoff and a 0.90 cutoff are different products.
Do not treat code-path coverage as enough. You can cover every line of the pre-processing script and still have a model that fails on night-time photos, a minority dialect, or an adversarial sticker. Coverage of the wrapper is necessary and nowhere near sufficient. You also need data coverage, scenario coverage, and behavioral testing of the model.
Keep conventional testing where it still applies. Authentication, encryption, access control, latency budgets, and crash handling remain ordinary software. The AI core does not excuse skipping those tests; it adds another test object beside them.
A useful picture for the exam: the conventional system is a recipe someone wrote. The ML system is a palate trained on thousands of meals. Both can serve dinner. Only one lets you read the recipe line by line. Your job is to know which kitchen you walked into, and to pick oracles that match that kitchen.