DEV Community

Priyanka
Priyanka

Posted on

UI vs Functional vs Network Bugs: How to Tell Them Apart

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.500 instead 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 £100 comes 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 /cart returns 200, 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:

  1. UI — SAVE10 appears in the field but the field's error state is styled invisible. Fix: CSS.
  2. Functional — the applyDiscount reducer runs but does not trigger a total recompute. Fix: state management.
  3. Validation — the code is rejected by a regex that excludes codes with digits. Fix: validation rule.
  4. Network — POST /discount returns 422 invalid_code and 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.

Top comments (0)