Levels of Testing: Unit, Integration, System, Acceptance (2026)

Last updated: July 17, 2026 · 12 min read · By Avinash Kamble

The 4 levels of software testing — unit, integration, system, and acceptance — are the vocabulary every QA engineer uses to describe where in the stack a test lives. Confuse them and you'll either double-test or leave gaps. Understand them and you can defend your test strategy in any design review. This is a canonical ISTQB topic and a near-guaranteed interview question.

Pair with the test pyramid and the SDLC phases guide.

Key takeaways

• Four levels: Unit → Integration → System → Acceptance.
• Each level has a different owner, tool set, and defect class.
• The test pyramid tells you how many tests to write at each level.
• ISTQB Foundation topic — appears in almost every QA interview.

Scope: a single function, method, or class in isolation.

Owner: developers, primarily. In shift-left teams, QA reviews unit-test design.

Tools: JUnit / TestNG (Java), pytest (Python), Jest / Vitest (JS/TS), NUnit (C#).

Defect class: logic errors inside one function — wrong branch, off-by-one, null handling.

Speed: milliseconds. A CI unit-test suite of thousands of tests should finish in under 2 minutes.

// Vitest unit test
import { calculateDiscount } from './pricing';

test('applies 10% discount for members', () => {
  expect(calculateDiscount(100, { isMember: true })).toBe(90);
});

test('no discount for non-members', () => {
  expect(calculateDiscount(100, { isMember: false })).toBe(100);
});

Scope: two or more components working together — service-to-service, service-to-DB, service-to-message-broker.

Owner: developers and SDETs jointly.

Tools: Postman, REST-Assured, WireMock, Testcontainers, Pact for contract testing.

Defect class: contract mismatches, serialisation bugs, connection handling, retry logic.

Approaches: big-bang, top-down, bottom-up, sandwich (hybrid). Modern microservices teams favour contract tests + a small suite of end-to-end integration checks.

Scope: the fully integrated system end-to-end, exercised from the outside as a black box.

Owner: QA / SDET team.

Tools: Playwright, Selenium, Cypress for UI; k6 or JMeter for performance; OWASP ZAP for security.

Types of system testing:

• Functional (does the feature work?)
• Regression (did we break what already worked?)
• Performance / load / stress
• Security / penetration
• Usability
• Compatibility (browsers, devices)
• Recovery, installation, configuration

See the types of software testing hub for the full taxonomy.

Scope: the built system, verified against business acceptance criteria by the customer or product owner.

Owner: business users, product managers, sometimes customers.

Types: User Acceptance Testing (UAT), Business Acceptance Testing (BAT), Alpha (in-house), Beta (real users), Operational Acceptance Testing (OAT — DR, monitoring, runbooks).

Deliverable: sign-off. Without acceptance sign-off the feature does not release.

QA's job in UAT is to enable the business — provide test data, walk them through flows, log the defects they surface, and manage sign-off criteria.

The test pyramid is a visualisation of the volume distribution across these four levels. A healthy pyramid is wide at the base (many fast unit tests) and narrow at the top (few slow E2E tests). Anti-patterns: ice-cream cone (too many manual and E2E tests) and hourglass (too many unit + E2E, no integration middle).

Shift-left means moving each level of testing as early in the SDLC as possible. Unit tests get written with the feature, not after. Contract tests live in the developer's PR. System tests run in nightly CI, not manual pre-release cycles. UAT starts on preview environments, not staging on release day. See the shift-left with AI copilots guide.

Guaranteed at every QA interview from junior to senior. Common prompts: “Explain the 4 levels of testing”, “Difference between integration and system testing?”, “Who owns UAT?”. Rehearse on the AI Mock Interview. Pillar prep: software testing interview questions.

Map your current test suite to these four levels. Count how many tests live at each. Compare against the test pyramid. Where's the biggest gap? Fill it in the next sprint. Then benchmark comp on the QA Salary Guide and audit your resume on the ATS Resume Reviewer.

Textbooks still draw unit → integration → system → acceptance as a clean waterfall. In real 2026 delivery, the four levels are parallel workstreams owned by different roles and gated by different SLAs. From SoftwareTestPilot's 2026 review of 40+ engineering orgs:

Two rules senior interviewers now expect you to state out loud: (1) each level has its own entry/exit, not a shared one; (2) defects escape upward, not downward — a defect that reached system testing was a hole in unit or integration coverage, not just “a system bug”. Say that in a panel and you are instantly reading as a lead-level candidate.

Original SoftwareTestPilot research on level ratios and cost-to-fix:

• Test pyramid benchmarks (2026) — 62 / 26 / 12 median unit/integration/E2E.
• Shift-left benchmarks (2026) — cost-per-defect by level.
• Software testing interview questions — levels vs types drilled with senior answers.