ISTQB Glossary — Chapter 2: Testing Throughout the SDLC

In plain English

The checklist that says a user story is done and shippable.

From real testing work

During a pre-release security pass, a tester submits `' OR 1=1 --` into a search box and watches the response. Work like that sits under acceptance criteria: deliberately behaving like an attacker against your own system, in a controlled environment, with written permission.

curl -s "https://staging.example.com/api/search?q=%27%20OR%201%3D1%20--" \
  -H "Authorization: Bearer $TOKEN" | jq '.results | length'
# a jump from 12 to 4,812 results is the finding

In plain English

The team agrees on acceptance tests up front and only writes code that makes those tests pass.

From real testing work

Where you meet this in real work: during a sprint, acceptance test-driven development is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. ATDD writes acceptance tests before code — TDD writes unit tests, BDD writes behaviors.

In plain English

The ‘go / no-go’ testing that confirms the system meets business needs and is ready to be released to real users.

From real testing work

The same discount rule is verified three times: in a unit test on the calculator, in an API test against the pricing service, and once through the UI at checkout. Acceptance Testing names one of those layers — different test basis, different owner, different defects found.

// component level
expect(calcDiscount(100, "SAVE10")).toBe(90);
// system level
const res = await api.post("/cart/apply", { code: "SAVE10" });
expect(res.body.total).toBe(90);

In plain English

Check the software works for users with visual, motor or cognitive disabilities.

From real testing work

A signup form passes the automated scanner with zero violations, then fails the moment a tester unplugs the mouse: focus jumps from the email field straight to the footer. Accessibility Testing work catches exactly that gap between tool output and a real person completing the task.

const results = await new AxeBuilder({ page }).analyze();
expect(results.violations).toEqual([]);
// then: keyboard-only pass, Tab order recorded in the charter notes

In plain English

Internal ‘pre-beta’ environment where developers and internal testers try the software.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Alpha Environment covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

Early real-world testing done on the developer’s premises, usually by a separate QA team or invited customers, before shipping.

From real testing work

Where you meet this in real work: during a sprint, alpha testing is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. Alpha happens at the developer’s site; beta happens at the customer’s site — the location and audience are the exam giveaway.

In plain English

Testing at the service boundary — sending requests to endpoints and asserting responses — without a UI.

From real testing work

On a checkout form that accepts a quantity between 1 and 99, api testing is what stops you writing 99 test cases. You pick one value from inside the valid range and the values sitting either side of each edge, then let the rest of the range go untested on purpose.

// quantity field: valid 1..99
test.each([0, 1, 2, 98, 99, 100])("quantity %i", (qty) => {
  const res = validateQuantity(qty);
  expect(res.valid).toBe(qty >= 1 && qty <= 99);
});

In plain English

The single ordered to-do list the Agile team pulls work from.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Backlog is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

BDD writes tests as plain-English scenarios so business, devs and QA agree on what the feature should do before code is written.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Behavior-Driven Development is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

Real users try the product in their own environment before the general launch, and their feedback drives last-minute fixes.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Beta Testing covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

Slam everything together and test — cheap but painful to debug when it breaks.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Big-Bang Integration is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Deploy the new version to an idle stack, then flip the router to it.

From real testing work

In sprint planning, payment processing scores high likelihood and high impact while the marketing footer scores low on both. Blue-Green Deployment is how the team justifies spending 60% of the test effort on 10% of the codebase — to a stakeholder, in one sentence.

In plain English

Integrate from the bottom upward, using drivers to call low-level modules.

From real testing work

The payment gateway sandbox is down for maintenance, but the checkout service still has to be tested. The team wires in a bottom-up integration that returns canned success and decline responses, so the tests exercise their own code instead of a third party's uptime.

vi.mock("./gateway", () => ({
  charge: vi.fn(async (amount: number) =>
    amount > 5000 ? { status: "declined" } : { status: "approved" }),
}));

In plain English

Ship the new version to 1% of traffic, watch it, then ramp up.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Canary Release covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

Find the maximum load at which response times still meet targets.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Capacity Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

Umbrella term for confirmation and regression testing — anything you run because something changed.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Change-Related Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Intentionally break parts of a live system to check it handles failure gracefully.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Chaos Engineering is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Verify the app plays nicely with other browsers, OSes or apps.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Compatibility Testing covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

Check the software follows the rules it must follow.

From real testing work

After a bad release the team runs a root-cause session and changes the definition of done rather than adding more tests at the end. Compliance Testing sits on that side of the fence: preventive and process-oriented, distinct from executing tests against a build.

In plain English

Testing the smallest testable pieces of code (a function, class, or module) in isolation, usually by developers.

From real testing work

The same discount rule is verified three times: in a unit test on the calculator, in an API test against the pricing service, and once through the UI at checkout. Component Testing names one of those layers — different test basis, different owner, different defects found.

// component level
expect(calcDiscount(100, "SAVE10")).toBe(90);
// system level
const res = await api.post("/cart/apply", { code: "SAVE10" });
expect(res.body.total).toBe(90);

In plain English

Check the app works on every supported OS/browser/DB combination.

From real testing work

Where you meet this in real work: during a sprint, configuration testing is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. Combinatorial techniques like pairwise reduce configuration test explosion.

In plain English

Also called re-testing — you rerun the exact steps that reproduced the bug to prove the fix works.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Confirmation Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

The pipeline can push any commit to production, but a human clicks ‘go’.

From real testing work

A nightly ETL job loads 40 million rows into the reporting warehouse. Continuous Delivery shows up as the reconciliation step: row counts, checksum comparisons per partition, and null-rate thresholds that fail the pipeline before an analyst builds a dashboard on bad data.

SELECT load_date,
       COUNT(*) AS rows_loaded,
       SUM(CASE WHEN customer_id IS NULL THEN 1 ELSE 0 END) AS null_keys
FROM warehouse.orders
WHERE load_date = CURRENT_DATE
GROUP BY load_date;

In plain English

Every green build goes straight to real users, no manual approval.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Continuous Deployment is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

A culture of small, regular changes that compound into big quality gains.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Continuous Improvement is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Every code push triggers a build + automated tests so problems surface within minutes.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Continuous Integration is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Every commit triggers tests — unit, integration, sometimes end-to-end — so risks surface within minutes.

From real testing work

A nightly ETL job loads 40 million rows into the reporting warehouse. Continuous Testing shows up as the reconciliation step: row counts, checksum comparisons per partition, and null-rate thresholds that fail the pipeline before an analyst builds a dashboard on bad data.

SELECT load_date,
       COUNT(*) AS rows_loaded,
       SUM(CASE WHEN customer_id IS NULL THEN 1 ELSE 0 END) AS null_keys
FROM warehouse.orders
WHERE load_date = CURRENT_DATE
GROUP BY load_date;

In plain English

Verify the system meets what the signed contract promises.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Contract Acceptance Testing is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

How long it actually takes to finish one work item once you start it.

From real testing work

Where you meet this in real work: during a sprint, cycle time is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. Cycle time is a flow metric — shorter is generally better.

In plain English

The team’s checklist of everything true before a story is called ‘done’.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Definition of Done is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.

In plain English

Dev and Ops share ownership of building, shipping and running the product — automation and CI/CD glue it together.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. DevOps is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

An agile method that fixes time and cost but flexes scope.

From real testing work

A signup form passes the automated scanner with zero violations, then fails the moment a tester unplugs the mouse: focus jumps from the email field straight to the footer. DSDM work catches exactly that gap between tool output and a real person completing the task.

const results = await new AxeBuilder({ page }).analyze();
expect(results.violations).toEqual([]);
// then: keyboard-only pass, Tab order recorded in the charter notes

In plain English

Test the whole app the way a user would, through the real UI and back-end.

From real testing work

Where you meet this in real work: during a sprint, end-to-end testing is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. E2E tests are expensive and flaky — keep them at the top of the pyramid.

In plain English

Leave the system running for hours or days under load to see what slowly breaks.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Endurance Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

An epic is a big feature that is too large for one sprint and is split into stories.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Epic is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.

In plain English

A switch in config that hides or shows a feature to users.

From real testing work

Two weeks before a release the test manager compares planned versus executed cases, open defects by severity, and remaining effort. Feature Flag is where that number comes from — and the exam cares that it is used to inform a decision, not just published.

In plain English

Does the feature do what the spec says? Login logs you in, checkout charges the right amount.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Functional Testing is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

Before making a change, work out what else it will touch so you can plan tests and effort.

From real testing work

In sprint planning, payment processing scores high likelihood and high impact while the marketing footer scores low on both. Impact Analysis is how the team justifies spending 60% of the test effort on 10% of the codebase — to a stakeholder, in one sentence.

In plain English

You ship the product piece by piece, adding features over time instead of all at once.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so incremental development model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

Verify the installer, upgrader and uninstaller all work cleanly.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Installation Testing covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

After units work alone, you plug them together and check the seams — API calls, data hand-offs, contracts.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Integration Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Check two systems can actually talk to each other and understand the data.

From real testing work

Where you meet this in real work: during a sprint, interoperability testing is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. Interoperability is a sub-characteristic of compatibility.

In plain English

You build the product in loops, learning and refining each time, instead of one big waterfall.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so iterative development model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

A visual board that limits how many items are ‘in progress’ at once.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Kanban is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.

In plain English

How long a customer waits from ‘I want this’ to ‘I got it’.

From real testing work

Where you meet this in real work: during a sprint, lead time is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. Lead time includes waiting; cycle time starts only when work begins.

In plain English

Build only what customers value; cut everything that doesn’t add to that.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Lean is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Simulate the expected number of users to see if the system copes.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Load Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

The app writes a diary of what it did, used later to debug or audit.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Logging is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Check how easy it is for developers to change the code safely.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Maintainability Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

Testing done after go-live — patches, upgrades, migrations, retirements — to keep the running product safe.

From real testing work

A nightly ETL job loads 40 million rows into the reporting warehouse. Maintenance Testing shows up as the reconciliation step: row counts, checksum comparisons per partition, and null-rate thresholds that fail the pipeline before an analyst builds a dashboard on bad data.

SELECT load_date,
       COUNT(*) AS rows_loaded,
       SUM(CASE WHEN customer_id IS NULL THEN 1 ELSE 0 END) AS null_keys
FROM warehouse.orders
WHERE load_date = CURRENT_DATE
GROUP BY load_date;

In plain English

Testing that everything still works after moving to a new platform.

From real testing work

A nightly ETL job loads 40 million rows into the reporting warehouse. Migration Testing shows up as the reconciliation step: row counts, checksum comparisons per partition, and null-rate thresholds that fail the pipeline before an analyst builds a dashboard on bad data.

SELECT load_date,
       COUNT(*) AS rows_loaded,
       SUM(CASE WHEN customer_id IS NULL THEN 1 ELSE 0 END) AS null_keys
FROM warehouse.orders
WHERE load_date = CURRENT_DATE
GROUP BY load_date;

In plain English

Whole team on one screen — one driver, many navigators.

From real testing work

The payment gateway sandbox is down for maintenance, but the checkout service still has to be tested. The team wires in a mob programming that returns canned success and decline responses, so the tests exercise their own code instead of a third party's uptime.

vi.mock("./gateway", () => ({
  charge: vi.fn(async (amount: number) =>
    amount > 5000 ? { status: "declined" } : { status: "approved" }),
}));

In plain English

Watching logs, metrics and traces from the live system to catch problems fast.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Monitoring is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

How fast, how secure, how usable, how reliable — the ‘qualities’ around the feature, not the feature itself.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Non-Functional Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

How well you can figure out what a live system is doing from outside.

From real testing work

Two weeks before a release the test manager compares planned versus executed cases, open defects by severity, and remaining effort. Observability is where that number comes from — and the exam cares that it is used to inform a decision, not just published.

In plain English

Ops team checks that the system is deployable, monitorable and recoverable.

From real testing work

During a pre-release security pass, a tester submits `' OR 1=1 --` into a search box and watches the response. Work like that sits under operational acceptance testing: deliberately behaving like an attacker against your own system, in a controlled environment, with written permission.

curl -s "https://staging.example.com/api/search?q=%27%20OR%201%3D1%20--" \
  -H "Authorization: Bearer $TOKEN" | jq '.results | length'
# a jump from 12 to 4,812 results is the finding

In plain English

Two developers, one keyboard — instant code review and knowledge sharing.

From real testing work

A requirements review on a "forgot password" story raises that the acceptance criteria never say what happens to an unverified email address. That is pair programming in practice — an issue found in a document, before a single line of code exists, at a fraction of the cost of finding it in UAT.

In plain English

How fast, how many users, how stable under load — response time, throughput, resource usage.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Performance Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

A game where everyone flips an estimate card at the same time to avoid anchoring.

From real testing work

Two weeks before a release the test manager compares planned versus executed cases, open defects by severity, and remaining effort. Planning Poker is where that number comes from — and the exam cares that it is used to inform a decision, not just published.

In plain English

Check the app works on other browsers, OSes or hardware.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Portability Testing covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

The single voice of the customer who decides what the team builds next.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Product Owner is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

The real system your customers actually use.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Production Environment covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

Building a rough working version early to learn what users actually want.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so prototyping model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

Building working prototypes fast, then refining based on user feedback.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Rapid Application Development is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

How well the system restores itself and its data after a failure.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Recoverability Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Clean up the code without changing what it does.

From real testing work

Where you meet this in real work: during a sprint, refactoring is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. A strong regression test suite makes refactoring safe.

In plain English

After any change — bug fix, new feature, config update — you re-run existing tests to make sure nothing that used to work has broken.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Regression Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Prove the system meets legal and regulatory requirements like GDPR or HIPAA.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Regulation Acceptance Testing is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

Check the system keeps working correctly over time under expected load.

From real testing work

Where you meet this in real work: during a sprint, reliability testing is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. Reliability is a non-functional quality characteristic in ISO 25010.

In plain English

Check the system bounces back after crashes or lost dependencies.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Resilience Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

Running the same test again after a fix to confirm the bug is gone.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. Retest is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

The regular team meeting for ‘what went well, what didn’t, what to change’.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Retrospective is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.

In plain English

Integrate from both ends toward the middle — hybrid of top-down and bottom-up.

From real testing work

The same discount rule is verified three times: in a unit test on the calculator, in an API test against the pricing service, and once through the UI at checkout. Sandwich Integration names one of those layers — different test basis, different owner, different defects found.

// component level
expect(calcDiscount(100, "SAVE10")).toBe(90);
// system level
const res = await api.post("/cart/apply", { code: "SAVE10" });
expect(res.body.total).toBe(90);

In plain English

A narrow, targeted check after a small change — did this specific fix work and did it not obviously break its immediate neighbours?

From real testing work

Two weeks before a release the test manager compares planned versus executed cases, open defects by severity, and remaining effort. Sanity Testing is where that number comes from — and the exam cares that it is used to inform a decision, not just published.

In plain English

Check the system can handle growth by adding resources or nodes.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Scalability Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

The most common Agile framework — short sprints, daily standups, reviews and retros.

From real testing work

A requirements review on a "forgot password" story raises that the acceptance criteria never say what happens to an unverified email address. That is scrum in practice — an issue found in a document, before a single line of code exists, at a fraction of the cost of finding it in UAT.

In plain English

Trying to break in, leak data, or escalate privileges — before an attacker does.

From real testing work

During a pre-release security pass, a tester submits `' OR 1=1 --` into a search box and watches the response. Work like that sits under security testing: deliberately behaving like an attacker against your own system, in a controlled environment, with written permission.

curl -s "https://staging.example.com/api/search?q=%27%20OR%201%3D1%20--" \
  -H "Authorization: Bearer $TOKEN" | jq '.results | length'
# a jump from 12 to 4,812 results is the finding

In plain English

Classic phase-gate development — one stage finishes before the next starts. Waterfall and V-model are examples.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so sequential development model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

Start testing — reviews, unit tests, static analysis — as early as possible, not at the end.

From real testing work

A requirements review on a "forgot password" story raises that the acceptance criteria never say what happens to an unverified email address. That is shift-left testing in practice — an issue found in a document, before a single line of code exists, at a fraction of the cost of finding it in UAT.

In plain English

Keep testing after release — observe real users, run experiments, catch issues in production safely.

From real testing work

Two weeks before a release the test manager compares planned versus executed cases, open defects by severity, and remaining effort. Shift-Right Testing is where that number comes from — and the exam cares that it is used to inform a decision, not just published.

In plain English

A quick check that the build is stable enough to test — if login, home page, and basic navigation don’t crash, you go ahead with deeper testing.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Smoke Testing is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Instead of vague requirements, the team writes real input/output examples that also run as tests.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Specification by Example is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

Slam the system with a sudden burst of traffic to see how it copes.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Spike Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

A repeating cycle of planning, risk analysis, engineering, and evaluation.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so spiral model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

A short timebox in which the team delivers a working piece of the product.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Sprint is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.

In plain English

The meeting at the start of a sprint where the team commits to what it will build.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Sprint Planning is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

The demo meeting where the team shows working software and gets feedback.

From real testing work

A requirements review on a "forgot password" story raises that the acceptance criteria never say what happens to an unverified email address. That is sprint review in practice — an issue found in a document, before a single line of code exists, at a fraction of the cost of finding it in UAT.

In plain English

Run the system for a long time under normal load and watch for degradation.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Stability Testing is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

The last stop before production — same config, sanitized data, real integrations.

From real testing work

The same discount rule is verified three times: in a unit test on the calculator, in an API test against the pricing service, and once through the UI at checkout. Staging Environment names one of those layers — different test basis, different owner, different defects found.

// component level
expect(calcDiscount(100, "SAVE10")).toBe(90);
// system level
const res = await api.post("/cart/apply", { code: "SAVE10" });
expect(res.body.total).toBe(90);

In plain English

A relative size number the team gives a story, not hours.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Story Point is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

Push the system past its expected load to find the breaking point.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Stress Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

Once systems are combined, verify they talk to each other correctly.

From real testing work

A tester files: "Checkout returns HTTP 500 when the cart contains a gift card and a subscription." Steps, expected, actual, environment, build number. System Integration Testing is one of the fields or states in that workflow, and getting the term right is what makes the report actionable for the developer picking it up at 9am.

In plain English

End-to-end testing of the fully integrated product against its requirements, usually in a production-like environment.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. System Testing is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

Shortcuts in code that cost you extra time later to fix or work around.

From real testing work

Where you meet this in real work: during a sprint, technical debt is the piece of vocabulary a tester reaches for when explaining a decision to a developer or a stakeholder — for example, justifying in a stand-up why a specific check belongs in this build rather than the next. High technical debt slows delivery and often shows up as flaky tests.

In plain English

Lots of cheap unit tests, some integration tests, few slow UI tests.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so test pyramid is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

Business, dev and tester talk through a story together before coding starts.

From real testing work

A story reads "As a returning customer I can reuse a saved card." Before estimating it, the three amigos add acceptance criteria for an expired card and a card removed from the account. Three Amigos is the artefact or link involved, and it is what lets you prove later that every requirement has at least one test.

In plain English

How many stories or tickets the team actually finishes each week.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Throughput is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

Integrate from the top downward, using stubs for anything not built yet.

From real testing work

The payment gateway sandbox is down for maintenance, but the checkout service still has to be tested. The team wires in a top-down integration that returns canned success and decline responses, so the tests exercise their own code instead of a third party's uptime.

vi.mock("./gateway", () => ({
  charge: vi.fn(async (amount: number) =>
    amount > 5000 ? { status: "declined" } : { status: "approved" }),
}));

In plain English

Everyone commits to main every day; long-lived branches are avoided.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so trunk-based development is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

Same as component testing: developers verify one small piece of code at a time with fast, automated tests.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. Unit Testing is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Testing that upgrading from v1 to v2 doesn’t break anything or lose data.

From real testing work

Staging has last quarter's anonymised production snapshot, seeded with fifteen deliberately broken accounts. Upgrade Testing covers how that is created, versioned and restored — because a suite that passes only on Tuesday's data is not a suite you can trust.

make db-reset && make seed-fixtures ENV=staging
# fixtures are versioned with the tests, in the same commit

In plain English

Watch real users try the product to see if the UI actually works for them.

From real testing work

A signup form passes the automated scanner with zero violations, then fails the moment a tester unplugs the mouse: focus jumps from the email field straight to the footer. Usability Testing work catches exactly that gap between tool output and a real person completing the task.

const results = await new AxeBuilder({ page }).analyze();
expect(results.violations).toEqual([]);
// then: keyboard-only pass, Tab order recorded in the charter notes

In plain English

Real users try the software and decide if it’s good enough to ship.

From real testing work

The same discount rule is verified three times: in a unit test on the calculator, in an API test against the pricing service, and once through the UI at checkout. User Acceptance Testing names one of those layers — different test basis, different owner, different defects found.

// component level
expect(calcDiscount(100, "SAVE10")).toBe(90);
// system level
const res = await api.post("/cart/apply", { code: "SAVE10" });
expect(res.body.total).toBe(90);

In plain English

The final round of testing done by real users before launch.

From real testing work

The same discount rule is verified three times: in a unit test on the calculator, in an API test against the pricing service, and once through the UI at checkout. User Acceptance Testing names one of those layers — different test basis, different owner, different defects found.

// component level
expect(calcDiscount(100, "SAVE10")).toBe(90);
// system level
const res = await api.post("/cart/apply", { code: "SAVE10" });
expect(res.body.total).toBe(90);

In plain English

A short, user-focused description of a feature the team will build in one sprint.

From real testing work

The regression pack runs on every merge to main and blocks the deploy when it fails. User Story is the piece of that setup being named here — and the cost is not writing the tests, it is keeping them green when the UI changes next sprint.

- name: Regression suite
  run: npx playwright test --grep @regression
- name: Publish report
  if: always()
  uses: actions/upload-artifact@v4
  with: { name: playwright-report, path: playwright-report/ }

In plain English

Each dev phase (requirements, design, code) has a matching test level (acceptance, system, component) drawn as a V.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so v-model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

How many story points the team typically finishes per sprint.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Velocity is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.

In plain English

Load the system with huge datasets to see how it handles them.

From real testing work

Before a Black Friday sale, the team models 5,000 concurrent shoppers against staging. Volume Testing is the part of that exercise that answers a specific question — not "is it fast", but "at what point does it stop being fast, and what breaks first".

// k6 scenario
export const options = {
  stages: [
    { duration: "2m", target: 500 },
    { duration: "5m", target: 5000 },
    { duration: "2m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<800"] },
};

In plain English

Requirements → design → build → test → release, in a straight line with limited backtracking.

From real testing work

A résumé-screening model scores candidates from 0 to 1. There is no single expected value to assert against, so waterfall model is checked statistically: accuracy on a held-out set, score distribution compared across demographic slices, and an alert when the live distribution drifts from training.

assert accuracy_score(y_true, y_pred) >= 0.87
gap = abs(tpr(group_a) - tpr(group_b))
assert gap < 0.05, f"fairness gap too wide: {gap:.3f}"

In plain English

The rule that says ‘no more than N items in this column’, forcing focus.

From real testing work

In a two-week sprint the team tracks work on a board, agrees what "done" means before pulling a story, and reviews the outcome in the retro. Work-in-ProgressLimit is the agile artefact or practice involved, and testers are expected to shape it rather than receive it.