1. Home
  2. Blog
  3. Software Testing

Software Testing

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.

9 min read
System testing explained: types, process and a real end-to-end example

Key takeaways

  • 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

  1. Plan: scope, approach, environment, schedule, roles and criteria.
  2. Design: derive scenarios and test cases from requirements.
  3. Prepare: environment, test data, accounts and tools.
  4. Execute: run tests, manual and automated, and record results.
  5. Report defects: with clear reproduction steps; see our bug report guide.
  6. Retest and regress: confirm fixes and check nothing else broke.
  7. 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

Work with Stack Quora

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.

Keep reading

More guides on testing, AI & modern development

Enjoyed this article? Pick a topic and jump straight into our newest tutorials.

Artificial Intelligence

Random Forest in Python: Bagging, Feature Sampling and OOB From Scratch

Random forest in Python from scratch: bootstrap sampling, feature sampling, number of trees, out-of-bag evaluation and impurity vs permutation importance.

Read article →
Software Development

MIME Types Explained: Content-Type, nosniff and a Common Types List

MIME types explained and tested in a browser: Content-Type, nosniff, scripts and stylesheets with wrong types, a common MIME types…

Read article →
DevOps

Git Clean Explained: Remove Untracked Files Without Regret

Git clean explained with dry runs: -n, -f, -d, -x, -X, exclusions, paths, nested repositories and interactive mode, plus a…

Read article →
Test Automation

Pytest approx: Comparing Floats With rel, abs and Collections

Pytest approx explained: default tolerances, the near-zero trap, rel and abs, lists and dicts, NaN, NumPy, and how it differs…

Read article →
Software Testing

Accessibility Testing: WCAG Checklist, Automated Tools and Manual Checks

Accessibility testing explained: WCAG basics, an axe-core scan of a broken and a fixed page, what automation missed, contrast checks…

Read article →
Databases & SQL

SQL UNPIVOT: Turn Columns Into Rows, 4 Ways Tested

SQL UNPIVOT explained: turn columns into rows with UNION ALL, CROSS JOIN with CASE, JSON functions or native UNPIVOT, with…

Read article →
Software Development

Intl NumberFormat in JavaScript: Currency, Compact, Percent and Units

Intl.NumberFormat in JavaScript: locales, currency, compact notation, percent, units, rounding, formatToParts, the non-breaking space trap and formatter reuse.

Read article →
Software Development

Python Abstract Class: ABC, abstractmethod and When to Use Them

Python abstract class explained: ABC and abstractmethod, abstract properties, shared logic with super, register, collections.abc and ABC vs Protocol, tested.

Read article →
Software Development

Python Subprocess Explained: run, Capture Output, Timeouts and Safety

Python subprocess explained with tested examples: run, capture_output, check, timeouts, input, environment, shell injection, encoding on Windows and Popen streaming.

Read article →
Databases & SQL

SQL EXPLAIN Plan: How to Read Query Plans and Fix Slow Queries

SQL EXPLAIN plan explained: read scans, index searches, covering indexes and temporary sorts, with before and after timings for five…

Read article →
Artificial Intelligence

Decision Tree in Python: Gini, Entropy and Overfitting From Scratch

Decision tree in Python from scratch: Gini impurity, entropy, information gain, best splits, readable rules, and how depth and leaf…

Read article →
Software Development

URL Query Parameters: Encoding, URLSearchParams and Common Traps

URL query parameters explained: reading and building them with URLSearchParams and urllib, percent encoding, plus signs, repeated keys and nine…

Read article →
DevOps

Git Blame Explained: Find Who Changed a Line, and Why

Git blame explained with a real repository: ignore whitespace, line ranges and functions, ignore-revs files for formatting commits, moved code…

Read article →
Test Automation

Pytest Benchmark: Measure Speed and Catch Performance Regressions

Pytest benchmark tutorial: the benchmark fixture, reading results, parametrized and pedantic benchmarks, saving baselines and failing the build on regressions.

Read article →
Software Testing

Defect Density: Formula, Worked Examples and How to Use It

Defect density explained: the formula, a five-module worked example, per KLOC vs per function point, severity weighting, defect removal efficiency…

Read article →
Databases & SQL

Case Insensitive Search in SQL: LOWER, LIKE, COLLATE and Indexes

Case insensitive search in SQL: LOWER, LIKE, COLLATE NOCASE and expression indexes compared with query plans, plus accented letters and…

Read article →
Databases & SQL

ON DELETE CASCADE in SQL: CASCADE vs SET NULL vs RESTRICT

ON DELETE CASCADE in SQL tested: CASCADE vs SET NULL vs RESTRICT, multi-level cascades, the SQLite foreign key pragma, row…

Read article →
Software Development

JavaScript BigInt Explained: Big Numbers, Division and JSON

JavaScript BigInt explained: the 2^53 limit, creating and converting BigInt, division, mixing types, JSON stringify and parse without losing digits,…

Read article →
Artificial Intelligence

Logistic Regression in Python: Sigmoid, Log Loss and Gradient Descent From Scratch

Logistic regression in Python from scratch: sigmoid, log loss, gradient descent, odds ratios, thresholds, sigmoid overflow and separable data, tested…

Read article →
DevOps

Git Worktree Explained: Work on Two Branches at Once

Git worktree explained: add, list, remove, prune, lock and detached worktrees, a hotfix workflow, and the errors you will hit,…

Read article →
Test Automation

Pytest ini Explained: addopts, markers, testpaths and Precedence

Pytest ini explained: testpaths, addopts, strict markers, xfail_strict, filterwarnings, minversion, config file precedence and command-line overrides, tested.

Read article →
Software Testing

Test Estimation Techniques: WBS, Three Point PERT and Monte Carlo

Test estimation techniques worked through: WBS, three point PERT, total uncertainty, a Monte Carlo check, percentage rules and Wideband Delphi.

Read article →
Databases & SQL

Gaps and Islands in SQL: Find Streaks and Missing Ranges

Gaps and islands in SQL: find login streaks and missing ranges with ROW_NUMBER, DENSE_RANK, LAG and LEAD, plus the duplicate…

Read article →
Databases & SQL

INSERT INTO SELECT in SQL: Copy Rows Between Tables Safely

INSERT INTO SELECT in SQL: copy rows between tables with chosen columns, joins and summaries, avoid duplicates on reruns, upsert,…

Read article →
Artificial Intelligence

Linear Regression in Python: Least Squares From Scratch, With R Squared

Linear regression in Python from scratch: closed form, NumPy least squares and gradient descent, R squared, RMSE, outliers and curved…

Read article →
DevOps

Git Remote Explained: Add, Set-URL, Rename, Remove and Push URLs

Git remote explained: add, set-url, separate push URLs, rename, remove and prune, plus how to avoid leaking tokens in remote…

Read article →
Test Automation

Pytest Mock: mocker.patch, spy, side_effect and autospec Explained

Pytest mock explained: mocker.patch, return_value, side_effect, spy, autospec and PropertyMock, with tested examples for APIs, clocks and retries.

Read article →
Software Testing

System Testing Explained: Types, Process and a Real End-to-End Example

System testing explained: types, entry and exit criteria, the process, and a real end-to-end test suite run against a small…

Read article →
Artificial Intelligence

Naive Bayes Classifier Explained: Build a Spam Filter in Python

Naive Bayes classifier explained by building a spam filter in Python: Bayes rule, the naive assumption, Laplace smoothing, log probabilities…

Read article →
DevOps

Git Branch Explained: Create, Switch, Rename, Delete and Recover

Git branch explained with tested commands: list, create, switch, rename, delete, merged checks, recovering deleted branches, remote tracking and naming.

Read article →
Test Automation

Pytest raises: Testing Exceptions, match and excinfo

Pytest raises explained with tested examples: match regexes, excinfo, custom and chained exceptions, parametrized error cases, pytest.warns and common mistakes.

Read article →
Software Testing

Non Functional Testing: Types, Metrics and a Real Load Test

Non functional testing explained: 10 key types, measurable requirements, latency percentiles and what a small real load test revealed about…

Read article →
Artificial Intelligence

K Means Clustering Explained: How It Works, With Python Code

K means clustering explained: the algorithm, a from-scratch NumPy version, choosing k with the elbow and silhouette methods, k-means++, scaling…

Read article →
DevOps

Git Log Explained: 15 Useful Commands and Pretty Formats

Git log explained with 15 tested commands: oneline, graph, filters by author, date, message and code, file history, stats, pretty…

Read article →
Test Automation

Pytest conftest.py Explained: Shared Fixtures, Hooks and Overrides

Pytest conftest.py explained with a tested suite: shared fixtures, scope and teardown, folder overrides, autouse, custom options, markers and useful…

Read article →
Software Testing

Usability Testing: Methods, Metrics, SUS Score and Checklist

Usability testing explained: methods, planning, writing tasks, running sessions, metrics, SUS scoring, how many users you need and a practical…

Read article →