What's the difference between client-side and server-side errors?

Client-side errors happen in the game running on the player's device (a crash, exception, or rendering error), affecting the individual player and captured from the field with device context. Server-side errors happen on your backend (a failed query, a crashed service) and can affect everyone at once if a service goes down, captured from production. They differ in where they occur, who they affect (one device versus potentially everyone), and where you capture them.

Should I monitor both client-side and server-side errors?

For an online game, yes, they're different failure modes with different impacts. Client-side errors are distributed (many devices, each affecting one player) and captured from the field; server-side errors are centralized (your backend, potentially affecting everyone) and captured from production. Watching only one leaves you blind to half your failures, so capture both to have full visibility across your game's client and server.

Why can server-side errors be more severe than client-side ones?

Because of blast radius. A client-side error affects the individual player whose device errored, while a server-side error can affect everyone at once, if a backend service fails, all players relying on it are hit simultaneously. So a client error is one player's bad experience, but a server error can be a game-wide outage. That centralized potential impact is why server-side error monitoring and fast detection matter so much for online games, alongside client-side capture.

Client-Side vs Server-Side Errors

Quick answer: Client-side errors happen on the player's device; server-side errors happen on your backend. Client errors affect individual players; server errors can affect everyone at once. Online games need to capture both.

For online games, errors occur in two places, the client (player's device) and the server (your backend), and they differ in blast radius and how you capture them. Here's the comparison.

What Client-Side Errors Are

Client-side errors happen in the game running on the player's device, a crash, an exception, a rendering error on someone's phone or PC. They affect the individual player whose client errored, occur across your diverse device landscape, and are captured from the field, from the player's device, with device context.

Bugnet captures client-side crashes and errors from the field with device context, grouped by signature. Client-side errors scale with your player base and hardware diversity, each is one player's client failing, so they're about the breadth of devices your game runs on.

What Server-Side Errors Are

Server-side errors happen on your backend, where your game's online services run, a failed database query, a crashed service, an unhandled exception under load. Critically, a server-side error can affect everyone at once: if a backend service fails, all players relying on it are hit, unlike a client error affecting one device.

Bugnet captures server-side errors with context (request, inputs, load), so backend failures surface diagnosably. Server-side errors are about your infrastructure under production load, and their potential blast radius, your whole player base, makes them potentially more severe than any single client error.

Why You Capture Both

They differ in where they happen, who they affect, and how you capture them: client-side (player's device, individual impact, captured from the field) versus server-side (your backend, potentially everyone affected, captured from production). For an online game, watching only one leaves you blind to half your failures.

Bugnet captures both client crashes and server errors, giving you visibility across the whole system. So for online games, capture both: client-side errors for the device-side failures affecting individual players, and server-side errors for the backend failures that can take everyone down, since they're different problems requiring capture in different places.

Client-side errors happen on the player's device (individual impact, captured from the field); server-side errors happen on your backend (potentially everyone affected, captured from production). Online games need to capture both.