Why the scanner is blind
Why no automated tool will ever find a stacked discount
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
An automated tool finds flaws by recognising something malformed — a value that escapes its field, a call to a known-dangerous function, a request that violates a rule. A business-logic flaw does none of that. Consider a promotion that gives ten per cent off. Applying it once is intended. Applying it, removing an item, and reapplying it so the discount compounds; or opening the same cart in two tabs and redeeming the single-use code in both before the system records either — every request in those sequences is perfectly valid. There is nothing malformed for a tool to catch, because the flaw is in the meaning of the sequence, not in any one message.
This is why business-logic testing cannot be bought as a scan. The tester has to know that the discount was meant to apply once, that the order was meant to wait for payment, that the approval was meant to be unskippable — none of which is written in the code as a rule a tool could read. It is written in the intent of the business. So the work begins not with a payload list but with a conversation about how the process is supposed to run, from which the ways to break it are derived.
From process map to test
How a process map becomes a set of logic abuse cases
Because the flaws live in intent, the test is designed backwards from how the process is meant to run. Each assumption the workflow relies on is a candidate to violate deliberately.
1 · Map the process as it is meant to run
We sit with the people who own the workflow and draw its steps, its order, and the assumptions baked into it: this step comes before that one, this happens once, this quantity cannot go negative, this state cannot be reached without the previous one. A map of the workflow and every assumption it rests on.
2 · Turn each assumption into an attack
For every assumption the map exposes, we write the case that violates it: reach the last step directly, run the once-only action twice at the same instant, submit a negative quantity, apply the discount out of order. The assumptions are the test plan. A list of abuse cases, each tied to an assumption to break.
3 · Drive the workflow to the wrong outcome
Each case is run against the live workflow using only valid requests, and we record which ones the process allows to reach an outcome it should have refused — the compounded discount, the confirmed unpaid order, the skipped approval. The cases the workflow fails to refuse, demonstrated live.
4 · Explain the fix at the logic, not the input
A logic flaw is fixed by enforcing the assumption the code left implicit — a server-side check that the step order held, a lock so the once-only action is once, a re-validation of state at the final step. We describe the fix where the decision is made, not by filtering an input that was never malformed. A fix aimed at the decision, expressed in the workflow's terms.
An illustrative case
The race condition that let one balance be spent twice
Illustrative engagement, not a named client
A wallet feature let a user spend a stored balance. The code read the balance, checked it covered the purchase, then deducted it — three steps that everyone assumed ran as one. In normal use they effectively do, because a person clicks once and waits.
- 01From the process map, the assumption "the balance is read, checked and deducted atomically" stood out as untested, so the case was to fire two purchase requests at the same instant.
- 02Both requests read the same starting balance before either deduction was written, both passed the check, and both were allowed — spending the balance twice. Every request was valid; the flaw was the gap between reading and writing.
- 03The fix was not input filtering but a lock making the read-check-deduct one indivisible step, so a second concurrent request waits for the first to finish and then sees the reduced balance.
A scanner would have reported nothing on this workflow, because no request in it was ever malformed. Only a test written from the process — knowing the balance was meant to be spent once — could have found it.
Our role
What business logic testing depends on getting from you
- 01
You explain the intent, we find the abuse
The test cannot be done blind. We need the people who own the workflow to tell us what it is meant to do; from that intent we derive the ways it can be driven wrong, which no code or scanner reveals on its own.
- 02
We test the sequence, not the message
Every request we send is valid, because that is the nature of a logic flaw. We prove the outcome, not a malformed input, and show the exact sequence that reached it so the finding is reproducible.
- 03
Your team owns the process decision
A logic fix often changes how the business rule is enforced, which is a decision for the people who own the process, not only the engineers. We describe where the check belongs; you decide the rule it enforces.
What the workflow is meant to allow, and how strict each rule should be, are yours to define; we take that intent, find where the process can be driven past it using only valid requests, and show the sequence and the fix.
Common questions
What buyers ask
If a scanner cannot find business logic flaws, what tool do you use instead?+
The primary tool is an understanding of what the process is for, which no software supplies. We do use technical tooling — a proxy to capture and replay requests, scripts to fire concurrent calls for a race condition, a way to alter a request between the client and the server — but those are instruments for executing a test case, not for discovering one. The discovery comes from mapping the workflow with the people who run it and asking, at each step, what the code is assuming and what happens if that assumption is deliberately broken. A tool can send the malformed sequence once we know which sequence to send; it cannot tell us that the discount was meant to apply once. That judgement is the service.
How much of our internal process do you need us to reveal for this to work?+
Enough to know what each workflow is meant to guarantee, which is more than a black-box tester gets and is the whole reason the test works. We need to understand the intended order of steps, which actions are meant to happen once, which states depend on earlier ones, and where money, stock, entitlements or approvals change hands. We do not need your source code — this is not a code review — but we do need the people who own the process in the room, because the flaws are gaps between what the code enforces and what the business assumed. The more accurately you describe the intent, the more precisely we can find where reality diverges from it.
Does business logic testing replace an application penetration test?+
No — it covers the class of flaw the others miss, and misses the classes they cover. A standard application test and a scanner are strong on technical vulnerabilities: injection, broken authentication, misconfiguration, the malformed input a tool recognises. They are weak to blind on logic, because nothing in a logic abuse is malformed. Business logic testing is the reverse: it finds the stacked discount and the skipped approval and would not, on its own, catch an injection flaw. The honest position is that they are complementary. An application is well covered when both have been done — the technical test for what is broken in the mechanics, and the logic test for what is broken in the meaning.
In this cluster
Walk us through the workflow
A workshop that turns your process map into a set of logic abuse cases, then a test that drives the workflow to the outcomes it was never meant to reach and reports how each was possible.
Start the conversation
