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
- Explain the values of the Agile Manifesto and what the whole-team approach asks of a tester.
- Write user stories with the team and check each one against the INVEST technique.
- Report test progress in an iteration with task boards and burndown charts.
- Use TDD, ATDD and BDD so that tests are defined before the code exists.
- Estimate test effort with planning poker and rank the quality risks of each story.
- Plan exploratory testing with test charters and time-boxed sessions.
Explore related topics
CTFL-AT exam content
3 domains · 20 topics · 199 of 442 questions are written for CTFL-AT
Agile Software Development51 questions
This domain covers the agile basics a tester needs: the Agile Manifesto, the whole-team approach and early feedback. It also covers Extreme Programming, Scrum and Kanban, and shared practices such as retrospectives, continuous integration and release planning.
Skills tested
- Explain the Agile Manifesto values and how each one changes a tester's daily work.
- Describe how Extreme Programming, Scrum and Kanban organize the team's work.
- Help write user stories that hold the card, conversation and confirmation parts.
- Take part in retrospectives and in release and iteration planning as a tester.
- Explain how continuous integration gives the team fast feedback on each change.
Questions by topic
- Collaborative User Story Creation9
- Continuous Integration5
- Agile Software Development and the Agile Manifesto6
- Release and Iteration Planning6
- Retrospectives4
- Whole-Team Approach7
- Agile Software Development Approaches (Kanban)2
- Agile Software Development Approaches5
- Agile Principles in Testing1
- Continuous Integration Testing1
- Writing Testable Acceptance Criteria1
- Definition of Done2
- Agile Project Management2
Fundamental Agile Testing Principles, Practices, and Processes47 questions
This domain compares testing in traditional and agile projects. Candidates see how test levels, work products and configuration management change, how to report status in short iterations, and which skills an agile tester needs.
Skills tested
- Compare how testing and development activities overlap in agile and traditional projects.
- Report test status and product quality with task boards, burndown charts and stand-up meetings.
- Keep regression risk low by updating manual and automated test cases every iteration.
- Weigh the organizational options for independent testing in an agile team.
- Describe the role and the skills of a tester in an agile team.
Official topics
- The Differences between Testing in Traditional and Agile Approaches
- Status of Testing in Agile Projects
- Role and Skills of a Tester in an Agile Team
Agile Testing Methods, Techniques, and Tools101 questions
This domain puts the methods to work. Candidates use TDD, ATDD and BDD, plan tests with the test pyramid and the testing quadrants, assess quality risks, estimate test effort and choose tools for an agile project.
Skills tested
- Tell TDD, ATDD and BDD apart and pick the one that fits a given need.
- Use the test pyramid and the testing quadrants to plan a balanced set of tests.
- Assess the quality risks of a story and estimate its test effort with planning poker.
- Write acceptance criteria and design functional and non-functional black box tests from them.
- Choose tools for task tracking, builds, configuration management and virtual test environments.
Official topics
- Agile Testing Methods
- Assessing Quality Risks and Estimating Test Effort
- Techniques in Agile Projects
- Tools in Agile Projects
Requirements
- Required: an ISTQB Foundation Level certificate, such as CTFL v4.0 or any earlier version.
- Recommended: about six months of work on agile projects.
- Recommended: a sound grasp of the Agile Manifesto and its principles.
About the CTFL-AT exam
ISTQB's CTFL-AT exam is for certified Foundation Level testers who work in agile teams or are about to join one. It checks how a tester fits into the whole team: helping to write testable user stories, testing within short iterations, and using practices such as test-driven development and exploratory testing. ISTQB notes that its CTFL v4.0 syllabus already covers agile testing, so the exam adds most for holders of an earlier Foundation certificate. Passing earns the ISTQB Certified Tester Foundation Level - Agile Tester certification.
The PlanetCert practice test gives the most questions to Agile Testing Methods, Techniques, and Tools, such as the test pyramid and the testing quadrants. The explanations show why one practice fits a case better than another, for example why acceptance test-driven development (ATDD) starts from acceptance criteria while test-driven development (TDD) starts from a unit test. Flashcard mode suits the many named practices, such as the card, conversation and confirmation parts of a user story. Brainy AI Assistant can walk through a planning poker round or explain how a tester's work differs in Scrum and in Kanban.
How to earn the certification
- Earns
- ISTQB Certified Tester Foundation Level - Agile TesterFoundation
ISTQB issues the certificate for life, so it needs no renewal.
- Before
- CTFL-V4-0 CTFL v4.0
ISTQB requires a Foundation Level certificate before CTFL-AT. Version 4.0 or any earlier version counts.
- CTFL-V4-0 CTFL v4.0
- After
- CTAL-ATT Agile Technical Tester
The Advanced Level step in ISTQB's Agile stream, open to holders of this certificate.
- CTAL-ATT Agile Technical Tester
How to prepare for CTFL-AT
- 1
Read the syllabus chapter by chapter
ISTQB's Agile Tester syllabus has three chapters and gives every learning objective a K-level. Mark the K3 objectives, because those ask candidates to apply a technique, not only to recall it.
- 2
Learn the manifesto and the 3C concept
Questions often quote one of the manifesto's values or a part of a user story. Write the values, the principles and the card, conversation and confirmation parts from memory until none is missing.
- 3
Turn one feature into tests
Take a small feature, write it as a user story, check it against INVEST and add acceptance criteria. Then turn the criteria into ATDD tests and BDD scenarios in Given-When-Then form.
- 4
Run one timed exploratory session
Write a test charter for a simple web form, test it in one uninterrupted session, and record notes and defects. This makes session-based test management concrete.
- 5
Practise by chapter, then in full
Work through the CTFL-AT practice test in Study Mode one chapter at a time, then take full runs in Timed Mode. Ask Brainy AI Assistant to explain any missed question on the testing quadrants.
Start a timed CTFL-ATrun
Who CTFL-AT is for
- Testers and QA engineers who move from traditional projects into Scrum or Kanban teams.
- Test analysts already in agile teams who want their practice checked against the ISTQB syllabus.
- Test leads responsible for testing across the iterations of an agile project.
- Developers and business analysts who share acceptance testing with the rest of the team.
Typical job titles: Software tester · QA engineer · Test analyst · Agile tester · Test lead
CTFL-AT glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- 3C concept
- The view of a user story as three parts: the card that records it, the conversation that explains it, and the confirmation through acceptance criteria.
- Acceptance Test-Driven Development (ATDD)
- A practice in which the team turns a story's acceptance criteria into tests before the feature is built.
- Agile Manifesto
- A short statement of values for software work, such as individuals and interactions over processes and tools, backed by a list of principles.
- Behavior-Driven Development (BDD)
- A practice that describes expected behavior as Given-When-Then scenarios, which business staff can read and tools can run as tests.
- Burndown charts
- Charts that show how much work is left in an iteration or a release, so the team can see whether it is on track.
- Continuous integration
- Merging and building code changes often, with automated tests on every build, so faults show up soon after they are made.
- Definition of Done
- The team's agreed conditions that a backlog item must meet before it counts as finished, such as passed tests.
- Exploratory testing
- Testing in which the tester designs and runs tests at the same time, and the results of each test guide the next one.
- INVEST technique
- A check that a user story is independent, negotiable, valuable, estimable, small and testable.
- Planning poker
- An estimation method in which each estimator picks a card with an effort value in private, then the team discusses large differences.
- Power of three
- The idea that a business representative, a developer and a tester take part together in every discussion of a feature.
- Retrospective
- A meeting at the end of an iteration where the team discusses what went well, what did not, and what to change next.
- Session-based test management
- A way to manage exploratory testing in uninterrupted, time-boxed sessions, each with a charter and a short record of what was found.
- Test charter
- A short plan for an exploratory session that names the test conditions to cover in a fixed amount of time.
- Test pyramid
- A model with many small, fast tests at the lower levels and fewer tests at each higher level, up to a few system tests at the top.
- Test-Driven Development (TDD)
- A practice in which a developer writes a failing unit test first, writes just enough code to pass it, then improves the code.
- Testing quadrants
- A model that groups test types by whether they are business-facing or technology-facing, and whether they support the team or critique the product.
- Whole-team approach
- The practice in which developers, testers and business representatives share responsibility for quality, instead of leaving it to the testers.