Security testing has a reputation problem. Teams imagine it as something a specialist does once a year, produces a long PDF about, and then everyone ignores until the next audit.
In practice most of what protects a web application is ordinary work that a good QA team does every sprint. The specialist work matters, but it sits on top of that, and it is wasted money if the basics are missing.
This guide covers what to test, what to automate, who should do which part, and how much of it you actually need at your stage.
The four layers of security testing
| Layer | What it is | Who does it | How often |
|---|---|---|---|
| Secure development | Code review, dependency checks, static analysis | Developers | Every pull request |
| Security in QA | Access control, input handling, session behaviour tested as features | QA engineers | Every sprint |
| Automated scanning | Tools that crawl the running app and flag known problems | CI pipeline | Nightly or weekly |
| Penetration testing | A specialist attacking the system on purpose | External team | Yearly, or before a major release |
Most teams buy the fourth layer and skip the second. That is the wrong order. A penetration test that spends its first two days finding problems your own QA could have caught is an expensive way to write a to-do list.
What QA should test every sprint
These checks need no special tools and no security background. They need someone who is willing to try the thing the interface does not offer.
Access control
This is the single most common serious finding, year after year, and it is entirely testable by a normal QA engineer.
- Log in as a low-privilege user and open a URL that belongs to an admin screen. Do you get a refusal, or the page?
- Take a request that loads your own invoice and change the id to somebody else’s. Does the server check ownership, or only the interface?
- Call the API directly, without the front end. The browser hides the delete button from a viewer; does the endpoint behind it also refuse?
- Remove a role from a user while they are logged in. Does their session lose the rights immediately, or at next login?
The pattern behind all four: the interface is not a security control. Anything the browser enforces must also be enforced on the server, and that is what you are checking.
Input handling
Every field that reaches a database, a file system or another service should be tested with input it does not expect: very long strings, unusual characters, the wrong type, an empty value, a negative number where only positive makes sense.
You are not trying to break in. You are checking two things: that the application rejects what it should reject, and that when it rejects something it does so cleanly — no stack trace, no database error message, no internal path shown to the user.
Sessions and authentication
- Does logging out actually end the session on the server, or only clear the browser?
- Does changing a password end the other active sessions?
- Is there a limit on failed login attempts?
- Does a password reset link expire, and can it be used twice?
- Do error messages tell an attacker whether an email address exists in the system?
What the application reveals about itself
Check what an ordinary visitor can see: detailed error pages, debug mode left on, directory listings, an admin panel on a guessable address, API documentation that was meant to be internal, version numbers in headers. None of these is an attack on its own; together they are a map.
Transport and storage
HTTPS everywhere, with HTTP redirecting to it. Security headers present. Cookies marked Secure and HttpOnly. Sensitive data not written to logs — a surprising amount of the personal data that leaks does so through log files nobody thought about.
What to automate, and where
Three kinds of automated checks belong in a pipeline, and they catch different things.
Dependency scanning. Most vulnerabilities in a modern application are not in your code; they are in the libraries you installed. A dependency scanner reads your lock file and tells you which packages have known problems. This is the cheapest security win available: it runs in seconds and needs no expertise. Run it on every build and fail the build on a critical finding.
Static analysis. Tools that read the source and flag risky patterns — unvalidated input reaching a query, secrets committed to the repository, dangerous functions. Expect false positives at first; tune the rules rather than switching it off.
Dynamic scanning. A scanner crawls the running application and tries a catalogue of known problems against it. It finds the obvious and misses anything that needs context, which is why a clean scan is not a clean bill of health. Run it nightly against a test environment, never against production without agreement.
On top of these, the access-control checks above make excellent automated tests. A test that logs in as a viewer and asserts that a delete endpoint returns 403 is a normal API test, it runs in milliseconds, and it will fail the day somebody changes a permission by accident. That is exactly the kind of check we build into a test automation suite.
Penetration test, bug bounty, or in-house?
These three get compared as if they were alternatives. They are not — they answer different questions.
| Penetration test | Bug bounty | In-house QA | |
|---|---|---|---|
| You pay for | Time, fixed price | Results, per finding | Salary |
| Coverage | Agreed scope, deep | Unpredictable, broad | Everything you ship |
| Timing | A fixed window | Continuous | Every sprint |
| Produces | A report you can show an auditor | A stream of individual reports | Tests that keep running |
| Main cost | The invoice | Triage time, which people underestimate | Hiring |
| Good for | Compliance, a major release | Mature products with a hardened surface | Everything, always |
Two warnings worth stating plainly.
A bug bounty is not a cheap substitute for testing. It is often sold that way — you only pay for results. What that leaves out is triage: somebody on your team reads every submission, and most submissions are duplicates, out of scope, or not real. Opening a programme before your own basics are in place produces a flood of low-value reports and a large bill for findings you could have caught yourself.
A penetration test is a snapshot. It describes the system on the week it was tested. Everything you ship afterwards is untested. That is why the regular layers matter more than the annual one.
What this looks like at different stages
Early product, small team. Dependency scanning on every build, HTTPS and security headers configured properly, access-control tests for every role, no secrets in the repository. That is most of the realistic risk covered, and it costs almost nothing.
Growing product with real customers. Add static analysis, nightly dynamic scanning, and a security review of anything touching money, personal data or permissions. Write the access-control tests into the automated suite so they run on every release.
Regulated or handling payments. All of the above, plus an annual penetration test, a documented process for handling a report from outside, and an audit trail that shows who did what. In fintech this is not optional; see how we approach it on our fintech development page.
A checklist you can run this week
- Run a dependency scan. Fix anything critical.
- Search the repository history for keys and passwords. If you find one, rotate it — removing the commit is not enough.
- Take one API endpoint per role and check it refuses the roles that should not reach it.
- Confirm debug mode is off and error pages show nothing internal.
- Check that logout, password change and password reset all behave the way you assumed.
- Grep your logs for anything that looks like personal data or a token.
- Write down who is responsible when someone reports a vulnerability, and how they can reach you.
That last point is the one teams forget. Researchers do try to report things, and if there is no address and no owner, the report goes nowhere — or somewhere worse.
FAQ
Does security testing need a specialist?
The deep part does. But the checks in this article — access control, input handling, session behaviour, exposure — are ordinary QA work, and they cover a large share of what actually goes wrong.
How often should we run a penetration test?
Once a year for most products, and again before a release that changes authentication, payments or how personal data is handled. More often than that is usually money better spent on the regular layers.
Is an automated scanner enough?
No. Scanners find known patterns. They cannot tell that a viewer should not be able to reach an admin endpoint, because they do not know your rules. They are a floor, not a ceiling.
Can security tests run against production?
Read-only checks, yes. Anything that submits data, floods requests or attempts an exploit belongs in a test environment, with written agreement. Running a scanner against your own production system without telling your hosting provider is a good way to get blocked.
We are a small team. Where do we start?
Dependency scanning and access-control tests. Those two, in a week, remove more risk than anything else you could buy.
Getting help
Security testing is part of what our QA team does on client projects, alongside functional, regression and performance testing — not as a separate annual event but as checks that run with every release.
If you want someone to go through the list above against your product and tell you what is missing, that is a short engagement and a useful one. Our QA and software testing page explains how we work.

