Hi people,
This story began with a very simple test: open the same shopping flow in two clean browsers and make sure they stay separate. No accounts, no shared cookies, and no copied storage. I expected two anonymous sessions and two independent carts.
That is exactly what I saw at first. Then one navigation value changed the result.
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, and I am not claiming a deployed fix or completed retest.

Two clean browsers, two clean carts
I started Browser A with a fresh profile and added a harmless item to its anonymous cart. Browser B used a different fresh profile and added a different item. Their cookies and local storage did not overlap.
I refreshed both sides, changed quantities, and checked the cart summaries. Everything behaved normally. That control mattered because it showed the application was capable of creating separate state for separate visitors.
I also recorded the harmless contents on both sides before changing anything. That gave me a clean before-and-after view and stopped an ordinary refresh, duplicate item, or stale interface from looking like a cross-session result.
Browser A -> session_alpha -> cart_alpha -> item RED
Browser B -> session_beta -> cart_beta -> item BLUE
At this point there was no finding. Two carts existing at the same time is not enough; I needed to understand how the application selected the active cart during each action.
The clue was in navigation state
While moving between pages, I noticed a cart reference travelling through a browser-controlled navigation value. It looked like ordinary state used to keep a visitor on the right step of the flow.
I copied only that placeholder value from Browser A into Browser B and repeated a normal cart edit. Browser B still had its own session cookie, but the change appeared in Browser A's cart.
This was the important twist: the server appeared to have two possible answers for "which cart is this request about?" One answer came from the session. The other came from navigation state supplied by the browser. In the tested path, the second answer won.
How I proved it was not a display bug
A strange cart screen can come from stale HTML, client caching, or a front-end mix-up. So I did not rely on what Browser B displayed after the request.
I returned to Browser A and loaded the cart through its original session. The quantity and marker changed by Browser B were present. I then made another controlled change from Browser A and observed it from the path using the copied reference.
That two-way observation established shared server-side state. The browser that should have remained tied to cart_beta had been allowed to act on cart_alpha.
I kept the impact narrow. This did not prove account takeover, payment access, or a way to discover unknown cart references. The result demonstrated an anonymous session-isolation failure with a known controlled reference.
Where authority should have lived
Navigation values are useful for continuity, but they should not become authority. The server already had a session-bound cart. A client-supplied reference could be checked as context, but it should not silently replace the cart selected by the authenticated or anonymous session.
There are several safe designs. The server can ignore the client reference and derive the cart from the session. It can bind a reference to the same session and reject mismatches. If carts are intentionally shareable, it can use a separate, explicit capability with a clear lifetime and scope.
The dangerous middle ground is treating a routine identifier as if possession automatically grants control.
Open-source workflow companion: Turbo Intruder
One open-source tool I would bring to a test like this is Turbo Intruder. It can queue and analyze controlled HTTP request sequences, with Python scripts defining the order. Here I would use it carefully, not for volume, but to build a small authority matrix: cookie A with reference A, cookie B with reference B, then the two crossed combinations. Filtering results by a controlled cart marker makes the server's authority choice easier to see and repeat. It can also support bounded simultaneous updates after the sequential boundary is understood. This is a current workflow recommendation, not a claim that Turbo Intruder was used in the original private submission. Keep every request and object inside the authorized test scope.
The takeaway
When testing stateful workflows, I like using two clean browsers because they make authority visible. Cookies, local storage, and navigation values can all point at different objects. The question is which one the server trusts when they disagree.
A good retest would begin with two isolated carts, deliberately introduce a foreign reference, and verify that the request is rejected without changing either cart. It should also confirm that normal refreshes and valid sharing still work.
That is all for this write-up. The small testing habit I kept from it is to make browser state disagree on purpose. Interesting boundaries often appear in the disagreement.
For another authorization story, read The draft you could change but could not read, or browse the complete Bug Bounty Archive.
Follow state across the whole workflow.
Explore web application penetration testing for session and business-logic testing, or continue through the archive.
Research topics: session isolation / cart security / state precedence / business logic