Software testing: types, approach and when to use what

Software testen: soorten, aanpak en wanneer je wat inzet
Date
November 15, 2026
Author
Isatis Group
Category
Blog
Read time
8 min read

Learn which types of software testing you need, how to build a test strategy in five steps, and when to use manual or automated tests.

It's Friday afternoon and the release is ready. A small change to the price calculation has gone in, and the demo looked fine. On Monday morning it turns out the invoice export is no longer correct, because nobody had looked at that export again. It was one line of code, but the customer is on the phone anyway. A situation like this rarely comes from carelessness. Usually there's no agreement on what you test, when, and how deeply.

You test software at several levels: unit, integration, system, regression, performance and acceptance tests. Each level catches a different kind of defect, so you choose based on risk: what does it cost if this component breaks, and how often does it change? Fast automated tests form the foundation. You keep manual testing for what needs human judgment.

Software testing: the types at a glance

If you search for software testing, you run into a pile of terms. These are the types you need in practice:

  • Unit tests: check one small piece of logic, such as a VAT calculation. They run in seconds and show you exactly where it goes wrong.
  • Integration tests: check whether components work together, such as your application with the database or with an external API.
  • System tests: test the complete application as a whole, from logging in to completing an order.
  • Regression tests: check that what worked yesterday still works today. They're the reason a small change doesn't quietly wreck the invoice export.
  • Performance tests: measure how the system behaves with many users or large data volumes.
  • Acceptance tests: let the client or the user judge whether the software does what was agreed.

There are also security tests, accessibility tests and exploratory testing. In the latter, a tester without a script looks for behavior nobody had thought of. Not every project needs everything. An internal tool for ten colleagues calls for something different than a customer portal with thousands of users.

Which test to use when

A useful rule of thumb is the test pyramid: lots of unit tests, fewer integration tests and even fewer tests that run through the whole application via the screen. The higher you go up the pyramid, the slower and more brittle tests become. That's why you put most of your effort at the bottom.

Match the type of test to the moment in the project:

  • While building: unit tests and integration tests, which the developer runs before the code is merged.
  • On every build: a compact set of regression tests, so you know within minutes whether something has broken.
  • Before a release: system tests and the most important user journeys, plus exploratory testing on the components that have changed.
  • Before a peak or go-live: performance tests with realistic numbers of users and realistic data.
  • Just before handover: acceptance tests by the people who will be using the software.

Look at risk too. A payment step or a link to a healthcare system deserves more testing than a text page. Write down which components you consider critical, so the discussion about test depth doesn't start over with every release. That saves time and stops the deadline from deciding how much you test.

Manual or automated testing

This isn't an either-or choice. Automated tests are strong at repetition: the same check on every build, without anyone losing an afternoon to it. Manual testing is strong where curiosity and judgment are needed, such as with a new screen, an unclear error message or a workflow that has to feel logical.

In practice, the bottom layer is the one most often automated. According to the ASQF e.V. survey from 2024, more than three quarters of participants had automated at least three quarters of their unit tests, while at higher test levels about a third had got that far. That fits the picture that unit tests are the easiest to automate and that work at the integration and system level more often gets left undone.

Testing in the pipeline is also gaining ground. According to the RSE International Survey 2022, 46.97 percent (31 of 66) of Dutch respondents used automated testing with continuous integration, compared with 0 percent in 2018. This is a small group of respondents, so read it as a signal and not as a market average.

If you want to release changes quickly and safely, you need automated tests like these. You can read how a pipeline makes that speed possible in patch management with CI/CD: updates live in hours.

Creating a test strategy in five steps

A test strategy doesn't have to be a forty-page document. Two pages that the team actually reads work better than a folder nobody opens. These steps will get you there:

  1. Take stock of risks. Which functions are business-critical, which change often and where is most of the complexity?
  2. Choose the levels. For each risk, decide which test level fits best and drop what adds little.
  3. Decide what to automate. Start with what runs often and is stable: regression of core processes, API tests and unit tests. Don't automate screens that still change every week.
  4. Set release gates. Agree on when a build can go through, for example when all regression tests pass and there are no blocking defects open.
  5. Evaluate after every release. Which defects did you only find in production? Those are the gaps in your strategy, so fill them.

By doing this in a fixed cycle, your testing approach grows along with the product. You then test what matters now, not what mattered two years ago.

Quality starts before the first line of code

Many defects don't originate in the code but in the question. If nobody has defined what the software should do in an edge case, the developer builds something they think is reasonable, and the client later decides it isn't right. That's why testing is also part of reviewing requirements.

What helps:

  • Reviewing requirements before development begins, with someone who thinks like a tester.
  • Naming edge cases early: empty fields, duplicate input, time zones, large files and users with limited permissions.
  • Making acceptance criteria measurable. So don't write that the application has to be fast, but set a response time under an agreed load. You can read how to put that in a contract in defining acceptance criteria in your contract.

This way, acceptance at the end becomes a decision instead of a debate. It also reduces rework, because a misunderstanding you find in the requirements costs far less than the same misunderstanding in production.

What you can expect from a testing partner

If you bring in outside help, watch for these points:

  • Transferable tests. Automated tests are code. With clean code, clear names and a modular structure, your own team can extend them without staying dependent on the party that wrote them.
  • A strategy that fits your risk. Not a standard package, but choices based on your release rhythm and what goes wrong if something fails.
  • A clear role for AI. AI can suggest test cases, but a QA engineer decides what goes into the test set.
  • Honest feedback. A tester who only brings good news adds little.

At Isatis this falls under quality assurance and testing: test strategy and planning, test automation and the quality processes around it, such as reviewing requirements, defining acceptance criteria and release gates. We test our own software and that of others.

Frequently asked questions

What's the difference between unit tests and integration tests?

A unit test checks one small component in isolation from the rest, such as a calculation. An integration test checks whether several components work together, such as your application with a database or an external integration. You need both, because a component can be correct on its own and still fail as soon as it talks to other components.

How much of my testing should I automate?

There's no fixed percentage that works for everyone. Automate what comes back often, is stable and covers a lot of risk, such as regression tests on core processes and API tests. Leave exploratory testing and the assessment of new screens to people.

When do you start testing?

At the requirements, so before there's any code. You then assess whether the requirements are clear and testable. Unit and integration tests follow during the build, and system and acceptance tests before handover.

Can an external team test software it didn't build itself?

Yes. It can work well, because a tester with fresh eyes also spots assumptions the build team no longer notices. It does help if you make documentation, test environments and a point of contact available. Isatis also tests software from other parties.

Want to know which tests fit your software, or are you unsure whether your current approach covers enough? Then schedule a short 15-minute conversation via the contact page. You tell us what you want to achieve and we'll honestly tell you whether we can help.


About the author: Jeroen Penninx, Director and co-founder of Isatis.

Share this article

Jack van Poll

Jack van Poll

Co-Founder, Isatis

Writes about nearshore engineering,
software partnerships and building teams that last.

Get in touch

Read next.

All articles