Programming errors fall into six rough categories: syntax, runtime, reference, network, logic, and environment and configuration. The point of the taxonomy is not vocabulary — it is that each category leaves different evidence behind. Knowing the category tells you which error text, which request and which screenshot a bug report needs.
This article gives a table you can use directly, then walks through the eight errors front-end teams see most often to show why one error can belong to several categories, and ends with the practical part: how a single error becomes a report a developer can act on without asking three questions.
Why the taxonomy is worth its own article
Most teams do not struggle to understand what TypeError means. They struggle with three other things:
- Calling every red line in the console a bug, when half of them come from third-party scripts and browser extensions;
- Passing "the page does nothing" straight to the backend, when the front end never handled the response shape;
- Filing reports that say "it errors" and leave a developer twenty minutes of questions about which page, which browser and what was clicked.
All three are classification problems: the category decides the evidence, and the evidence decides whether the report can be fixed directly.
The six categories
| Category |
When it happens |
Typical message |
Where the first-hand evidence lives |
| Syntax |
The code cannot be parsed, so the whole script stops |
Unexpected token, Unexpected end of input |
The first red line in the console (everything after it is usually fallout) |
| Runtime |
The code runs, then fails at one step |
TypeError, RangeError, Cannot read properties of undefined |
Console plus the action that triggered it |
| Reference |
A variable, field or module that does not exist is used |
ReferenceError, x is not defined, undefined is not a function |
Console plus the page URL (which route failed to load) |
| Network |
A request fails, is blocked, is cross-origin or times out |
4xx / 5xx, blocked by CORS policy, net::ERR_ |
The Network panel: request URL, status code, response headers |
| Logic |
Nothing throws, but the result is wrong |
No red text at all |
Steps, expected vs actual result, a data sample |
| Environment |
Only on one machine, one environment or one account |
Unrelated 404s, blank page, assets failing to load |
Browser and OS version, viewport, build or environment marker, account permissions |
The most useful column is the last one: it tells you what to put in the report. A logic error has no error message to screenshot, so it needs steps and expectations. A network error cannot be explained by a screenshot at all, so it needs the request itself.
Syntax, runtime, logic: the borders are blurry
One message can belong to different categories depending on the root cause, not on the wording.
Uncaught TypeError: Cannot read properties of undefined (reading 'map') is a runtime error — code reached an undefined value and called .map on it. But the cause could be:
- The API response shape changed (network);
- The initial state is missing a default (logic);
- An async request had not returned before render (timing).
So "it throws a TypeError" is not enough. The report needs the request that produced the data. That is also why console errors and failed requests belong side by side: either one alone will mislead you.
The eight most common front-end errors
| # |
Message |
Usually means |
Where to look |
| 1 |
TypeError: Cannot read properties of undefined |
Data has not arrived, shape does not match, optional chaining missing |
Console plus the response of the matching request |
| 2 |
ReferenceError: x is not defined |
Undeclared variable, wrong script order, a module missing from the bundle |
Console plus script order in the page source |
| 3 |
blocked by CORS policy |
Preflight failed, or Access-Control-Allow-Origin missing |
Console plus the preflight request in Network |
| 4 |
An endpoint returns 404 / 500 |
Wrong path, deleted resource, server exception |
Network: URL, status code, a summary of the response |
| 5 |
Hydration failed because the initial UI does not match |
Server and client rendered different first screens |
Console plus the component involved |
| 6 |
Unhandled promise rejection |
An async failure with no catch, so the error disappears |
Console plus the action that triggered it |
| 7 |
Refused to load ... violates Content Security Policy |
CSP does not allow a new domain or inline script |
Console plus the page's CSP response header |
| 8 |
Mixed Content: ... loaded over HTTPS, but requested an insecure resource |
An HTTPS page requested an HTTP resource |
Console plus the blocked request in Network |
Treat this as a reporting checklist: classify the red line first, then add the evidence the right-hand column points to.
Errors, bugs and defects are not the same thing
- An error is a signal from the system. It may be a warning; it may be noise.
- A bug is a mismatch between implementation and expectation, and it usually needs a path that reproduces.
- A defect is what most trackers call a bug once it enters formal management.
The full distinction is in Bug vs Defect vs Issue vs Error. For anyone filing a report, one sentence is enough: an error is a clue, a bug is a conclusion. Reports supply clues; they should not deliver verdicts.
What evidence each category needs
| Category |
The report must contain |
Nice to have, not required |
| Syntax / runtime |
The exact message, page URL, triggering action |
Screenshot, short recording |
| Reference |
The exact message, the route that failed, the signed-in role |
The shape of the related response |
| Network |
Request URL, status code, triggering action, timestamp |
A response snippet (mind sensitive fields) |
| Logic |
Steps, expected result, actual result, a data sample |
A recording |
| Environment |
Browser and OS version, viewport, environment marker (production, staging, preview) |
Account permissions, build number |
The last row is the most overlooked: "it only happens on my machine" is itself the most valuable piece of information in the report, because it narrows the search from the whole site to one class of environment.
Getting the evidence without an interview
The manual route is to open DevTools, screenshot the Console and Network panels, and align timestamps by hand — see How to Open the Browser Console. That route has three practical problems: non-technical colleagues will not do it, they will not capture everything, and someone has to reconcile the times afterwards.
The cheaper route is to let the reporting tool carry it. Every BugCapturer report attaches the page URL (with sensitive parameters masked), browser and OS, screen and viewport, a timestamp, the verbatim console errors, and failed requests (4xx/5xx) with their status codes. The reporter draws a box around the problem and writes one sentence about what they saw; the other five columns arrive automatically.
The difference shows up in submission rate. Requiring people to learn the console filters out most non-technical colleagues; annotating on the page is what makes them file a second report.
Should your tracker have an error-type field?
If the ledger already holds a few hundred reports, an error_type field earns its keep — but only in three situations:
The same class of error keeps returning (a CORS failure every other week): classification exposes a systemic problem instead of one ticket at a time.
The reporter is not a developer: classification removes the "front end or back end" round trip.
You measure quality: distribution by type is fairer than distribution by person.
If the team is three to five people filing fewer than twenty reports a week, the field is just extra typing. Get the evidence complete first, then talk about classification.
Three common mistakes
- Treating every red line as a bug: browser extensions, analytics scripts and ad blockers all write errors into the console. The test is whether it changes what the page does.
- Ignoring warnings: React key warnings, hydration warnings and deprecation notices are not bugs, but they are often the precursor to one.
- Forwarding a 500 straight to the backend: the status code says the server failed, but the report still lacks the request URL, the parameter names and the action. Without those three, the answer is always "reproduce it again".
FAQ
Is a syntax error a bug?
A syntax error in source code normally never reaches production; the build catches it. If a SyntaxError does appear in production, the release pipeline is at fault — an unvalidated build or a CDN serving a stale file — and it should be treated as a defect.
Should console warnings go into the report?
Only the ones related to the symptom. A blank page plus a hydration warning belongs in the report; a deprecation notice from a library does not — it buries the real clue.
Is an "API 500" a front-end or back-end issue?
Whoever owns the fix depends on your process, but the report content is identical: request URL, status code, triggering action, timestamp, and whether it reproduces. First establish whether the front end sent bad parameters or the server genuinely failed.
Why does a developer keep saying "I can't reproduce it"?
Because what is missing is an environment, not a set of steps: permissions, data volume, browser version, timezone and feature flags all differ. An environment field in the report removes that round trip.
How do non-technical colleagues file useful reports?
Do not teach them DevTools. Install a browser extension, or embed a feedback entry point on the site, and let the tool collect the console and failed requests — that is the premise behind an instant feedback system.