- CTAL-ATT (Certified Tester Advanced Level Agile Technical Tester, also called CT-ATT) is the ISTQB advanced certification for a tester's technical skills in Agile teams.
- Important: it is in its sunset phase. You can take it in English until May 6, 2027 and in other languages until November 6, 2027. It is being replaced by CTAL-AT v2.0.
- ATT certificates already issued remain valid, but they are not automatically converted to CTAL-AT.
- Prerequisite: CTFL 4.0, or an earlier CTFL plus CTFL Agile Tester, and practical experience.
- Syllabus v1.1: 4 chapters, at least 16 hours of training; more than half of the time is "Testing in Agile" (TDD, BDD, ATDD, exploratory testing, code quality).
- Exam: 40 questions, 90 minutes (113 in a non-native language), pass with 42 out of 64 points (65%).
There was a time when Agile testers were mostly asked to collaborate and adapt. Today they are asked for more: write acceptance criteria that can be automated, understand TDD, review code, design tests for a continuous integration pipeline and simulate services that do not exist yet. That technical profile is exactly what ISTQB CTAL-ATT certifies.
In this guide I explain what it is, why it is being retired and what that means for you, what the syllabus covers chapter by chapter, what the exam looks like and whether you should take it or go straight to its successor.
What CTAL-ATT is and where it sits in the ISTQB portfolio
CTAL-ATT belongs to the ISTQB Agile stream at Advanced level. Its current syllabus is version 1.1 (December 2019). For years it was the natural step after CTFL Agile Tester for anyone who wanted to go deeper into the technical side.
Current status: sunset phase
In 2026 ISTQB launched CTAL-AT v2.0 (Advanced Level Agile Tester), a broader certification that replaces CT-ATT. According to ISTQB, the technical practices ATT covered have become mainstream. What you need to know:
| Topic | What applies |
|---|---|
| Last day to sit the exam in English (retakes included) | May 6, 2027 |
| Last day in other languages (retakes included) | November 6, 2027 |
| ATT certificates already issued | Remain valid |
| Converted to CTAL-AT? | No. To get CTAL-AT you must pass its exam |
| Successor | CTAL-AT v2.0 (prerequisite: CTFL) |
Is it still worth it? Yes, if you already studied the syllabus, your employer asks for it or you want to certify soon in these specific practices: the certificate does not expire. If you are starting from scratch and are not in a hurry, consider CTAL-AT v2.0, which is the long-term option. Either way, what you learn here (TDD, BDD, ATDD, CI, virtualization) is fully relevant in day-to-day work. See the full map in our ISTQB certification guide.
Who it is for and prerequisites
It is designed for testers on Agile teams who want a more technical role: Agile testers, technical test analysts, test automation engineers, SDETs and developers interested in test-first practices.
- Formal prerequisite: a valid CTFL 4.0 certificate, or a pre-4.0 CTFL plus the CTFL Agile Tester certificate. If you need them, see our ISTQB Foundation Level 4.0 course or our ISTQB Agile Tester course.
- Sufficient practical experience: the member board or exam provider sets the criteria.
- Technical skills: you do not have to be a developer, but you must be able to read code: the syllabus includes code review and TDD, with K3 and K4 objectives.
- An accredited course is not required to sit the exam.
What you will be able to do: business outcomes
According to ISTQB, a certified Agile Technical Tester can:
| # | Business outcome | In practice |
|---|---|---|
| 1 | Apply Agile techniques to ensure adequate test coverage | Combine automation, exploratory and black-box testing by risk |
| 2 | Define testable requirements within an Agile team | Clear, measurable, automatable stories and acceptance criteria |
| 3 | Create and implement Agile test approaches with suitable techniques | TDD, BDD, ATDD and exploratory test charters |
| 4 | Support test automation in Agile projects | Data-driven and keyword-driven, the right level of automation |
| 5 | Support continuous integration, delivery and deployment | Decide what runs in each CI cycle |
| 6 | Understand service virtualization | Test without depending on external systems |
| 7 | Communicate effectively with the team | Code reviews, conversations with POs and developers |
Learning objectives go up to K4 (analyze). ISTQB allocates a minimum of 15 minutes of training per K2 objective, 60 per K3 and 75 per K4, which tells you where the depth is.
Syllabus content chapter by chapter
| Chapter | Minimum time | Key topics |
|---|---|---|
| 1. Requirements Engineering | 180 min | Storyboards, story mapping, personas, diagrams, use cases, elicitation, acceptance criteria, INVEST and SMART |
| 2. Testing in Agile | 540 min | TDD, unit tests and FIRST, BDD, ATDD and specification by example, mixing approaches by risk, test charters, test refactoring, code review and static analysis, technical debt |
| 3. Test Automation | 135 min | Data-driven, keyword-driven, automation by test approach, level of automation needed |
| 4. Deployment and Delivery | 105 min | Continuous integration and its impact on testing, continuous testing in continuous delivery and deployment, service virtualization |
Chapter 1. Requirements Engineering
The chapter opens with a key idea: in Agile, requirements engineering techniques are not applied by an analyst at the start, but by the whole team in every iteration. Testers use them to polish stories and epics and to find gaps and forgotten non-functional requirements.
The techniques you must be able to apply (K4) are:
- Storyboards: a visual representation of the system that shows the flow and helps find logic gaps, group stories and define acceptance criteria.
- Story mapping: orders stories along two dimensions (priority and sophistication). It helps you define the smoke suite with the most basic features and prioritize tests by risk.
- Personas: user archetypes that reveal inconsistencies across user types. Example: the story works for "Ana, a frequent customer", but what about "Luis, placing a first order on his phone with a poor connection"?
- Diagrams (entity-relationship, class, UML) and use cases, which surface forgotten stakeholders, interfaces and integration points.
It then covers the requirements process (elicitation, documentation, negotiation and validation, management) and elicitation techniques for deriving acceptance criteria: quantitative questionnaires (useful for many stakeholders and non-functional criteria), qualitative questionnaires and qualitative interviews. The K4 objective is to create and evaluate testable acceptance criteria using INVEST, SMART and CTFL techniques such as equivalence partitioning, boundary value analysis, decision tables and state transition testing.
Example: "The user can pay quickly" cannot be tested. "Card payment is confirmed in under 3 seconds in 95% of cases, for amounts between 1 and 50,000" can, and it already suggests boundary values.
Chapter 2. Testing in Agile
The heart of the certification: nine of the sixteen hours. It has three blocks.
Agile development and test techniques. First TDD, which you must be able to apply (K3) with its red-green-refactor cycle: write a failing test, write the minimum code to make it pass and improve the design without changing behavior. It covers the traits of a good unit test (deterministic, atomic, isolated, fast), the FIRST mnemonic (Fast, Isolated, Repeatable, Self-validating, Thorough) and the Arrange-Act-Assert pattern.
Then BDD (K3): Given-When-Then scenarios written from the user's perspective, in the third person, isolated and atomic, with semantic actions ("the user confirms the order") rather than technical ones ("the user clicks the Confirm button"), and concrete outcomes rather than a generic "everything works". And ATDD and specification by example (K4): analyzing a backlog to decide how to introduce ATDD, separating the test intention (readable by the business) from its implementation (ideally automated).
Experience-based testing in Agile. The syllabus proposes deciding the mix of automated, exploratory and black-box tests according to the risk level and whether the system is mission- or safety-critical. In a critical system, high risk calls for highly recommended automation and black-box testing plus exploratory testing; in a non-critical system, low risk can be covered mostly with exploratory testing. It also teaches you to create test charters (K4) from epics and stories, with 60 to 120 minute sessions, and to document and present their results in the debriefing.
Code quality. Refactoring test cases (identify, analyze, refactor, re-run, evaluate) and code reviews and static analysis to find defects and technical debt (K4). The syllabus clarifies that testers should be able to read the language of the code they review, though they need not be experts: they contribute by asking about behavior, suggesting overlooked use cases and watching code metrics.
Chapter 3. Test Automation
Here you apply (K3) two classic techniques:
- Data-driven testing: one script reads many data combinations from a table. Ideal for validating, for example, 50 combinations of postal code and shipping type with a single flow.
- Keyword-driven testing: tests are written with business keywords ("Login", "AddToCart", "Pay") that someone implements once. It lets non-technical people design automated tests.
The syllabus stresses that test automation is not a test objective but a strategy that serves larger objectives, and explains how it fits each test approach (analytical, model-based, methodical, process-compliant, reactive, directed and regression-averse). It closes with the level of automation needed to keep pace with deployments: growing suite volume, development and execution time, staff availability, and the benefits and limitations of automating more, such as false positives and negatives or non-functional tests that stay slow even when automated. It also reminds you that release frequency should match what users actually need.
Chapter 4. Deployment and Delivery
First, continuous integration (K3) and its impact on testing. The syllabus frames the conflict between running CI very often and testing as thoroughly as possible, and proposes five complementary solutions: prioritize tests by risk, use different configurations per cycle type (basic tests on every build, fuller runs at night), reduce UI tests in favor of unit and integration tests, select tests through impact analysis and parallelize the suite across agents.
Then the role of continuous testing in continuous delivery (every change reaches a production-like environment) and continuous deployment (every change reaches production automatically). It closes with service virtualization: simulated services that, unlike a simple stub, can keep state, context and realistic response times. Benefits include parallel development and testing, earlier API testing, less reliance on shared resources such as mainframes, earlier non-functional testing and lower data-handling risk. Example: testing a store's checkout before the payment provider offers a sandbox.
Download the official syllabus
The CTAL-ATT v1.1 syllabus is available in English. Everything is examinable except the introduction and appendices.
The CTAL-ATT exam
Verified structure
| Item | Value |
|---|---|
| Questions | 40, multiple choice |
| Total points | 64 |
| Passing score | 42 points (65%) |
| Duration | 90 minutes; 113 in a non-native language (+25%) |
| Cognitive levels | K1 to K4 |
| Available until | May 6, 2027 (English) / Nov 6, 2027 (other languages) |
Source: the CTAL-ATT page on istqb.org and the official exam structure tables. Because there are K4 objectives, expect long scenarios (a user story, a code snippet, a backlog) where you must analyze and choose the best option.
Exam options
- Online from home (iSQI FLEX): remote proctoring 24/7. For Advanced exams, book at least 48 hours ahead. You need a webcam, microphone, your phone as a second camera and a government-issued ID.
- Pearson VUE: test center or OnVUE.
- At your company: groups of 6 or more, with a proctor provided by Cool Testers.
Paper exams are no longer offered. Given the retirement date, do not leave it to the last minute: if you fail, you need time for a retake.
Where to buy it
You can buy it directly from iSQI, our partner and official exam provider, or through Cool Testers with our certification exam (1 or 2 attempts) if your employer pays or you need an invoice. Keep in mind that even though you normally have 1 year to take it, the real deadline is the exam's retirement date. Questions? Message us on WhatsApp.
How to prepare
- First decide between ATT and CTAL-AT v2.0 based on your target date and what your employer requires.
- Review CTFL and Agile Tester: user stories, acceptance criteria, Agile testing quadrants and black-box techniques.
- Actually practice TDD. Take a simple exercise (a discount calculator, for example) and build it red-green-refactor in the language your project uses.
- Write BDD scenarios for real stories and check them against the syllabus guidelines: user perspective, atomicity, semantic actions and concrete outcomes.
- Review code. Ask a developer on your team to include you in pull requests; it is the best practice for the K4 review and technical debt objectives.
- Build a small data-driven and keyword-driven framework. Our Playwright and Selenium courses (open groups) and Postman give you the hands-on base.
- Work through the official sample exam (v1.3) on istqb.org and analyze every distractor.
Benefits and career paths
- A highly sought-after profile: a tester who can talk TDD, BDD and CI with developers fits modern Agile teams and SDET or quality engineer roles.
- Advanced level: it is an advanced certification and carries more weight on a resume than a foundation-level module.
- Practices that do not expire: even as the exam is retired, everything it covers is used daily in the industry.
- A bridge to automation: it prepares you for CTAL-TAE and for working in CI/CD pipelines.
- For companies: Agile teams with shared technical practices. To train your team in Agile or automation, request a quote.
Related certifications and next steps
- Before: CTFL 4.0 or an earlier CTFL + CTFL-AT.
- Successor: CTAL-AT v2.0, the advanced Agile certification that replaces it.
- Agile leadership: CT-ATLaS for Agile at scale.
- Automation: CTAL-TAE and CT-TAS.
- DevOps: CT-QDO, the natural next step if your team lives in CI/CD.
- Technical: CTAL-TTA to go deeper into technical testing.
Frequently asked questions
Does the CTAL-ATT certification no longer exist?
It still exists but is in its sunset phase. You can take it in English until May 6, 2027 and in other languages until November 6, 2027. It is being replaced by CTAL-AT v2.0.
Does my ATT certificate lose its validity?
No. ISTQB confirms that all existing CT-ATT certificates remain valid. What does not happen is an automatic conversion to CTAL-AT.
What do I need to sit the exam?
A CTFL 4.0 certificate, or an earlier CTFL plus the CTFL Agile Tester certificate, along with sufficient practical experience.
What does the CTAL-ATT exam look like?
40 multiple-choice questions worth 64 points; you pass with 42 (65%). You have 90 minutes, or 113 in a non-native language.
Do I need to know how to code?
You need to be able to read code, because there are TDD and code review objectives. You do not need to be an expert developer.
Should I take ATT or CTAL-AT v2.0?
If you already studied ATT or your employer requires it, take it before it is retired. If you are starting from scratch, CTAL-AT v2.0 is the long-term option.
Is the ATT syllabus available in Spanish?
We share the official v1.1 syllabus in English. Check with your member board (such as ASTQB in the US) or the exam provider for exam language availability.