ISTQB Certified Tester Foundation Level - Agile Tester

From the ISTQB CTFL-AT Syllabus v4.0, Section 1.2 The 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 supports Option C, where Kanban boards are used for visualizing active tasks increasing transparency and progress visibility. Let's clarify the other options: Option A: The five values listed communication, simplicity, feedback, courage, and respect are associated with Extreme Programming (XP), not Kanban.
Option B: Scrum does not prescribe specific testing techniques, but it also does not dictate how development must be done, which makes this atrick answer that's partially true but not complete or precise enough to be correct.
Option D: The roles are incorrectly named. The correct Scrum roles are: Product Owner, Scrum Master, Developers (Development Team is no longer a formal term post-2020 Scrum Guide)

References:
CTFL-AT Syllabus v4.0, Section 1.2
Scrum Guide 2020 . Official Roles
Learning Objective (K1) . Recognize common Agile development practices

From CTFL-AT Syllabus v4.0, Section 3.2 Test-Driven Development, and Section 3.4 Testing Quadrants: "TDD focuses on writing unit tests before code is implemented. These are technology-facing tests that support the team and are categorized under Q1."

Therefore, Option D is correct.
Option A involves performance/security testing.
Options B and C involve business-facing tests, not applicable to TDD.

References:
CTFL-AT Syllabus v4.0, Sections 3.2 and 3.4
Learning Objective (K2) - Identify test types and quadrants.

The tester within an Agile team is not responsible for ensuring all project status meetings are held according to the plan. This is typically a task for the Scrum Master, who facilitates the meetings and ensures that the team follows the Agile principles and practices. The tester within an Agile team is responsible for ensuring the appropriate testing tasks are scheduled during iteration planning, suggesting improvements in team retrospectives, and working with business stakeholders to clarify requirements.
These are all tasks that contribute to the quality of the software and the testing process, as well as the collaboration and communication within the team and with the customers.

References:
ISTQB Foundation Level Agile Tester Syllabus, Section 2.3.1, page 171;

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 begins.
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.

References:
ISTQB Foundation Level Agile Tester Syllabus, Section 2.3.2, page 182;

A tester on an Agile project typically performs the following tasks: 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;

Testers replace developers in writing unit test automation scripts. Comprehensive : 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.

From CTFL-AT Syllabus v4.0, Section 2.2 Quality Risk Analysis: "The whole team contributes to quality risk analysis. While the Product Owner may identify business risks, the team collectively assesses risk levels based on impact and likelihood."
Thus, Option A is correct collaborative assessment ensures accurate risk-driven testing and planning.
Option B is wrong poor user stories should be addressed, not ignored.
Option C is incorrect risk level, not item count, determines depth of testing.
Option D is false effort estimation considers multiple factors, not just risk.

References:
CTFL-AT Syllabus v4.0, Section 2.2 Learning Objective (K2) . Understand risk-based testing in Agile

CTFL-AT Section 2.2 defines risk as impact x likelihood.
Option B directly supports assessing risk levels to guide testing.
Options A, C, and D do not directly support risk analysis per the syllabus.

References:
CTFL-AT Syllabus v4.0, Section 2.2

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 information. 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 development.

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

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 guide the tester's exploration and document the results. A time box is a fixed period allocated for an exploratory session. It helps keep focus and limits scope. A time box should not be too long, as it may reduce concentration and creativity. A recommended duration is between 45 minutes and 2 hours.

Tests should be designed and executed within each session using heuristics, creativity, and intuition: Exploratory testing is iterative and interactive. The tester designs and executes tests based on observations and feedback from the system. The tester uses heuristics (rules of thumb that help simplify complex problems), along with creativity and intuition, to generate test ideas and make informed decisions.

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 testing:

Option 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 separates test design from test execution, which contradicts the core of exploratory testing. It also uses excessively long time boxes, which can harm focus and creativity.
Additionally, it reduces collaboration within the Agile team by isolating testers from developers and stakeholders.

Option 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 exploratory testing sessions. It also overlooks heuristics, creativity, and intuition as structured methods for generating test ideas. It suggests that exploratory testing is random and unstructured, which is a misconception-exploratory testing is disciplined and systematic.

Option 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 separates test design from execution. It also uses testers who were not part of the sprint, which may limit their understanding of the product and user needs. It does not use test charters and does not rely on heuristics, creativity, or intuition, all of which are essential to exploratory testing.

The 3C concept of user stories consists of three elements: card, conversation, and confirmation. The card is a written description of the user story that captures the essence of the feature or functionality from the user's perspective. The conversation is a dialogue between the product owner and the development team to clarify the details, assumptions, and expectations of the user story. The confirmation is a set of criteria or tests that verify that the user story is implemented correctly and meets the user's needs. Therefore, by applying the 3C concept, the correct statement is A, as the conversation should include the acceptance criteria discussion. This will help the team understand the scope, priority, and value of the user story, as well as the conditions of satisfaction that the product owner expects.
The other statements are incorrect, as they violate the 3C concept. Statement B is wrong, as the card should contain the user story, not the requirements. The user story is a brief and informal way of expressing the user's goal and benefit, while the requirements are more detailed and specific descriptions of how the software should work. The requirements can be added later as part of the conversation or confirmation.
Statement C is wrong, as the product owner has written a user story, but confirmation is still needed. The confirmation is a vital part of the 3C concept, as it ensures that the user story is testable, measurable, and verifiable. The confirmation also helps avoid ambiguity, misunderstanding, or disagreement between the product owner and the development team.
Statement D is wrong, as the conversation is required and the team should not start developing without it.
The conversation is an essential part of the 3C concept, as it allows the team to ask questions, share ideas, and collaborate with the product owner to refine the user story and reach a shared understanding.
The conversation also helps identify the dependencies, risks, and assumptions that may affect the implementation of the user story.

References:
ISTQB Foundation Level Agile Tester Syllabus, Section 2.2.1, pages 16-17
Effective User Stories - 3C's
and INVEST Guide, Section "The 3 C's (Card, Conversation, Confirmation) of User Stories."