EU AI Act Testing Requirements: What QA Teams Must Do Before December 2027
qabash.comAmbassador
Nov 21, 2026
Quick answer
The EU AI Act requires providers of high-risk AI systems to test them before release and throughout their life: against predefined metrics and thresholds for accuracy, for robustness to errors and inconsistent inputs, and for cybersecurity threats such as data poisoning and adversarial inputs. Systems must log events automatically, and providers must keep technical documentation and monitor performance after release. After the Digital Omnibus (Regulation (EU) 2026/1744), these obligations apply from 2 December 2027 for Annex III high-risk systems and 2 August 2028 for AI embedded in regulated products.

Most talk about the EU AI Act happens between lawyers and executives. Then a compliance lead asks QA a simple question: “Can you show me the evidence that this model is accurate, robust and secure?”
That question is coming to a lot of test teams. In July 2026 the EU moved the deadline for most high-risk AI systems to 2 December 2027. That’s a reprieve, not a repeal, and the work it requires is mostly testing work.
This guide explains the EU AI Act testing requirements from a tester’s point of view: which systems are in scope, what the Act expects you to test, and how to turn your CI results into evidence. It isn’t legal advice; your legal team decides classification. It is the part they will hand to you.
What is the EU AI Act, in one paragraph?
The AI Act (Regulation (EU) 2024/1689) regulates AI systems by risk. A few practices are banned outright. “High-risk” systems, such as those used in hiring, credit, education, essential services and critical infrastructure, must meet requirements on risk management, data, documentation, logging, transparency, human oversight, accuracy, robustness and cybersecurity. Some systems that interact with people or generate content have transparency duties. Everything else is largely untouched. It applies to providers and deployers whose systems are used in the EU, wherever the company is based.
That last point matters for teams in India and elsewhere: if your product scores EU applicants or screens EU candidates, the Act can apply to you.
What are the current EU AI Act deadlines?
The Act phases in over several years, and the 2026 Digital Omnibus on AI changed the high-risk dates.

General-purpose AI model providers (the companies training foundation models) have had obligations since August 2025. Most product teams build on those models, so their obligations depend on what their own system does, not on the model underneath.
A year sounds like plenty of time. It isn’t, if your current test suite can’t produce evidence of accuracy, robustness and security for a specific model version.
Is your system high-risk?
Classification is a legal call, but testers should know the shape of it. A system is generally high-risk if it’s a safety component of a product covered by EU product law (Annex I), or if it’s used for one of the purposes listed in Annex III, including:
| Annex III area | Examples |
|---|---|
| Employment | CV screening, candidate ranking, promotion or termination decisions |
| Essential services | Creditworthiness and credit scoring, life and health insurance pricing |
| Education | Admissions, exam scoring, proctoring |
| Critical infrastructure | Safety components in energy, water or traffic systems |
| Biometrics | Remote biometric identification, emotion recognition (where permitted) |
| Public sector, law enforcement, migration, justice | Eligibility for benefits, risk assessments |
There are exceptions, for example for systems that perform a narrow procedural task and don’t materially influence the decision. Your legal team applies them. Your job is to make sure that, whatever the answer, you can test to it.
What does the EU AI Act require you to test?
For high-risk systems, several articles land directly on QA:

Translated into test activities:
| Requirement | What QA actually does |
|---|---|
| Predefined metrics and thresholds (Art. 9) | Agree pass thresholds before testing; gate releases on them, ideally on confidence-interval lower bounds |
| Representative data, bias examination (Art. 10) | Test sets that reflect the real population; slice results by relevant groups; look for proxies of protected attributes |
| Logging (Art. 12) | Verify that inputs, outputs, versions and key events are recorded and retrievable for a given decision |
| Accuracy (Art. 15) | Measure on held-out data; report per version; repeat after every model or data change |
| Robustness (Art. 15) | Perturbation tests, edge cases, missing and malformed inputs, consistency checks |
| Cybersecurity (Art. 15) | Adversarial inputs, prompt injection for LLM-based systems, data-poisoning controls in the pipeline |
| Human oversight (Art. 14) | Test that overrides, stop controls and explanations work as specified |
| Post-market monitoring (Art. 72) | Production performance checks and drift alerts with an owner |
None of this is exotic. It’s disciplined ML and LLM testing. The difference is that it must be planned in advance, repeatable and documented, for each version you ship.
Turning test results into evidence
Auditors and notified bodies don’t read CI logs. They read evidence: which requirement, which test, which model version, what result, when. Most teams have all of that, scattered across tools.
The cheapest fix is to make tests emit evidence as they run. Link each test to a requirement ID, and write a record with the outcome and the exact model and code version.
A requirement-linked evidence plugin for pytest
# conftest.py: write one evidence record per test, linked to a requirement
import json
import os
from datetime import datetime, timezone
import pytest
MODEL_VERSION = os.environ.get("MODEL_VERSION", "credit-scorer-2.4.1")
EVIDENCE_FILE = "evidence.jsonl"
def pytest_configure(config):
config.addinivalue_line("markers", "requirement(id): requirement this test verifies")
@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item, call):
outcome = yield
report = outcome.get_result()
marker = item.get_closest_marker("requirement")
if report.when == "call" and marker:
record = {
"requirement": marker.args[0],
"test": item.nodeid,
"outcome": report.outcome,
"model_version": MODEL_VERSION,
"git_commit": os.environ.get("GIT_COMMIT", "local"),
"timestamp": datetime.now(timezone.utc).isoformat(timespec="seconds"),
}
with open(EVIDENCE_FILE, "a") as f:
f.write(json.dumps(record) + "\n")
Tests declare which requirement they verify. The model here is a stand-in for a credit scorer, one of the Annex III use cases:
# test_credit_model.py: requirement-linked tests for a (stub) credit-scoring model
import pytest
def score(applicant: dict) -> float:
"""Stand-in for the real model: returns an approval probability."""
return min(1.0, applicant["income"] / 100_000)
@pytest.mark.requirement("ACC-01") # accuracy against a labelled holdout set
def test_holdout_accuracy_meets_threshold():
holdout = [({"income": 90_000}, True), ({"income": 20_000}, False), ({"income": 70_000}, True)]
correct = sum((score(a) >= 0.5) == label for a, label in holdout)
assert correct / len(holdout) >= 0.9
@pytest.mark.requirement("ROB-02") # robustness: tiny input changes don't flip decisions
def test_small_income_change_does_not_flip_decision():
base = score({"income": 80_000}) >= 0.5
assert all((score({"income": 80_000 + d}) >= 0.5) == base for d in (-100, 100))
@pytest.mark.requirement("FAIR-03") # protected attribute must not affect the score
def test_score_ignores_protected_attribute():
a = {"income": 60_000, "gender": "F"}
b = {"income": 60_000, "gender": "M"}
assert score(a) == score(b)
pip install pytest
MODEL_VERSION=credit-scorer-2.4.1 GIT_COMMIT=$(git rev-parse --short HEAD) pytest -q
# 3 passed
Each run appends lines like this to evidence.jsonl:
{"requirement": "ACC-01", "test": "test_credit_model.py::test_holdout_accuracy_meets_threshold", "outcome": "passed", "model_version": "credit-scorer-2.4.1", "git_commit": "local", "timestamp": "2026-11-21T05:07:01+00:00"}
Store the file as a CI artifact per release, and you have a traceability matrix that builds itself: requirement → test → result → model version.
Two honest caveats. First, the holdout here has three rows to keep the example short; real accuracy claims need large, representative sets and confidence intervals. Second, FAIR-03 only shows that the protected attribute is ignored. That’s necessary but not sufficient: models discriminate through proxies (postcode, school, gaps in employment), so real fairness testing compares outcomes across groups.
What about GenAI features and chatbots?
Most LLM features (support bots, writing assistants, summarizers) are not high-risk by default. They mainly carry Article 50 transparency duties, which have applied since August 2026:
- People must be told when they’re interacting with an AI system, unless it’s obvious.
- AI-generated synthetic content must be marked in a machine-readable way, with a grace period to 2 December 2026 for systems already on the market.
- Deepfakes and certain AI-generated text published to inform the public must be disclosed.
These are testable. Check that the disclosure appears in every entry point, including embedded widgets and API responses, and that generated media carries the expected marking.
The use case changes the class, not the technology. An LLM that ranks job applicants is high-risk, however friendly its chat interface looks.
Common mistakes testers make
| Mistake | Why it happens | Better approach |
|---|---|---|
| “Compliance is legal’s problem” | The Act reads like law | Most evidence is test evidence; QA owns producing it |
| Thresholds set after seeing results | Habit from exploratory evaluation | Define metrics and thresholds before testing, as Article 9 expects |
| Results not tied to a model version | Models update outside code | Record model, data and code versions with every result |
| Fairness by attribute removal | Simple to test | Compare outcomes across groups; look for proxies |
| Logs nobody can query | Logging added for debugging | Test that a specific decision can be reconstructed |
| Waiting for December 2027 | It sounds far away | Evidence for a year of releases takes a year to collect |
Interview questions
Beginner
What is the EU AI Act?
An EU regulation that sets requirements for AI systems according to their risk level.
When do high-risk obligations apply?
From 2 December 2027 for Annex III systems and 2 August 2028 for Annex I systems, after the Digital Omnibus.
Name three high-risk areas.
Employment, credit scoring and education.
Does the Act apply to companies outside the EU?
Yes, when their AI systems are placed on the market or used in the EU.
Intermediate
What does Article 15 require?
Appropriate accuracy, robustness and cybersecurity, with accuracy levels declared to deployers.
Why define thresholds before testing?
The Act expects testing against prior defined metrics; setting thresholds afterwards makes results meaningless.
How does logging relate to testing?
You must verify that the system records the events needed to trace its decisions.
What are Article 50 duties?
Transparency: disclosing AI interactions and marking AI-generated content.
Advanced
How would you build an evidence trail in CI?
Requirement IDs on tests, records with model and code versions, stored as release artifacts.
Why isn’t removing a protected attribute enough for fairness?
Proxies can reproduce the same discrimination; test outcomes across groups.
How do you test robustness for an LLM-based high-risk system?
Paraphrase and perturbation sets, malformed inputs, prompt injection tests and consistency checks across repeated runs.
What does post-market monitoring mean for QA?
Production performance metrics, drift detection and a process for feeding incidents back into tests.
How AI changes this
Regulation is turning AI testing from a nice-to-have into a deliverable. Testers who can design threshold-based evaluations, slice results by group and produce versioned evidence will be in demand well beyond the EU.
AI tools help with the volume: generating perturbation sets, drafting documentation from test results and summarizing evidence. Keep the thresholds, the classification and the sign-off with people who are accountable for them.
Into 2027, expect harmonised standards and Commission guidance to fill in the details the Act leaves open. Build the evidence habit now and those details become small adjustments. A bug found in production is expensive. A bug prevented is priceless.
This article explains the AI Act for testing teams and isn’t legal advice. Confirm classification and obligations with qualified counsel, and check the current text on EUR-Lex.
Best practices checklist
- Get a written classification decision for each AI system
- Define metrics and thresholds before testing
- Link every evaluation test to a requirement ID
- Record model, data and code versions with every result
- Slice accuracy by relevant groups and look for proxies
- Test robustness with perturbations and malformed inputs
- Test security, including prompt injection for LLM-based systems
- Verify that individual decisions can be reconstructed from logs
- Test Article 50 disclosures in every entry point
- Monitor production performance with a named owner
Conclusion
The EU AI Act testing requirements ask for what good testers already value: thresholds set in advance, representative data, robustness and security checks, and results you can trace to a specific version.
The difference is that “we tested it” now needs proof. Start linking tests to requirements and recording versions today. By December 2027 you’ll have a year of evidence instead of a scramble.
Tools change. Testing principles endure.
Keep testing. Keep learning. Keep questioning.
Go deeper · QA Bash kit
AI for QA Engineers: Getting Started
Use AI tools in your testing work, with prompts that work and checks that keep you safe.
0–1 yrs · 10 testing workflows
₹299₹374
Rate this article
8.4/10 average · 29 ratings
Discussion
Be the first to weigh in
Your question or experience helps the next tester who reads this. Sign in and earn +25 XP for every approved comment or reply.
Written by
Frequently asked questions.
Keep reading




