System Testing Explained: Types, Process and a Real End-to-End Example
System testing checks the complete, integrated application against its requirements, the way a user or client would experience it. Learn where it sits between integration and acceptance testing, the functional and non-functional types, entry and exit criteria, how to design scenarios, and what an end-to-end suite caught when we broke our sample shop.
- System testing verifies the whole, integrated system against its requirements, usually as black-box testing through real interfaces.
- It comes after integration testing and before user acceptance testing.
- It covers functional behaviour and non-functional qualities such as performance, security and recovery.
- Our 8 end-to-end tests passed in 0.18 s; removing one lock made the concurrency test crash the server, a bug no unit test would see.
Every unit test can pass and every pair of components can integrate correctly, and the product can still fail when a real customer places an order: stock is not updated, the coupon applies twice, or the server falls over when two people buy the last item at once. System testing is the level that looks at the product as a whole, in an environment like production, before it reaches users.
This guide explains the concepts and process, then shows a small but real example: a Python shop API with a database, tested end to end through HTTP with pytest 9.2.0 on Python 3.13.6. For how this level relates to others, see our test pyramid guide.
What is system testing?
System testing evaluates a complete, integrated software system to check that it meets its specified requirements. Testers interact with it through its external interfaces, the UI, the API, files or messages, without relying on internal code, which is why it is usually described as black-box testing. The question it answers is: does the whole system, deployed together with its database, configuration and integrations, do what the specification says?
Where system testing fits
Unit testing -> individual functions and classes
Integration testing -> components working together
SYSTEM TESTING -> the complete system against its requirements
Acceptance testing -> users or clients confirm it meets their needs
Each level builds on the one before. System testing assumes the units and integrations already work, so it focuses on complete flows and system-wide qualities. Our unit vs integration testing guide covers the levels below it, and user acceptance testing the level above.
System testing compared with other levels
| Aspect | Integration testing | System testing | Acceptance testing |
|---|---|---|---|
| Scope | Interfaces between components | Whole system | Whole system in business context |
| Basis | Design and interface specs | System requirements | Business needs and acceptance criteria |
| Performed by | Developers, testers | Independent testers | Users, clients, product owners |
| Style | Often grey box | Black box | Black box |
| Environment | Partial, with stubs | Production-like | Production-like or production |
Types of system testing
Sources list dozens of types; these are the ones teams use most:
- Functional system testing: complete business flows such as sign-up, checkout, refund.
- End-to-end testing: flows that cross every layer and external integration; see end-to-end testing best practices.
- Regression testing: confirming that existing behaviour still works after changes.
- Performance, load and stress testing: speed and capacity of the whole system.
- Security testing: authentication, authorisation, data protection.
- Usability testing: whether real people can complete tasks.
- Recovery testing: behaviour after crashes, restarts and lost connections.
- Compatibility and installation testing: supported browsers, devices, operating systems and upgrade paths.
The non-functional types are explained in depth in our non functional testing guide.
Entry and exit criteria
| Entry criteria | Exit criteria |
|---|---|
| Integration testing completed and critical defects fixed | All planned system test cases executed |
| Build deployed to a stable, production-like environment | No open critical or high severity defects |
| System test plan, cases and data ready | Requirements coverage agreed and reached |
| Smoke test passed on the build | Performance and security targets met |
Clear criteria stop system testing from starting on an unstable build, which wastes days, and from ending on a deadline rather than on evidence. Record them in the test plan.
The system testing process
- Plan: scope, approach, environment, schedule, roles and criteria.
- Design: derive scenarios and test cases from requirements.
- Prepare: environment, test data, accounts and tools.
- Execute: run tests, manual and automated, and record results.
- Report defects: with clear reproduction steps; see our bug report guide.
- Retest and regress: confirm fixes and check nothing else broke.
- Close: summarise coverage, results and open risks for the release decision.
Designing system test scenarios
Start from user goals and requirements, not from screens. For each major flow, cover the happy path, important alternative paths, invalid input, boundaries, state changes over time, and what happens when things run concurrently. Trace each scenario back to a requirement, so gaps in coverage are visible. A good system test scenario checks the outcome a user cares about (stock went down, money was refunded once), not just that a page loaded.
Our end-to-end system test suite
We built a small shop API in Python: it takes orders, applies a coupon (50 off orders of 500 or more), reserves stock and handles refunds, storing orders in SQLite behind an HTTP server. The test suite starts the real server for each test and talks to it only over HTTP, as a client would:
def test_order_happy_path_updates_stock(base):
assert call(base, "GET", "/stock/A1") == (200, {"sku": "A1", "stock": 3})
code, body = call(base, "POST", "/orders", {"sku": "A1", "qty": 2, "coupon": "SAVE50"})
assert code == 201 and body["total"] == 950
assert call(base, "GET", "/stock/A1")[1]["stock"] == 1
def test_refund_restores_stock_once(base):
oid = call(base, "POST", "/orders", {"sku": "B2", "qty": 4})[1]["id"]
assert call(base, "POST", f"/orders/{oid}/refund", {})[0] == 200
assert call(base, "GET", "/stock/B2")[1]["stock"] == 10
assert call(base, "POST", f"/orders/{oid}/refund", {}) == (409, {"error": "already refunded"})
def test_no_overselling_under_concurrency(base):
with cf.ThreadPoolExecutor(10) as ex:
codes = list(ex.map(lambda _: call(base, "POST", "/orders", {"sku": "A1", "qty": 1})[0], range(10)))
assert codes.count(201) == 3 and codes.count(409) == 7
assert call(base, "GET", "/stock/A1")[1]["stock"] == 0
Alongside these, the suite checks three kinds of invalid orders (unknown product, zero quantity, quantity sent as text), a coupon that should not apply below the minimum, and a simple response-time budget of under 200 ms per request. Result:
8 passed in 0.18s
0.53s call test_no_overselling_under_concurrency
Each test checks a business outcome across the API, the business rules, the database and the stock counter together: exactly the system-level view.
What the suite caught
To see whether the tests had teeth, we removed the lock that serialises stock updates and added a tiny delay inside the order handler, simulating a slower database. The concurrency test then failed with:
E http.client.RemoteDisconnected: Remote end closed connection without response
1 failed
Ten simultaneous orders crashed request handling outright, most likely because the single shared database connection was now used from several threads at the same moment. Unit tests of the order function, run one at a time, would never see this; only a test of the deployed system under concurrent use did. The same scenario would also catch overselling, a classic race condition in shops and booking systems.
Tip: include at least one concurrency scenario for any resource that can run out: stock, seats, coupon redemptions, account balances.
The system test environment
- Match production as closely as possible: same operating system family, database engine and version, configuration and integrations.
- Use realistic data volumes; many bugs only appear with large tables.
- Replace third-party services with sandboxes or reliable fakes, documented in the test plan.
- Reset data between runs so results are repeatable.
Automating system tests
Automate stable, high-value flows such as checkout, sign-up and refunds, and run them in CI on every deployment to a staging environment. Keep them fewer than unit tests, because they are slower and more fragile. API-level system tests, like ours, are faster and more stable than browser tests, so cover business rules through the API and keep a thin layer of UI checks. Our API testing with Python guide shows the building blocks. Exploratory testing by skilled testers remains valuable on top, to find what nobody scripted.
Common mistakes
- Starting system testing on an unstable build.
- Testing screens instead of complete user outcomes.
- An environment so different from production that results mean little.
- Ignoring non-functional requirements until the end.
- No concurrency or failure scenarios.
- Duplicating every unit test at system level, making suites slow and brittle.
Final thoughts
System testing is where a product is judged as a whole, against its requirements, in a realistic environment. Define entry and exit criteria, design scenarios around user outcomes, include both functional and non-functional checks, and automate the stable core flows. Our small shop showed why it matters: everything worked one request at a time, and only the end-to-end concurrency scenario revealed the crash. Pass system testing, and acceptance testing can focus on whether the product is what users actually need. The full flow is described in our software testing life cycle guide.
Frequently asked questions
What is system testing in software testing?
It is testing of the complete, integrated system against its requirements, usually through its external interfaces as black-box testing, before user acceptance testing.
What is the difference between system testing and integration testing?
Integration testing checks that components work together across their interfaces. System testing checks the entire assembled system and its complete flows against the requirements.
Is system testing black box or white box?
It is mainly black box. Testers use the system through its user interface, API or other external interfaces without relying on knowledge of the internal code.
What are the types of system testing?
Common types include functional, end-to-end, regression, performance, load, stress, security, usability, recovery, compatibility and installation testing.
Who performs system testing?
Usually an independent test team or testers who did not build the features, in a production-like environment, often with automated suites run in CI.
Keep learning
Need help with testing, WordPress or SEO?
We help teams ship better software and grow their sites. Tell us what you are working on and we will suggest a clear next step.