Lesson 1 of 10 · Lesson + Lab · 75 min · Free preview

Exam Blueprint, K-Levels & Chapter 1: Fundamentals of Testing

Understand the CTFL v4.0 exam format, K-levels and chapter weightage, then master Chapter 1 (principles, error/defect/failure, test activities, testware and roles) through worked exam exercises.

Independent prep course. This QA Jobs India course is an independent study aid aligned to the ISTQB Certified Tester Foundation Level (CTFL) syllabus v4.0. It is not affiliated with, endorsed by or produced by ISTQB. The official exam is booked through an ISTQB member board or an accredited exam provider — in India that is usually the Indian Testing Board (ITB). Always download the current official syllabus, glossary and sample exams free from istqb.org and treat them as the final authority.

Why this matters on the job

Open any fresher or 1–4 year QA job description on Naukri or LinkedIn from service companies (TCS, Infosys, Wipro, Capgemini, Accenture) and product firms alike, and you will often see “ISTQB certification preferred”. More importantly, interviewers use CTFL vocabulary every day: “What is the difference between a defect and a failure?”, “Explain regression vs confirmation testing”, “Which test design technique would you use here?”. The certificate opens the door; the concepts make you sound like a professional tester in the interview and on the project.

This first lesson gives you the exam blueprint and an exam strategy, then covers Chapter 1 (Fundamentals of Testing) through worked exam-style exercises.

Concepts

The exam at a glance

ItemCTFL v4.0 (verify on the official exam structure document)
Questions40 multiple-choice, one mark each, no negative marking
Duration60 minutes; candidates taking it in a non-native language usually get 25% extra (75 minutes)
Pass mark65% — at least 26 correct answers
FormatClosed book; most questions have one correct option, a few ask you to “select TWO”
BookingISTQB member board (e.g., ITB in India) or an accredited exam provider; online-proctored or test-centre options

K-levels: how deep each question goes

Every learning objective in the syllabus is tagged with a cognitive level. Knowing the level tells you what kind of question to expect.

LevelMeaningTypical question verbsApprox. share of the 40 questions
K1 – RememberRecognise a term or factidentify, recall, recogniseabout 8
K2 – UnderstandExplain, compare, classify, give examplesclassify, compare, differentiate, explain, summariseabout 24
K3 – ApplyUse a technique on a given scenarioapply, use, derive, calculateabout 8

Chapter weightage (where the marks are)

ChapterTopicApprox. questions
1Fundamentals of Testing8
2Testing Throughout the SDLC6
3Static Testing4
4Test Analysis and Design11
5Managing the Test Activities9
6Test Tools2

Chapters 4 and 5 together carry roughly half the marks and contain almost all K3 questions. Plan your study time accordingly.

Chapter 1 essentials, in plain words

  • Testing is a set of activities to find defects and evaluate quality. It is not only executing tests: planning, analysing requirements and reviewing are also testing. Debugging is a development activity — finding, analysing and removing the cause of a failure.
  • Error → defect → failure. A person makes an error (mistake), which can introduce a defect (bug, fault) into a work product. When defective code is executed, it may cause a failure (the system behaves differently from what is expected). The root cause is the fundamental reason the error happened (e.g., time pressure, unclear requirement). Failures can also come from environmental conditions such as radiation or electromagnetic fields.
  • Testing and QA. Testing is a form of quality control (product-oriented, corrective). Quality assurance is process-oriented and preventive — improving the way work is done.
Seven testing principlesWhat it means on a project
1. Testing shows the presence, not the absence, of defectsZero open bugs after a sprint does not prove the build is defect-free.
2. Exhaustive testing is impossibleUse techniques, risk and priority to select tests instead of testing every input.
3. Early testing saves time and moneyA wrong GST rule found in a story review costs minutes; found in production it costs a hotfix.
4. Defects cluster togetherA few modules (often payment, integration, legacy code) hold most defects — focus there.
5. Tests wear outRunning the same regression suite unchanged finds fewer new defects; refresh tests and data. (Older syllabi called this the pesticide paradox.)
6. Testing is context dependentA banking app and a casual game need different approaches, rigour and documentation.
7. Absence-of-defects fallacyA bug-free system that does not meet user needs is still a failure.

Test activities and testware

ActivityKey questionTypical testware produced
Test planningWhat, why, how much, by when?Test plan, schedule, risk register, entry/exit criteria
Test monitoring & controlAre we on track? What do we change?Test progress reports, control directives
Test analysisWhat to test?Prioritised test conditions, defect reports on the test basis
Test designHow to test?Test cases, test charters, coverage items, test data requirements
Test implementationIs everything ready to run?Test procedures, test suites, automated scripts, test data, environment
Test executionRun and compareTest logs, defect reports
Test completionWhat did we learn and hand over?Test completion report, archived testware, lessons learned

These activities are often iterative and overlap. Traceability links test basis items to test conditions, cases, results and defects, which lets you measure coverage and do impact analysis. The syllabus describes two roles: the test management role (planning, monitoring, control, completion) and the testing role (analysis, design, implementation, execution). In the whole-team approach anyone can perform testing tasks and everyone is responsible for quality. Independence ranges from the author testing their own work, to peers, to a separate test team, to external testers: more independence finds different defects but can cause isolation and communication gaps.

Hands-on Lab: Chapter 1 worked exam exercises

  1. Error, defect, failure, root cause. Scenario: a business analyst writes “round GST to the nearest rupee” but the developer, under deadline pressure and without clarification, implements floor(). In production, invoices show ₹1 less GST for some amounts.

    Worked solution: Error = the developer’s misinterpretation. Defect = the floor() call in the code. Failure = invoice shows the wrong GST. Root cause = deadline pressure plus no clarification step for ambiguous requirements. Exam tip: if the option names the reason behind the mistake, it is the root cause.

  2. Map the principle. Classify each statement:

    StatementPrinciple (answer)
    “The regression pack has run unchanged for a year and finds nothing new.”Tests wear out
    “80% of last release’s bugs were in the payment gateway module.”Defects cluster together
    “The app passed all tests but customers say it is unusable.”Absence-of-defects fallacy
    “We cannot test every PIN combination for the ATM.”Exhaustive testing is impossible
    “A medical device needs far more formal testing than a food blog.”Testing is context dependent
  3. Map testware to activity. For each item, write the activity that produces it. Answers: test charter → design; test log → execution; prioritised test conditions → analysis; automated test script → implementation; lessons-learned notes → completion; progress report → monitoring and control.

  4. K-level tagging. Tag each question stem:

    Q-a  "Which of the following is a typical objective of testing?"          -> K1 (recall)
    Q-b  "Which statement BEST explains why independent testing is valuable?" -> K2 (explain)
    Q-c  "Given the valid range 10-50, which set of values achieves 100%
          2-value boundary coverage?"                                          -> K3 (apply)
    Q-d  "Which activity is an example of debugging, not testing?"           -> K2 (differentiate)

    Why it matters: K1 questions take 30 seconds; K3 questions need 2–3 minutes. Tagging teaches you to budget time.

  5. Exam-style question with option analysis.

    Which of the following is the BEST example of quality assurance rather than testing? a) Executing regression tests on a new build b) Reviewing a requirements document for ambiguities c) Introducing a mandatory peer-review step in the team’s development process d) Logging a defect found during system testing.

    Answer: c. Options a, b and d are all forms of testing (quality control: dynamic, static, and the reporting of results). Only c improves the process, which is what QA means.

  6. Build your study plan. Create a spreadsheet with columns Chapter | Syllabus minutes | Est. questions | My confidence (1-5) | Study hours. Give Chapters 4 and 5 at least 50% of your hours. Expected result: a dated 3–4 week plan ending with two full timed mock exams.

Common mistakes

  • Studying from old v3.1 notes: terms like “fundamental test process” and the pesticide paradox wording have changed in v4.0.
  • Calling debugging a test activity. Testing can trigger failures; debugging finds and fixes their cause.
  • Mixing up error and defect: the error is human, the defect lives in the work product.
  • Memorising brain-dump answers. v4.0 questions are scenario-based and dumps are often wrong and unethical to use.

Real-world assignment

Your test lead asks: “Map our current sprint to the seven test activities.” Take a project you know (or SauceDemo at saucedemo.com as a stand-in). For each activity, list who does it, what testware is produced and where it is stored (Jira, Confluence, Git). Highlight one missing activity (often test completion) and propose a 15-minute fix. Keep it to one page — this is a classic “tell us about your test process” interview answer.

Key takeaways

  • 40 questions, 60 minutes, 26 to pass; Chapters 4 and 5 carry about half the marks.
  • K1 = remember, K2 = understand, K3 = apply — budget time by level.
  • Error (human) → defect (in the work product) → failure (observed behaviour); root cause is why the error happened.
  • Know all seven principles with one project example each.
  • Seven test activities, each with its own testware; traceability ties them together.

🧪 Practical checklist

Do each task yourself and tick it off. All tasks are required to complete this lesson.

🎤 Interview questions

What is the difference between an error, a defect and a failure?

An error is a human mistake; it can introduce a defect (fault) in code or another work product; when that defect is executed it may cause a failure, an observable deviation from expected behaviour.

Is debugging part of testing?

No. Testing reveals failures or defects; debugging is a development activity that locates, analyses and fixes the cause. Confirmation testing then checks the fix.

Explain the 'tests wear out' principle with an example.

If the same regression suite runs unchanged for many releases, it stops finding new defects because the code it covers has stabilised. We refresh test data, add new tests and retire stale ones.

How is QA different from testing?

Testing is quality control: it checks the product and finds defects. QA is process-focused and preventive, improving how the team works, for example by introducing reviews or coding standards.

What are the pros and cons of independent testing?

Independent testers bring different perspectives and fewer author biases, so they find different defects. Drawbacks include isolation from the dev team, slower feedback and developers feeling less responsible for quality.

📝 Quiz, progress tracking & certificate

You're reading a free preview. Premium members tick off labs, take the quiz, unlock all 10 lessons and earn a verifiable certificate.

💎 Unlock with Premium Premium login
✓ You're subscribed! Job alerts arrive daily at 9 AM.
Scroll to Top