iSQI CTFL-AT Certified Tester Foundation Level Agile Tester Exam Practice Test

Exploratory testing is a testing approach that emphasizes learning, creativity, and adaptability. It involves simultaneous test design and test execution, where the tester uses heuristics, intuition, and experience to explore the system under test and discover new information12. Exploratory testing can be performed in an Agile project to complement other testing activities, such as test-driven development, behavior-driven development, and acceptance test-driven development12.

The correct approach to adopt for exploratory testing in an Agile project is D, as it follows the best practices for exploratory testing1234:

Ask experienced testers to prepare test charters for time boxed sessions lasting no more than 2 hours: A test charter is a brief document that describes the scope, objective, and strategy of an exploratory testing session. A test charter helps to guide the tester’s exploration and to document the results. A time box is a fixed period of time allocated for an exploratory testing session. A time box helps to focus the tester’s attention and to limit the scope of exploration. A time box should not be too long, as it may reduce the tester’s concentration and creativity. A recommended duration for a time box is between 45 minutes and 2 hours.

Tests should be designed and executed within each session using heuristics, creativity and intuition: Exploratory testing is an iterative and interactive process, where the tester designs and executes tests based on the observations and feedback from the system under test. The tester uses heuristics, which are rules of thumb or shortcuts that help to simplify the testing problem and to generate test ideas. The tester also uses creativity and intuition, which are mental abilities that help to generate novel and useful solutions and to make judgments based on incomplete or uncertain information.

The incorrect approaches to adopt for exploratory testing in an Agile project are A, B, and C, as they violate the principles and practices of exploratory testing1234:

A: Allocate independent testers to design exploratory tests using test charters in time boxed sessions. Plan to run all sessions in parallel with each session lasting more than 5 hours: This approach is incorrect because it does not involve simultaneous test design and test execution, which is the essence of exploratory testing. It also uses too long time boxes, which may reduce the tester’s concentration and creativity. It also does not leverage the collaboration and communication within the Agile team, as it isolates the testers from the developers and other stakeholders.

B: Ask experienced testers to try and find new defects by using the system without the constraint of documentation and tools: This approach is incorrect because it does not use test charters, which are essential for guiding and documenting the exploratory testing sessions. It also does not use heuristics, creativity, and intuition, which are important for generating test ideas and making decisions. It also implies that exploratory testing is an unstructured and random activity, which is a common misconception. Exploratory testing is a disciplined and systematic approach that requires planning, analysis, and evaluation.

C: Use testers who have not been involved in the sprint to write new test cases from the user stories. These test cases are then executed in a time boxed session for the sprint: This approach is incorrect because it does not involve simultaneous test design and test execution, which is the essence of exploratory testing. It also uses testers who have not been involved in the sprint, which may reduce their understanding of the system under test and the customer needs. It also does not use test charters, which are essential for guiding and documenting the exploratory testing sessions. It also does not use heuristics, creativity, and intuition, which are important for generating test ideas and making decisions.

Comprehensive and Detailed Explanation From Exact Extract:

From theISTQB CTFL-AT Syllabus v4.0, Section 1.2The Fundamentals of Agile Software Development, Kanban is explained as:

"In Kanban, work is visualized using a board that shows tasks in various states of progress. The transparency of the workflow helps teams identify bottlenecks, improve flow, and collaborate effectively."

This directly supportsOption C, whereKanban boardsare used for visualizing active tasks — increasingtransparencyandprogress visibility.

Let’s clarify the other options:

Option A: The five values listed —communication, simplicity, feedback, courage, and respect— are associated withExtreme Programming (XP), not Kanban.

Option B: Scrumdoes not prescribe specific testing techniques, but italso does not dictate how development must be done, which makes this atrick answerthat’s partially true butnot complete or precise enoughto be correct.

Option D: The roles areincorrectly named. The correct Scrum roles are:

Product Owner,

Scrum Master,

Developers (Development Team is no longer a formal term post-2020 Scrum Guide)

Acceptance test criteria are the conditions that a user story must satisfy to be accepted by the customer or the stakeholder. They are usually derived from the user story and its acceptance scenarios, and they should cover the functional and non-functional requirements of the user story. Acceptance test criteria should be clear, concise, testable, and agreed upon by the team and the customer or the stakeholder.

In this case, the user story describes the business rule for approving a loan request based on the customer’s income, repayment history, and loan amount. The user story also specifies the roles of the customer assistant and the bank manager in the process. Therefore, the acceptance test criteria should verify that the user story is implemented correctly and that the system behaves as expected for different scenarios and inputs.

The following test cases can be treated as acceptance test criteria for the above user story:

As a customer assistant I can log in to the system and check the history of the customer account for the last year. This test case verifies that the customer assistant can access the system and view the customer’s income information, which is one of the factors for approving the loan request.

As a customer assistant I can log in to the system and check the history of the customer debts and repayments. This test case verifies that the customer assistant can access the system and view the customer’s repayment history, which is another factor for approving the loan request.

As a bank manager I can log in to the system and receive the information of all requests waiting for approval. This test case verifies that the bank manager can access the system and see the list of loan requests that have been prepared by the customer assistant, and that the system provides the necessary information for each request.

As a bank manager I can log in to the system and decide whether to approve a loan for a customer. This test case verifies that the bank manager can access the system and perform the approval action for a loan request, and that the system applies the business rule correctly and updates the status of the request accordingly.

The following test cases cannot be treated as acceptance test criteria for the above user story:

As a customer assistant I can log in to the system and change my password. This test case is not related to the user story, as it does not verify any of the functional or non-functional requirements of the user story. It is a generic test case that applies to any user of the system, not specific to the customer assistant role or the loan approval process.

As a bank manager I can log in to the system within 10 seconds. This test case is not related to the user story, as it does not verify any of the functional or non-functional requirements of the user story. It is a performance test case that applies to any user of the system, not specific to the bank manager role or the loan approval process.

Comprehensive and Detailed Explanation From Exact Extract:

FromCTFL-AT Syllabus v4.0, Section 4.3Test Automation and Continuous Integration, it states:

"Short iterations and continuous integration require well-designed automated test suites, and teams should adopt good practices for test design and implementation from the start."

OptionBis correct because it highlights theneed for proactive test design practicesto handle frequent changes — a key Agile challenge.

Option Amixes concepts:version controlrelates to code, not directly to regression management.

Option Cis incorrect — regressionrisk increaseswhen code is modified.

Option Dis misleading — tests may becomeobsoleteor needrefactoring, sono test is permanently untouchable.

Comprehensive and Detailed Explanation From Exact Extract:

FromCTFL-AT Syllabus v4.0, Section 3.3Behavior-Driven Development, and 3.2Test-Driven Development:

"TDD focuses on writing unit tests that guide the implementation of code."

"BDD focuses on writing scenarios that describe the behavior of the software, often using a language that stakeholders can understand."

Thus,Option Bis accurate — TDD targetscode implementation, BDD targetsbehavioral expectations.

Option Ais incorrect —TDD is at unit level, whileBDD is at the acceptance level.

Option Cis false —BDD is more readable and accessiblefor non-technical stakeholders.

Option Dconfuses BDD withuser story formats; BDD usesGiven-When-Then, not the "As a... I want..." template.

Testers replace developers in writing unit test automation scripts. Comprehensive Explanation: The integration of development and testing activities in Agile projects is based on the principle of cross-functional teamwork, where all team members collaborate and share their skills and knowledge to achieve a common goal. In the context of testing, this means that testing is not seen as a separate activity or phase, but as an integral part of the development process. Therefore, the following sentences are correct:

While developers develop automated unit test scripts, testers write automated system level tests. This is an example of how developers and testers can work in parallel and complement each other’s testing efforts. Developers can focus on testing the internal quality of the code, while testers can focus on testing the external quality of the product.

Developers write acceptance criteria and test cases, together with testers. This is an example of how developers and testers can work together to define and verify the user requirements and expectations. Developers can provide their technical expertise and input, while testers can provide their business and user perspective and feedback.

Developers and testers may work as a pair to develop and test a feature. This is an example of how developers and testers can work closely and interactively to deliver a feature. Developers and testers can exchange ideas, suggestions, and information, and support each other in the coding and testing tasks.

The following sentence is incorrect:

Testers replace developers in writing unit test automation scripts. This is not a valid example of the integration of development and testing activities in Agile projects, because it implies that testers take over the responsibility of developers, rather than collaborate with them. Testers should not replace developers in writing unit test automation scripts, because developers have more knowledge and experience in coding and debugging, and because unit testing is an essential part of the development process. Testers should instead work with developers to ensure that the unit test automation scripts are adequate, effective, and maintainable. References: ISTQB® Foundation Level Agile Tester Syllabus1, Section 1.2.1, page 9; ISTQB® Glossary of Testing Terms2, version 4.0, pages 16 and 55.

 Equivalence partitioning is a black-box test design technique that divides the input domain of a system into classes of data from which test cases can be derived. The idea is that if a system works correctly for a representative value from an equivalence class, it will work correctly for all values from that class, and vice versa. Equivalence partitioning reduces the number of test cases by eliminating redundant ones. For the given user story, equivalence partitioning is the most suitable technique because it can test the different outcomes of the annual car tax calculation based on the power of the vehicle, which is the main input for the system. By testing one value from each partition, the tester can verify the functionality of the system and detect any errors in the calculation logic. The other techniques are not as suitable because they do not focus on the input domain of the system, but rather on the conditions, transitions, or scenarios that are not directly related to the user story. References:

: ISTQB® Foundation Level Agile Tester Syllabus, Version 2014, Section 2.2.2

: ASTQB Agile Tester Certification Resources, Agile Testing Foundations, Chapter 3, Section 3.2.2

: 3

Comprehensive and Detailed Explanation From Exact Extract:

FromCTFL-AT Syllabus v4.0, Section 4.3Test Automation and Continuous Integration, it states:

"Automated tests help detect regression defects quickly and can be run frequently during development, thus reducing regression risk."

So,Option Dis correct —test automation supports regression testingwithin iterations, making it an essential Agile practice.

Option Ais false —automated unit tests are designed to be fastand are ideally run with every check-in.

Option Bis incorrect — more code changesincrease, not reduce, regression risk.

Option Cis incorrect —technical debt can still existwith automation if the automation is poorly designed or not maintained.

Risk-based testing is a technique that prioritizes testing activities based on the level of risk associated with each feature or requirement. The level of risk is usually calculated by multiplying the probability and impact of each risk. The higher the risk level, the more testing effort should be allocated to mitigate the risk. In this case, the risk level for each option is as follows: A. Risk level = Low x Low = Low B. Risk level = Low x High = Medium C. Risk level = High x High = High D. Risk level = High x Low = Medium Therefore, the highest risk level is C, followed by B and D, and then A. The User Story for the Operator-Instructions module should be tested according to this risk order, starting with C, then B, then D, and finally A. Hence, the answer is B, as it is the second highest risk level and should be tested after C. References: ISTQB Foundation Level Agile Tester Extension Syllabus1, page 16; ISTQB Agile Tester Sample Exam2, question 18.

Comprehensive and Detailed Explanation From Exact Extract:

From theCTFL-AT Syllabus v4.0, Section 2.2Release and Iteration Planning, testers actively contribute during release planning:

"During release planning, testers collaborate with the team to understand the scope of the release and help identify any high-level test considerations. They also participate in quality risk analysis and help in estimating test effort."

Furthermore, it is noted:

"Testers are involved in defining and refining user stories and acceptance criteria, and contribute to quality risk assessments."

Therefore,Option Cis accurate as it reflects the tester's involvement inprioritizing user storiesand conductingquality risk analysisduring release planning.

Option Ais incorrect because defining and redefining the product backlog is primarily the role of theProduct Owner, and the test approach isiteration-specific, not fixed for the full release.

Option Bis inaccurate — breaking down stories into tasks is generally part ofiteration (Sprint) planning, not release planning.

Option Dis incorrect —release plans can changein Agile to accommodate changing business needs.

The Agile Manifesto is a declaration of four values and twelve principles that guide the Agile software development approach12. The four values of the Agile Manifesto are12:

Individuals and interactions over processes and tools

Working software over comprehensive documentation

Customer collaboration over contract negotiation

Responding to change over following a plan

These values emphasize the importance of human collaboration, working product, customer feedback, and adaptability over rigid processes, extensive documentation, fixed contracts, and predefined plans. The values do not imply that the items on the right are not important, but rather that the items on the left are more important and should be prioritized.

Therefore, the statement that is NOT a value from the Agile Manifesto is B, as it contradicts the first value of the Agile Manifesto. The correct statement should be “Individuals and interactions over processes and tools”. References: ISTQB Foundation Level Agile Tester Extension Syllabus1, page 10; ISTQB Agile Tester Sample Exam2, question 1.

 Behavior-Driven Development (BDD) is a software development approach that allows a developer to define accurate unit tests focused on business needs. BDD uses a common language that is understandable by both technical and non-technical stakeholders, such as Given-When-Then scenarios. BDD helps to align the development and testing activities with the customer expectations and business goals . References:

: ISTQB® Foundation Level Agile Tester Syllabus, Version 2014, Section 2.2.2

: ASTQB Agile Tester Certification Resources, Agile Testing Foundations, Chapter 3, Section 3.2.2

The whole-team approach is a principle of agile testing that involves everyone with different knowledge and skills to ensure project success. The whole-team approach means that the business representatives, testers, and developers work together in every step of the development process, from planning to delivery. The whole-team approach aims to enhance communication and collaboration within the team, leverage the various skill sets of the team members, and make quality everyone’s responsibility12. Therefore, the statement C is the most direct advantage of the whole-team approach, as it captures the essence of the principle and its benefits. The other statements are not directly related to the whole-team approach, or are incorrect. Statement A is about continuous integration, which is a practice of agile development that involves having at least once a day an automated build and test process that detects integration errors early and quickly. Continuous integration is not a direct consequence of the whole-team approach, although it may be facilitated by it13. Statement B is about avoiding requirements misunderstandings, which may be a benefit of the whole-team approach, but not the most direct one. The whole-team approach does not only focus on requirements, but also on design, implementation, testing, and delivery. Moreover, avoiding requirements misunderstandings may also depend on other factors, such as the quality of the user stories, the use of acceptance criteria, and the feedback from the customers and users14. Statement D is incorrect, as it contradicts the whole-team approach. The whole-team approach does not reduce the involvement of business representatives, but rather increases it. Business representatives are an integral part of the whole-team approach, as they provide the vision, the value, and the validation of the product. They collaborate with the testers and developers to define the features, prioritize the backlog, and verify the outcomes12. References: ISTQB Foundation Level Agile Tester Syllabus1, Section 1.2.1, page 9; What is Whole Team Approach in Agile Testing?2, Section What is Whole Team Approach?; Continuous Integration3, Section What is Continuous Integration?; Effective User Stories - 3C’s and INVEST Guide4, Section The 3 C’s (Card, Conversation, Confirmation) of User Stories.

Cross-functional teamwork is an important organizational and behavioral best practice for a tester in the SCRUM team that should have also been practiced when using the sequential model. Cross-functional teamwork means that all team members, regardless of their functional roles, collaborate and share their skills and knowledge to achieve a common goal. In the context of testing, this means that testing is not seen as a separate activity or phase, but as an integral part of the development process. All team members contribute to testing in various ways, such as:

Involving people with the test strategy, test planning and execution as well as test reporting. This can help ensure that the testing activities are aligned with the business objectives, the user needs, and the technical requirements. It can also help improve the test coverage, the test quality, and the test efficiency.

Sharing the responsibility for testing among the team members. This can help reduce the workload and the dependency on a single tester or a testing team. It can also help increase the feedback and the communication among the team members, and foster a culture of quality and learning.

Leveraging the diverse skills and perspectives of the team members. This can help enhance the test design and the test execution by applying different techniques, tools, and approaches. It can also help identify and address the risks, the issues, and the opportunities for improvement from various angles. References: ISTQB® Foundation Level Agile Tester Syllabus1, Section 1.2.1, page 9; ISTQB® Glossary of Testing Terms2, version 4.0, page 16.

A tester on an Agile project typically performs the following tasks12:

Implementing test strategy: A tester helps to define and implement the test strategy for the Agile project, which includes the test approach, test levels, test types, test techniques, test tools, test environment, test data, test metrics, and test documentation.

Measuring and reporting test coverage: A tester measures and reports the test coverage of the product features and quality attributes, such as functionality, usability, performance, security, etc. Test coverage can be expressed in terms of test cases, test scenarios, test sessions, test conditions, test data, code, etc.

Coaching development team in relevant aspects of testing: A tester coaches the development team in relevant aspects of testing, such as test design, test execution, test automation, test-driven development, behavior-driven development, exploratory testing, etc. A tester also helps the development team to improve their testing skills and practices.

The following tasks are not typically performed by a tester on an Agile project:

Documenting business requirements: Business requirements are usually documented by the product owner or the business analyst, not by the tester. The tester may review and provide feedback on the business requirements, but the tester is not responsible for documenting them.

Executing test-driven development tests: Test-driven development tests are usually executed by the developers, not by the tester. The tester may assist the developers in creating and reviewing the test-driven development tests, but the tester is not responsible for executing them.

Therefore, the correct answer is C, as it contains the tasks that are typically performed by a tester on an Agile project. References: ISTQB Foundation Level Agile Tester Extension Syllabus1, pages 14-15, 18-19, 22-23; ISTQB Agile Tester Sample Exam2, question 17.

Comprehensive and Detailed Explanation From Exact Extract:

FromCTFL-AT Syllabus v4.0, Section 2.2Release and Iteration Planning, it describes Planning Poker as:

"Planning Poker involves group discussion, especially from the highest and lowest estimators, to ensure that different perspectives and assumptions are aligned, which leads to more accurate and shared understanding of the effort involved."

Thus,Option Cis correct — Team B usesdiscussion-based estimation, which is a corebenefitof Planning Poker.

Option Ais speculative — we cannot know the actual effort difference.

Option Bis incorrect — convergence without discussion may indicatelack of engagement or pressure to agree.

Option Dis false — Planning Poker isnot based on averaging, but onconsensus.

An Agile retrospective is a regular meeting where the team reflects on their work process and identifies the areas for improvement12. The following statements about Agile retrospectives are correct12:

During Agile retrospectives, testers should be encouraged to provide constructive suggestions on both testing and non-testing activities, as testing is an integral part of the Agile team and testers can contribute to the overall quality of the product and the process.

In an Agile retrospective, the moderator can encourage and make sure that good practices are kept by the team, by asking what the team is doing well. This helps to reinforce the positive aspects of the team’s work and to appreciate the team members’ efforts and achievements.

Agile retrospectives should be focused mainly on impediments that are within the control of the team because these issues are more actionable and can be resolved by the team. Impediments that are outside the control of the team should also be discussed, but they may require the involvement of other stakeholders or external parties to be addressed.

The following statement about Agile retrospectives is incorrect12:

Unlike working sessions or meetings held in non-Agile projects, Agile retrospectives do require follow-up activities. The team should agree on the action items that result from the retrospective and assign them to the responsible team members. The team should also monitor the progress and effectiveness of the action items in the next iteration and review them in the next retrospective.

Therefore, the correct answer is B, as it is the only statement that is correct about Agile retrospectives. References: ISTQB Foundation Level Agile Tester Extension Syllabus1, page 24; ISTQB Agile Tester Sample Exam2,

Comprehensive and Detailed Explanation From Exact Extract:

From theCTFL-AT Syllabus v4.0, Section 2.1User Stories and Acceptance Criteria, it states:

"Acceptance criteria are defined collaboratively and refined during the conversation to ensure mutual understanding. They may be added or updated as new insights emerge."

This supportsOption D, which reflects how acceptance criteria evolveduring conversations— a key component of the"Card, Conversation, Confirmation"model.

Option Ais incorrect — the user story istestable, especially with the acceptance criterion.

Option Bis false — the story provides clear user value (printed hard copy for daily records).

Option Cis misleading — the Given-When-Then formatsupportsdiscussions; it doesn’t replace them.

Comprehensive and Detailed Explanation From Exact Extract:

FromCTFL-AT Syllabus v4.0, Section 1.2Fundamentals of Agile Software Development, it states:

"Kanban is a lean approach that uses visualization (typically via a task board) to manage work in progress and improve workflow. Unlike Scrum, iterations in Kanban are optional."

Thus,Option C (Kanban)is correct. It emphasizesvisualizationand doesnot require fixed-length iterations.

Option A (Scrum)is iteration-based.

Option B (Continuous integration)is a practice, not a development approach.

Option D (Slack)is a communication tool, not a methodology.

Comprehensive and Detailed Explanation From Exact Extract:

FromISTQB Glossary (also referenced in CTFL-AT):

"Configuration management is a discipline applying technical and administrative direction and surveillance to: identify and document the functional and physical characteristics of a configuration item, control changes to those characteristics, record and report change processing and implementation status, and verify compliance."

Thus,Option Dis the formal and accurate definition ofConfiguration Management.

Option Adescribestest control, not configuration management.

Option Brefers tosession-based testing, unrelated to configuration management.

Option Crefers tocombinatorial test design, not configuration control.

 Exploratory testing is a type of testing that involves simultaneous learning, test design, and test execution. It is suitable for Quadrant 3 because it is business facing and product critique, meaning that it focuses on the user’s perspective and the quality attributes of the product. Exploratory testing can help discover new risks, requirements, and defects that may not be covered by other test levels and test types. It can also provide feedback on the usability, functionality, and reliability of the product. References: ISTQB® Foundation Level Agile Tester Syllabus1, Section 2.3.2, page 17; ISTQB® Glossary of Testing Terms2, version 4.0, page 23.

A testable acceptance criterion is a condition that can be verified or measured objectively by the tester, customer, or stakeholder. It should be specific, measurable, achievable, relevant, and time-bound (SMART). A testable acceptance criterion should also be written from the user’s perspective, achievable within the sprint, and written before development begins1.

Among the four options, only option C meets these criteria. It is specific (the response time to confirm a customer submission), measurable (must not exceed 5 seconds), achievable (within the technical and business constraints), relevant (to the user’s needs and expectations), and time-bound (must be met in every sprint). It is also written from the user’s perspective, testable (by measuring the response time), and written before development (as part of the user story definition).

Option A is not testable because it is vague and subjective. What does it mean to support business processes? How can this be verified or measured? Option B is also not testable because it is subjective and ambiguous. What does it mean to be easy to use? How can this be verified or measured? Option D is not testable because it is not written from the user’s perspective. It is an internal quality criterion for the testing team, not an acceptance criterion for the product or feature.

Independence in testing is the degree of separation between the person who tests something and the person who developed it. Independence can help to reduce bias, increase objectivity, and provide different viewpoints. However, independence also has some drawbacks, such as increased communication overhead, reduced collaboration, and delayed feedback. In agile projects, testers are usually embedded in the agile teams to perform many of the testing tasks, such as unit testing, integration testing, acceptance testing, etc. This provides a high level of collaboration and fast feedback, but also reduces the independence of the testers. Testers from an independent test team who do not get involved with the agile team, but are assigned to do System Testing once all sprints are completed, would provide the most independence for testers working with agile teams. However, this would also introduce many disadvantages, such as lack of alignment with the agile principles, loss of context and domain knowledge, delayed defect detection and resolution, and increased risk of missing customer expectations. References: ISTQB® Foundation Level Agile Tester Syllabus, Section 1.1.2, page 8; ASTQB Agile Tester Certification Resources, Section 1.1.2, page 8.

Comprehensive and Detailed Explanation From Exact Extract:

From theCTFL-AT Syllabus v4.0, Section 1.3The Whole-Team Approach, the benefit of the whole-team approach is:

"All team members, including testers, work together in all project phases. This encourages collaboration and shared responsibility, which leads to the availability of working software and immediate feedback on changes."

Specifically, it is noted:

"One benefit of the whole-team approach is the continuous availability of working, executable software, which can be tested at any point in the iteration."

This makesOption Athe correct answer.

Let’s analyze the others:

Option Brelates toAcceptance Test-Driven Development (ATDD), not the whole-team approach specifically.

Option Cis a benefit ofTDD, not of the whole-team approach.

Option Drefers tocontinuous integration, not directly tied to the whole-team concept.