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)return19when 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
| Level | What's tested | Usually done by | Example question |
|---|---|---|---|
| Component | One piece of code | Developers | Does this function calculate VAT correctly? |
| Integration | Pieces together | Developers and testers | Does the cart send the right total to payment? |
| System | The whole application | Testers | Can a customer complete a purchase? |
| Acceptance | Fitness for users | Users, client, business | Can our sales team actually work with this? |
Every level catches something different
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.
