MANUAL TESTING GUIDE
Manual Test Run: From One Check to a Regression Suite
The feature changed again. Do you still have the checks you made last time?
Unit tests, integration tests, and automated end-to-end tests are great at protecting behavior that has already been formalized in code. But during everyday development, we still test a lot of things manually.
A specific API response. An unusual error case. A frontend reaction to changed data. A WebSocket message. Sometimes, a sequence of actions that only makes sense in the context of one feature.
What exactly did I check last time?
You test something, fix a problem, confirm that it works, and move on.
A few weeks or months later, the same feature changes again.
You remember checking it. But what exactly did you check?
Some cases are already protected by automated tests. Others existed only in DevTools, a temporary note, or your memory. You remember the feature. Reconstructing the conditions you tested is another matter.
That was the problem I wanted to solve for myself.
I did not want another reminder to “test the feature.” I wanted to keep the practical checks behind it:
This request should still work.
This error response should still be handled correctly.
The UI should behave correctly with this response.
This WebSocket message should still produce the expected behavior.
Start from the application already running
There is no need to start this investigation with a request invented from scratch.
The application is authenticated.
The right environment is open.
The network path is already working.
Any VPN or development tunnel you need is already in place. You have reached the relevant screen, and the application is generating the traffic you want to investigate.
The request is not an example in a document. It comes from the feature in front of you.
That was where I wanted to start: with the real HTTP and WebSocket traffic, and the page whose behavior I needed to check.
I could investigate a different response, an error, or an unexpected message. But once I found a useful check, I wanted to keep it—not just the JSON I happened to copy.
That is the workflow I built PayloadPigeon around.
Turn useful checks into a regression suite
I wanted to keep more than a note saying “check the error state.” I wanted the response change I had used to check it.
During one feature change, I might verify the normal response, an error response, and what happens when an update arrives late. Those checks belong together because they protect the same functionality.
In PayloadPigeon, I can save each prepared scenario as a Test and group the related Tests into a Test Plan.
That is the regression suite I want here: not an archive of every request the application sent, but a small collection of conditions I deliberately want to check again.
A case earns its place because it exposed a problem, covers behavior that matters, or would take effort to reconstruct.

A manual test run after the next change
When the feature changes, I do not want to begin by finding the request again and rebuilding every response variation. I want to start with the checks I already considered important.
That is the starting point for the next manual test run. I return to the Test Plan, review the scenarios against the current feature, and repeat the relevant checks.
Then I record a Result: what I observed when I performed that check. Did the application behave as expected? If not, what was different?
A Result from last month tells me what I observed then. It is useful context—not proof that today's change works.

The saved scenario does not replay a whole browser session. I still prepare the page, perform the necessary actions, and assess the outcome myself. The usage guide explains the controls and setup.
For WebSocket message changes, start Capture before the application creates a supported connection. Reconnect through the application when needed; the WebSocket testing guide explains the setup.
PayloadPigeon does not replace automated testing. It gives me a way to keep the manual scenarios that were important enough to verify once—and useful enough to verify again later.
Try the workflow with one scenario in the Playground.
You will need the extension to capture and change traffic: Add PayloadPigeon to Chrome.