Hi people,
This story started with a workflow that looked very familiar: complete a few steps, attach the required evidence, and submit the case for review.
I was testing the process with my own controlled record. One required item was still missing, so I expected the final action to fail. Instead, the interface showed a completion message and moved the record into a submitted state.
At first I did not know whether this was only a front-end issue. A friendly success banner is not enough to prove a security finding. I needed to check what the server had actually stored.
Publication note: This story is reconstructed from private research. The company, product, routes, identifiers, dates, and UI labels were removed or replaced. The examples are synthetic. I am not claiming that a fix was deployed or that a completed retest occurred.

What I expected the workflow to do
The rule seemed straightforward. The record could remain in a collecting state while evidence was incomplete. Only after every required item existed, belonged to that record, and finished processing should the server mark it ready for review.
The user interface appeared to follow this rule. It showed the missing requirement and encouraged the user to complete it. But interfaces are suggestions. The real security decision happens when the server receives the final transition request.
How I proved it was more than a message
After the completion screen appeared, I reopened the record and checked its status through a separate read path. The server returned the submitted state even though the required evidence was still absent. I repeated the flow from a clean starting point and observed the same result.
The evidence I needed was the contradiction itself: the authoritative record said submitted, while the authoritative evidence set said incomplete. A synthetic version of that comparison looks like this:
GET /cases/[CASE]/status HTTP/1.1
Host: workflow.example
Authorization: Bearer [REDACTED]
Accept: application/json
HTTP/1.1 200 OK
Content-Type: application/json
{"state":"submitted","required_evidence":"missing","decision":"not_set"}
This is not an original response. The host, route, fields, and values were created for the article. It represents the three facts that mattered during the controlled test.
The claim I did not make
This is where careful wording matters. I proved that the record reached submitted state without all required evidence. I did not prove that a reviewer approved it, that a downstream service granted access, or that another person's data was affected.
Submitted and approved are different security states. The first says the collection phase is complete. The second says an authorized decision was made. A broken submission gate can be important without pretending that the approval gate was also bypassed.
Keeping that line clear made the report stronger. The finding did not depend on a dramatic guess about what might happen later. It depended on a reproducible server-side state that should have been impossible.
Why this kind of bug appears
Multi-step workflows often trust a flag produced earlier in the process. The interface may set a step to complete, an upload service may return an object ID, or a background worker may still be processing an artifact. If the final transition trusts those client-visible signals instead of reading the current stored evidence, the workflow can move forward with an incomplete snapshot.
There is also a timing problem. Evidence can change between the check and the state update. A safer design evaluates the server-owned policy and the finalized evidence in one consistent transaction, records the evidence revision used for the decision, and writes the submission event with the same commit.
How I would repair the boundary
The client should request submission, not declare that submission is valid. The server should load the current record, verify the actor can submit it, load the correct policy version, and confirm every required artifact is finalized and belongs to the same record.
Retries need a rule too. Repeating a completed request should return the existing receipt or a documented conflict. It should not create a second logical submission. If the evidence revision changed, the server should reject the stale request or evaluate the new snapshot deliberately.
Open-source workflow companion: Nuclei
Once I had seen this workflow contradiction, I could turn the minimum safe proof into a custom Nuclei template. Nuclei uses human-readable YAML templates and supports multi-step workflows. I would model three bounded steps: create or reset my controlled incomplete record, attempt the final transition, then read the authoritative status through a separate path. The matcher should fire only when the record is submitted while the required evidence remains absent. That makes the result repeatable without treating a success banner as proof. This is a current workflow recommendation, not a claim that Nuclei was used in the original private submission. Run it only against an authorized test account with a strict request limit.
Takeaway
- Do not trust a client-side completed flag as evidence.
- Validate stored prerequisites again at the final state transition.
- Bind every artifact to the correct record and require processing to be final.
- Keep submitted, verified, and approved as separate states with separate authorization rules.
- When reporting, prove the state you reached and avoid claiming the state you did not.
The lesson I kept from this test was simple: a workflow status is a promise to every system that reads it. The server should only make that promise after it has checked the facts behind it.
That is all for this write-up. Hope you found it useful. The related story the draft you could change but could not read shows another place where a stored state carried more truth than the response message. You can also browse the complete Bug Bounty Archive.
Test the workflow, not only the screen.
Explore our SaaS penetration testing service or continue through the Bug Bounty Archive for more first-person security research.
Research topics: bug bounty / business logic / workflow security / evidence validation