I learned this method running a parity audit on a pre-launch multi-step web flow. The product, the team and the employer stay unnamed here, and every example below is illustrative: none of it is a row from that tracker.
The review that ends in a shrug
Picture a design review on a pre-launch flow with a handful of steps. The design team clicks through the live build. People point at the screen. The verdict, in three different phrasings, is that it looks off.
Nobody is wrong. The build does not match the frames. But when the call ends there is nothing anyone can pick up. No ticket, no list, not even agreement on which screens are the problem. The next planning session starts from memory, and memory in a room is not an input.
Converting that feeling into rows is the most useful thing I have learned in my first year of product work.
Why vague feedback dies
"It looks off" is missing three things, and each absence is fatal on its own.
No owner. A comment addressed to the room is addressed to nobody, so it survives until someone volunteers, which is never.
No location. "This step feels wrong" could mean the layout, the spacing, the controls, or the copy around them. An engineer forced to guess picks the cheapest reading.
No severity. Everything is then urgent or ignorable depending on who raised it last, and the sprint fills with cosmetics while a broken control ships.
A parity audit supplies all three.
The tracker is the artefact
The method is plain: go through every screen against its frame, click the build, and read the code where behaviour is ambiguous. Every finding becomes a row. The columns I recommend:
- ID as screen.number, so 4.2 means the same item in every conversation.
- Where: the screen, and the exact region on it.
- Differs from design: what the build does instead, with the frame reference.
- Action: the change, rather than the complaint.
- Severity, Source, Owner and Status.
An illustrative slice, from an invented sign-up flow for a booking app:
| ID | Where | Differs from design | Action | Severity |
|---|---|---|---|---|
| 1.3 | Account step, Continue button | Stays disabled after every field is valid | Enable it once validation passes | P1 |
| 2.1 | Step indicator | Shows three steps; the flow has four | Match the indicator to the real step count | P2 |
| 2.4 | Phone field | Format hint missing; users learn the format only from the error | Restore the hint text from the frame | P2 |
| 3.2 | Confirm step, primary button | 4px corner radius where the frame has 8px | Use the radius token from the frame | P3 |
The columns are the trick. "Where" ends the guessing. "Differs from design" stops the row being an opinion, because it names a frame anyone can open.
The priority rule
Agree a rule of thumb and apply it uniformly. Applying it consistently matters more than the rule being perfect.
P1 is a blocked or lying happy path. A Continue button that never enables. An error message that blames the wrong field. A confirmation that reports success when the request failed. These are not visual defects; they are the product stopping the user or telling them something untrue.
P2 is drift that changes comprehension. A step indicator that miscounts, so users cannot tell how far they are. Helper text that is missing, so a requirement is discovered only by failing it. The user finishes, but understands less than intended.
P3 is cosmetic. A corner radius off by a few pixels. An icon one size too small. A divider in the wrong shade.
Where each row comes from
Rows come from two sources: the design team's walkthrough and your own pass through the build and the code. A Source column records which.
That makes the tracker auditable. A challenged row gets one of two answers: design raised it on the walkthrough, or I found it and here is the frame. Neither is an opinion.
It also makes room for rows that run the other way. Expect some where the build is right and the frame is wrong, so the action is to change the design. Those matter more than their count suggests. An audit that only produces work for engineering reads as a list of complaints; one where the arrow sometimes points at design is a shared quality exercise.
Splitting out content dependencies
Some items are not code at all: they depend on content that has to exist before the build can show it. Left in the main list they read as engineering failures, and status reviews get spent re-explaining that they are blocked elsewhere. Give them a separate series with their own owners.
What happens next
The tracker goes to the team as a ranked backlog. I am not reporting which rows were fixed on the flow I audited; that is the team's story to tell. The point of the format is that once a row has an ID, a location, a severity and a name against it, prioritisation is mostly arithmetic.
P1s go first, for a reason that fits in one sentence: they are the ones that lie to the user. A misaligned control makes a build look unfinished; a confirmation that reports a success that never happened makes it untrustworthy, and polish elsewhere does not repair that.
What I would do differently
Link every row to a frame ID from the start rather than adding references afterwards. Review disputes often turn out to be two people looking at different versions of a frame.
Agree the priority rule before the walkthrough, not after. With the tiers settled up front, the walkthrough produces sorted rows, and nobody relitigates later whether a corner radius is urgent. That is the same instinct as scoping an ambiguous problem before solving it, which I wrote about in my structured thinking framework.
Do the boring version
If a review ends with "it looks off", the review has failed. Open the frames, open the build, write the rows. Give every row a place, a severity and a name. Vague feedback is not kindness to your team. It is work you have declined to do, handed to someone with less context than you.
