Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by ISTQB
Exam Format
Registration
Validity
Skills this practice test covers
- Check user stories against the INVEST criteria and write acceptance criteria that can be tested.
- Work test-first with TDD, and turn acceptance criteria into BDD scenarios in Given-When-Then form.
- Plan an exploratory session with a test charter and combine it with black-box tests.
- Judge code quality through refactoring, code reviews and static code analysis.
- Build data-driven and keyword-driven tests, and decide how much of the testing to automate.
- Fit testing into continuous integration and delivery, using service virtualization where systems are missing.
Explore related topics
CTAL-ATT exam content
4 domains · 27 topics · 199 of 203 questions sorted by domain
Requirements Engineering43 questions
The technical tester helps turn user stories and epics into requirements that can be tested. Candidates use requirements engineering and elicitation techniques, such as personas, story mapping and interviews, and write acceptance criteria that a test can check.
Skills tested
- Analyze user stories and epics with story mapping, personas and storyboards.
- Check each story against the INVEST criteria.
- Write testable acceptance criteria and derive tests from them.
- Pick an elicitation technique, such as an interview or a questionnaire, for a stakeholder.
Questions by topic
- Acceptance Criteria16
- Personas7
- Requirements Engineering Techniques12
- Story Mapping8
Testing in Agile92 questions
This chapter covers test-first practices and code quality. Candidates apply TDD, BDD and ATDD, combine experience-based testing with black-box tests through test charters, and improve code with refactoring, code reviews and static code analysis.
Skills tested
- Follow the Red-Green-Refactor cycle of test-driven development.
- Write BDD scenarios with the team in Given-When-Then syntax.
- Plan a time-boxed exploratory session from a test charter and report what it found.
- Spot technical debt, and refactor code and test cases without changing their behavior.
- Use code reviews and static code analysis tools to find defects early.
Questions by topic
- Test-Driven Development (TDD)12
- Code Quality and Technical Debt5
- Behavior-Driven Development (BDD)12
- Experience-Based Testing6
- Acceptance Test-Driven Development (ATDD)7
- Agile Development and Test Techniques3
- Static Code Analysis5
- Unit Test Characteristics7
- Refactoring8
- Test Charters6
- Technical Debt8
- Exploratory Testing4
- Code Reviews7
- Test Automation Techniques2
Test Automation32 questions
This chapter covers automation that stays readable and reusable. Candidates compare data-driven and keyword-driven testing, apply automation to the team's test approach, and decide the right level of automation for a system.
Skills tested
- Separate test logic from test data with data-driven testing.
- Build keyword-driven tests from keywords taken from the business domain.
- Decide how much to automate, weighing coverage against speed and the criticality of the system.
Questions by topic
- Keyword-Driven Testing8
- Data-Driven Testing7
- Test Automation Techniques10
- Level of Automation7
Deployment and Delivery32 questions
This chapter places testing in the delivery pipeline. Candidates explain how continuous integration changes testing, what continuous testing adds to continuous delivery, and how service virtualization stands in for systems that are not available.
Skills tested
- Design a continuous integration (CI) process that gives fast feedback on each code change.
- Tell continuous delivery from continuous deployment, and state what each needs from testing.
- Simulate connected systems with virtual services when the real ones are missing or costly.
Questions by topic
- Service Virtualization13
- Continuous Integration and Continuous Testing4
- Continuous Delivery and Deployment4
- Continuous Integration7
- Continuous Delivery4
Requirements
- Required: CTFL v4.0, or an earlier Foundation Level certificate together with the Foundation Agile Tester certificate.
- Recommended: practical experience of testing in an agile team.
- Recommended: a sound understanding of agile methods.
About the CTAL-ATT exam
The ISTQB CTAL-ATT exam is for testers who work close to the code in an agile team. It checks four areas: testable requirements, test-first and experience-based testing with code quality, test automation, and testing in continuous delivery. Candidates need CTFL v4.0 first, or an earlier Foundation Level certificate together with the Foundation Agile Tester certificate. Passing earns the ISTQB Certified Tester Advanced Level - Agile Technical Tester certificate, which has lifetime validity.
Testing in Agile has the most questions in the PlanetCert practice test, led by test-driven and behavior-driven development, refactoring and technical debt, with Requirements Engineering second. The explanations help most where two answers sound alike, such as ATDD and BDD, or continuous delivery and continuous deployment. Flashcard mode suits the many named practices, from story mapping to service virtualization. Brainy AI Assistant can turn a user story into Given-When-Then scenarios, or compare keyword-driven with data-driven testing.
How to earn the certification
- Earns
- ISTQB Certified Tester Advanced Level - Agile Technical TesterAdvanced
The certificate has lifetime validity, so it needs no renewal.
- Before
- CTFL-V4-0 CTFL v4.0
The Foundation Level certificate that qualifies a candidate on its own.
- CTFL-AT Foundation Agile Tester
Also required for candidates whose Foundation Level certificate is older than version 4.0.
- CTFL-V4-0 CTFL v4.0
How to prepare for CTAL-ATT
- 1
Rewrite three stories until testable
Take three real or sample user stories, check each against the INVEST criteria, and write acceptance criteria for it. Then derive tests from those criteria with a black-box technique.
- 2
Code a small feature test-first
Pick a small coding exercise and go through Red-Green-Refactor in a unit test framework. Then describe the same feature as Given-When-Then scenarios to see how BDD differs from TDD.
- 3
Put Testing in Agile first
Testing in Agile holds the most topics and the most practice questions, from TDD and BDD to refactoring and technical debt. Give it the most study time, then move to Requirements Engineering.
- 4
Run one chartered exploratory session
Write a test charter, explore one feature inside a fixed time box, and record what was found. This makes the experience-based testing questions concrete.
- 5
Sit the practice test under time
Take the CTAL-ATT practice test in Timed Mode, then review the explanation for every miss. Ask Brainy AI Assistant to compare continuous delivery with continuous deployment, or data-driven with keyword-driven testing.
Start a timed CTAL-ATTrun
Who CTAL-ATT is for
- Testers in agile teams who work close to the code and the build pipeline.
- Technical test analysts and QA engineers who have joined agile teams.
- Automation engineers who build and maintain tests inside agile projects.
- Developers who write unit tests or BDD scenarios as part of their team's testing.
Typical job titles: Agile tester · Technical test analyst · Test automation engineer · QA engineer · Software developer in test
CTAL-ATT glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Acceptance criteria
- The conditions a user story must meet before the team accepts it; good criteria are clear enough to test.
- Acceptance test-driven development
- A practice in which business people, developers and testers write acceptance tests together before the code.
- Behavior-driven development
- A practice in which the team describes the wanted behavior as natural-language examples that also run as tests.
- Continuous integration
- Building and testing the product automatically each time a developer commits a change to the shared code.
- Data-driven testing
- Running one test script many times, with inputs and expected results read from a data table.
- Given-When-Then syntax
- The BDD scenario format: Given a starting state, When an action happens, Then a stated result follows.
- INVEST criteria
- A checklist for good user stories: Independent, Negotiable, Valuable, Estimable, Small and Testable.
- Keyword-driven testing
- Building tests from keywords that each stand for an action, so that people without coding skills can read and write them.
- Personas
- Fictional but realistic user profiles that help the team think about who uses the product and why.
- Red-Green-Refactor cycle
- The TDD loop: a failing test (red), code that passes it (green), then a cleanup that keeps it passing (refactor).
- Refactoring
- Changing the structure of code or tests to make it cleaner without changing what it does.
- Service virtualization
- Simulating the behavior of systems the application depends on, so that tests can run before those systems are ready.
- Specification by example
- Describing requirements through concrete examples, which then serve as acceptance tests.
- Static code analysis tools
- Tools that check source code without running it, to find defects and breaches of coding rules.
- Story Mapping
- Laying user stories out along the steps of a user's activity, to find gaps and plan releases.
- Technical debt
- The future cost of quick or poor design choices, which makes code harder and slower to change.
- Test charter
- A short statement of the goal of one exploratory testing session: what to explore, with what, and why.
- Test-driven development
- Writing a failing unit test first, then the code that makes it pass, then improving the code.