Software Testing

Beginner path · lesson 9 of 35

BeginnerFundamentals4 min readPublished November 12, 2026

The different levels of software testing

Software is tested in layers: single pieces, pieces working together, the whole system and finally whether it's acceptable to users. Here's what each level checks and who usually does it.

On this page

Key takeaways

  • Test levels split testing by how much of the software you're looking at: one piece, pieces together, the whole system or the system in the user's hands.
  • The four classic levels are component (unit), integration, system and acceptance testing.
  • Each level catches different problems. Passing one level doesn't replace the others.

Why test in levels?

Imagine building a car. You check each part on its own, then check the parts fit together, then drive the whole car, and finally let the customer test-drive it.

Software works the same way. Each level looks at a different size of the product, and each finds problems the others can't see.

The four levels

1. Component (unit) testing

Tests a single piece of code on its own: a function, a class, a module.

  • Example: does calculateVat(100) return 19 when the rate is 19%?
  • Who: usually developers, with automated tests.
  • Finds: logic mistakes inside one piece.

2. Integration testing

Tests how pieces work together. ISTQB distinguishes two kinds:

  • Component integration: modules of the same application talking to each other, such as the cart and the pricing module.
  • System integration: your system talking to other systems, such as a payment provider, an email service or a bank's API.

Finds: mismatched data formats, wrong assumptions about another piece, broken connections.

3. System testing

Tests the whole application, end to end, against its requirements. This is where most dedicated testers spend their time.

  • Example: a customer can search, add to cart, pay and get a confirmation email.
  • Who: usually testers, by hand and with automation.
  • Finds: problems in complete user flows, plus non-functional problems like slowness or security gaps.

4. Acceptance testing

Answers one question: is this ready for its users? It's done against business needs, not technical specs.

Common types:

  • User acceptance testing (UAT): real users or the client try the system on realistic tasks.
  • Operational acceptance: can the operations team install, back up, monitor and recover it?
  • Alpha and beta testing: early versions shared with users, inside the company (alpha) or outside it (beta).

Side by side

LevelWhat's testedUsually done byExample question
ComponentOne piece of codeDevelopersDoes this function calculate VAT correctly?
IntegrationPieces togetherDevelopers and testersDoes the cart send the right total to payment?
SystemThe whole applicationTestersCan a customer complete a purchase?
AcceptanceFitness for usersUsers, client, businessCan our sales team actually work with this?

Every level catches something different

Real-world exampleEvery piece passed, the whole didn't

A team builds a booking app. The date picker passes all its unit tests, and so does the booking service.

In system testing, a tester books a room for 5 March. The confirmation email says 3 May.

The date picker sends dates as day/month, and the booking service reads them as month/day. Each piece was correct on its own terms. Only testing them together revealed the mismatch.

Lesson: unit tests can't find problems between pieces. That's why integration and system testing exist.

What this means for you

  • As a beginner tester, you'll mostly work at the system level, and support acceptance testing.
  • Learn what the developers' unit and integration tests cover. It tells you where to focus, and where you don't need to repeat their work.
  • When you find a bug, think about which level should have caught it. That's useful feedback for the whole team.

Check yourself

The payment page works in the test environment, but fails when connected to the real bank's API. Which test level was missing?

Show answer

System integration testing: checking your system together with the external systems it depends on. Testing against a fake or simplified bank API isn't the same as testing the real connection.