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 prerequisites. You can start here.

Take next:

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

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.

Course outline

Start Here

  1. 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.
  2. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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

  1. 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.
  2. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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

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

  1. 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.
  2. 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.