ISTQB CTFL course and practice exam: Certified Tester Foundation Level v4.0
This ISTQB CTFL course has 32 video lessons and 73 graded labs, and its ISTQB CTFL practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
Testing fundamentals, techniques and test management
Prepares you for ISTQB CTFL v4.0: testing throughout the lifecycle, static testing, test techniques, test management and tools.
Beginner · 3 hours · 32 lessons · 73 labs
ISTQB CTFL exam guide
The ISTQB CTFL exam (ISTQB Certified Tester Foundation Level (CTFL) v4.0, by ISTQB (International Software Testing Qualifications Board)): 60 minutes (75 minutes for non-native language speakers); questions: 40; pass mark: 26 out of 40 (65%); cost: set by local exam providers; ISTQB does not publish a global price.
- Format: Multiple-choice, 40 questions, 1 point each
- Duration: 60 minutes (75 minutes for non-native language speakers)
- Questions: 40
- Pass mark: 26 out of 40 (65%)
- Cost: Set by local exam providers; ISTQB does not publish a global price
- Valid for: Lifetime; serves as prerequisite for advanced ISTQB certifications
- Delivery: Via accredited ISTQB Exam Providers (classroom, online, or at testing centres)
- Prerequisites: None
Exam domains and weights
- Fundamentals of Testing: 20%
- Testing Throughout the Software Development Lifecycle: 15%
- Static Testing: 10%
- Test Analysis and Design: 27.5%
- Managing the Test Activities: 22.5%
- Tool Support for Testing: 5%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 ISTQB CTFL sample questions with answers: free to read, no account needed.
Common questions
How long is the ISTQB CTFL exam?
The ISTQB CTFL exam lasts 60 minutes (75 minutes for non-native language speakers).
How many questions are on the ISTQB CTFL exam?
40.
What is the ISTQB CTFL passing score?
The pass mark is 26 out of 40 (65%).
How much does the ISTQB CTFL exam cost?
Set by local exam providers; ISTQB does not publish a global price.
Is there a free ISTQB CTFL practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: Certified Tester Foundation Level (CTFL) v4.0 overview (ISTQB) (ISTQB (International Software Testing Qualifications Board)), checked 2026-10-02.
Who it is for
Beginner level.
For anyone who tests software or wants to: new testers, developers, business analysts and product owners preparing for the ISTQB Foundation Level exam.
What you don't need yet:
- No programming needed
- No testing job yet
- Nothing to install: the labs run from the course page
No prerequisites. You can start here.
Take next:
- Automated Testing, TDD & Quality Engineering — Beginner
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
ISTQB Foundation is a multiple-choice exam: passing shows you know the core ideas and terms of software testing. It doesn't show you can test real software on a team; our graded labs have you apply the techniques from the course page.
Exam objectives this course teaches
ISTQB Certified Tester Foundation Level (CTFL) v4.0
- Fundamentals of Testing (20% of the exam): What is Testing: define testing, distinguish testing from debugging, describe test objectives; Why is Testing Necessary: explain how testing contributes to quality; understand context-driven testing; describe testers' and testing's contribution to success; Testing Principles: recall and explain the seven testing principles; Test Activities, Testware, and Test Roles: describe test activities, work products, and roles in testing (tester, test lead, developer); Essential Skills and Good Practices in Testing: identify generic skills for testers; describe whole-team approach; understand independence of testing
- Testing Throughout the Software Development Lifecycle (15% of the exam): Testing in the Context of a Software Development Lifecycle: explain the impact of SDLC on testing; describe how testing is adapted to different SDLC models (sequential, iterative, incremental, Agile, DevOps); Test Levels and Test Types: distinguish test levels (unit, integration, system, acceptance); compare test types (functional, non-functional, white-box, change-related); Maintenance Testing: summarize maintenance testing triggers, types, and impact analysis
- Static Testing (10% of the exam): Static Testing Basics: recognize types of work products that can be examined by static testing; explain the value of static testing; compare static testing vs. dynamic testing; Feedback and Review Process: describe the review process; explain the roles and responsibilities in a formal review; distinguish review types (informal review, walkthrough, technical review, inspection)
- Test Analysis and Design (27.5% of the exam): Test Techniques Overview: distinguish black-box, white-box, and experience-based test techniques; Black-Box Test Techniques: apply equivalence partitioning, boundary value analysis, decision table testing, and state transition testing to derive test cases; White-Box Test Techniques: apply statement testing and branch testing; explain the value of white-box testing; Experience-Based Test Techniques: apply error guessing, exploratory testing, and checklist-based testing; Collaboration-Based Test Approaches: explain collaborative user story writing, acceptance criteria, and acceptance test-driven development (ATDD)
- Managing the Test Activities (22.5% of the exam): Test Planning: summarize the purpose and content of a test plan; describe test estimation approaches; identify factors that influence testing effort; Risk Management: distinguish product and project risks; describe risk identification, analysis, response, and mitigation in testing; explain risk-based testing; Test Monitoring, Test Control, and Test Completion: recall metrics used for testing; explain purposes of test reports; summarize how to communicate test status; Configuration Management: explain how configuration management supports testing; Defect Management: explain the defect lifecycle; write effective defect reports; describe the attributes of a defect report
- Tool Support for Testing (5% of the exam): Tool Support for Testing: classify test tools; understand benefits of tool support for testing; identify tool categories (test management, static analysis, test design, test data preparation, test execution, performance testing, DevOps); Benefits and Risks of Test Automation: recall benefits and risks of test automation; explain factors for successful test automation
Labs
73 labs, 73 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- Seven Green Tests And A Bug That Shipped (2 labs): You can explain why a suite of passing tests did not reveal a fare defect, find the defect by testing the edges of each age group, name the error, defect and failure in the story, and describe how this course's mutation-graded labs judge a set of test cases.
- How The CTFL Exam Asks (3 labs): You can say how the forty CTFL questions are spread across chapters and K-levels, tell a K1, K2 or K3 question from its stem, read ONE, TWO, NOT and BEST questions correctly, and plan sixty minutes around the eight questions that take longest.
Fundamentals Of Testing
- What Testing Is For, And What Debugging Is (2 labs): You can recognise the typical test objectives, tell testing from debugging and from quality assurance, explain why testing is necessary, and separate a root cause, an error, a defect and a failure in a real incident.
- The Seven Principles, On One Booking App (3 labs): You can explain each of the seven testing principles, recognise which one a situation illustrates, and use Harbourline's own numbers to show why exhaustive testing is impossible and how defects cluster.
- Test Activities, Testware And Traceability (2 labs): You can explain the seven groups of test activities and their tasks, say how context shapes the test process, match testware to the activity that produces it, and use a traceability matrix to measure coverage, residual risk and the impact of a change.
- Roles, Skills, The Whole Team And Independence (2 labs): You can compare the test management role with the testing role, give examples of the generic skills testers need, recall what the whole team approach brings, and weigh the benefits and drawbacks of independent testing.
Testing Throughout The Lifecycle
- Testing In Sequential, Iterative And Agile Lifecycles (2 labs): You can explain how the chosen software development lifecycle changes the scope, timing, documentation, techniques and automation of testing, recall the good practices that hold in every lifecycle, and explain how retrospectives improve the test process.
- Test First, DevOps And Shift Left (3 labs): You can recall how TDD, ATDD and BDD use tests to drive development, run a test-first cycle in pytest, summarise how DevOps changes testing, and explain shift left and recognise its practices.
- Test Levels And Test Types (1 lab): You can distinguish the five test levels by their test object, objectives, test basis, typical defects and responsibilities, distinguish the four test types, and place any Harbourline test on both scales.
- Confirmation, Regression And Maintenance Testing (3 labs): You can distinguish confirmation testing from regression testing, use impact analysis to scope the tests after a change, and summarise maintenance testing, its triggers and what decides its scope.
Static Testing
- Static Testing: Finding Defects Without Running Anything (2 labs): You can recognise the work products static testing can examine, explain the value of static testing, compare static and dynamic testing, find typical defects in a user story by review, and read a static analyser's findings on code that has never run.
- The Review Process, Roles And Review Types (3 labs): You can identify the benefits of early and frequent stakeholder feedback, summarise the five review process activities, recall the principal review roles and their responsibilities, compare the four review types, check an inspection plan for role conflicts, and recall what makes a review succeed.
Test Analysis And Design
- Three Families Of Test Technique (2 labs): You can distinguish black-box, white-box and experience-based test techniques by what their tests are derived from, say what each family's tests survive and miss, and explain what a technique's coverage items are.
- Equivalence Partitioning (2 labs): You can divide a test object's inputs into valid and invalid equivalence partitions, derive test cases that cover every partition, calculate partition and Each Choice coverage for several parameters, and prove the cases in a mutation-graded lab.
- Boundary Value Analysis: Two Values And Three (4 labs): You can identify the boundary values of ordered partitions, derive 2-value and 3-value BVA test cases, calculate BVA coverage, explain why 3-value BVA can find defects 2-value BVA misses, and run your cases as a pytest suite.
- Decision Table Testing (3 labs): You can build a decision table from business rules, using T, F, - and N/A, count its columns, remove infeasible ones and minimise it, derive one test per column, calculate decision table coverage, and explain the risk a minimised table carries.
- State Transition Testing (3 labs): You can read and build a state diagram and a state table, derive test cases as event sequences, calculate all states, valid transitions and all transitions coverage, and explain why each invalid transition belongs in a test of its own.
- Statement And Branch Coverage (2 labs): You can explain statement testing and branch testing and how their coverage is measured, read a real coverage report, explain why full statement coverage can miss a defect that branch coverage exposes, and explain the value and the limits of white-box testing.
- Error Guessing, Exploratory And Checklist-Based Testing (2 labs): You can explain error guessing and fault attacks, explain exploratory testing and session-based test management with charters, and explain checklist-based testing, including what does not belong on a checklist.
- User Stories And Acceptance Criteria (2 labs): You can explain how user stories are written collaboratively, using the 3 C's and INVEST, classify acceptance criteria as scenario-oriented or rule-oriented, and spot criteria that no test could check.
- Acceptance Test-Driven Development (4 labs): You can use ATDD to derive test cases from a user story's acceptance criteria, positive examples first, then negative ones, check that the examples cover every criterion without going beyond the story, and run them as executable requirements in pytest.
Managing The Test Activities
- Test Plans, Entry And Exit Criteria (1 lab): You can exemplify the purpose and content of a test plan, recognise how testers add value to release and iteration planning, and compare entry criteria with exit criteria by evaluating both for a real release.
- Estimating Test Effort (1 lab): You can use estimation based on ratios, extrapolation, Wideband Delphi and three-point estimation to calculate test effort, including the standard deviation of a three-point estimate, and choose a technique for a situation.
- Prioritising Test Cases (2 labs): You can apply risk-based, coverage-based, additional coverage and requirements-based prioritisation to order test cases, respecting dependencies between them and the availability of resources.
- The Test Pyramid And The Testing Quadrants (2 labs): You can recall what the test pyramid models and how its layers differ in granularity, isolation and execution time, and summarise the four testing quadrants and how they relate to test levels and test types.
- Risk: Likelihood, Impact And Risk-Based Testing (2 labs): You can identify a risk level from likelihood and impact, distinguish project risks from product risks, explain how product risk analysis shapes test scope and thoroughness, and explain the responses available to an analysed product risk.
- Monitoring, Control And Test Reports (2 labs): You can recall the metrics used in testing, calculate progress and defect metrics from test records, summarise the purpose, content and audience of test progress and test completion reports, and exemplify ways to communicate test status.
- Configuration Management: Which Build Did We Test? (1 lab): You can summarise how configuration management supports testing: configuration items, baselines, change control and traceability, and use baseline records to decide which test results are valid for a release.
- Defect Reports That Get Fixed (4 labs): You can prepare a defect report with every field a report needs, write steps, expected and actual results that let a developer reproduce the failure, set severity and priority, and follow a defect through its workflow to closure.
Test Tools
- Test Tools And The Truth About Automation (3 labs): You can explain how the different types of test tools support testing, recall the benefits and risks of test automation, and work out when automating a regression suite starts to pay for itself.
Mock And Review
- The Eight Apply Questions, Against The Clock (1 lab): You can answer one apply question for each K3 learning objective in about three minutes each: equivalence partitioning, 2-value and 3-value BVA, decision tables, state transitions, three-point estimation, risk-based prioritisation with dependencies, and the fields a defect report needs.
- The Mock And Your Review Plan (2 labs): You can sit a forty-question CTFL mock at the exam's chapter distribution, turn the result into a review plan ordered by points lost, review the most-missed question types, and decide when you are ready to book.