Originally published at bughuntlab.hashnode.dev
Four defect classes, one triage question, and why misclassifying costs you more than missing the bug.
The most common mistake in junior defect reports is not a missing screenshot. It is misclassification — calling something a UI bug when it is a network bug, or a functional bug when it is a validation bug.
This matters more than it sounds. Classification decides who fixes it, and a ticket that starts in the wrong queue loses a day before it even gets assigned.
The one question that separates them
For any observed wrong behaviour, ask: where did the wrong thing first happen?
Not where you noticed it. Where it originated.
| If the wrong thing happened... | Class | Who fixes it |
|---|---|---|
| In the pixels only | UI | Front-end / design |
| In the app's logic | Functional | Front-end or back-end |
| In the request or response | Network | Back-end / API |
| In what input was accepted | Validation | Either, but usually API |
UI defects
The behaviour is correct. The rendering is wrong.
- Prices showing
£12.500instead of£12.50 - A disabled button that still looks enabled
- Text overflowing its container on a 320px viewport
- A toast appearing behind a modal
The tell: if you read the underlying data (from the DOM, or a response), it is right. Only the presentation is wrong.
Why this matters: a UI bug is usually cosmetic severity but high volume. Ten of them in one release feels like a broken product to a user, even though nothing is functionally wrong.
Functional defects
The UI looks plausible. The logic is wrong.
- A discount applies, but the total does not recalculate
- Removing the last cart item leaves the checkout button enabled
- Sorting by price sorts by string, so
£100comes before£20 - A "save" button closes the dialog without persisting anything
The tell: the wrongness exists in application state, not just on screen. Refresh and it is either still wrong (persisted) or back to normal (not persisted) — which is itself diagnostic information worth putting in the report.
Validation defects
The system accepts input it should reject, or rejects input it should accept.
- Quantity field accepts
-3 - Email field accepts
test@with no domain - A password field accepts 200,000 characters and hangs the form
- A date picker allows a delivery date in the past
The tell: the defect happens at the boundary between user input and the system, before any business logic runs.
These are the highest-value bugs to find in most web products, because they are cheap to miss and often the entry point for worse problems. A quantity field that accepts negative numbers is a step away from a negative total.
Network defects
The UI and the server disagree about what happened.
-
POST /cartreturns200, but the item is not persisted - A request returns
500, but the UI shows a success toast - The response includes the right total, but the page renders a hardcoded one
- A request is fired twice (double-submit) because the button was not disabled
The tell: you have to look. Open DevTools, find the request, compare what the server said to what the screen says. Every network defect is invisible to a tester who only looks at the screen.
This is the class most juniors never report, and it is often the most serious — because a UI that lies about server state will eventually corrupt data.
A worked example
A discount code fails to apply. Same symptom, four possible diagnoses:
- UI —
SAVE10appears in the field but the field's error state is styled invisible. Fix: CSS. - Functional — the
applyDiscountreducer runs but does not trigger a total recompute. Fix: state management. - Validation — the code is rejected by a regex that excludes codes with digits. Fix: validation rule.
- Network —
POST /discountreturns422 invalid_codeand the UI swallows it. Fix: error handling.
Four different teams, four different fixes, one symptom. If your report says "discount code doesn't work", all four of those people have to investigate. If it says "POST /discount returns 422, UI shows no error", one person fixes it in an hour.
Practising classification specifically
Classification is a judgement call, and judgement improves with feedback. The reason it is hard to practise alone is that nobody tells you what the seeded fault actually was.
That is the specific gap BughuntLab fills: each challenge has five seeded faults, and your report is scored on whether you identified the component and classification correctly, against a hidden answer key. Getting the symptom right but the class wrong costs points, which is a fair model of what happens at work.
You can see the report format in the walkthrough without signing up for a challenge.
Disclosure: I build BughuntLab, linked above. The taxonomy and the four-diagnosis example are standard practice and useful independently of any tool.


