Beyond the golden signals: Observability built around the end-user

Most teams try to close the gap with the tools they already have: a crash reporter (e.g., Crashlytics, Sentry) or a backend APM platform (e.g., Datadog, New Relic) stretched onto the client. These are error-focused tools. They ask one question, “What broke?”

That question produces a stack trace, maybe some breadcrumbs, and an engineer trying to reproduce the issue locally from incomplete context. It misses the things that determine whether a user finishes their journey:

• No session context. You see what crashed, not what the user was doing. What screens did they visit? What taps came before? What was the device state?
• Sampling. Many tools capture a slice of sessions. For most users, you have no data at all.
• Event isolation. A network failure, a UI freeze, and a crash are stored as three unrelated events instead of one connected timeline.
• No visibility into degradation. If the app is slow, janky, or burns battery without crashing, error-focused tools are blind to it.
• Manual reconstruction. Engineers stitch the story together by hand across logs, traces, and dashboards in different tools.

Crash reporters tell you something broke. Backend APM tells you the server was fine. Neither tells you what the user actually experienced.

User-focused observability inverts the question. Instead of, “What broke?”, it asks, “What did the user experience?” The fundamental unit is no longer the error event. It is the user session.

A session captures everything that happened during a single use of the app: every screen, every tap, every network call, every lifecycle event, every device state change, every span, every log. All of it is organized into a timeline that tells the complete story of what the user saw and did.

That changes the workflow:

1. An alert fires, a user reports a bug, or you proactively search for degradation.
2. The engineer opens the user’s session timeline.
3. They see the full sequence — what the user did, what the app did, what the device was doing — in the order it happened.
4. The root cause is visible in context. No guessing, no reproduction needed.

Three things make this possible:

• First, 100% unsampled capture — every session, every user, no blind spots.
• Second, correlated signals on a single timeline — network failures, UI freezes, crashes, ANRs, low-memory warnings, all in the order they occurred.
• Third, a session-first data model built on OpenTelemetry, where sessions are root-level spans, traces and logs hang off them, and crashes are captured inside the session rather than as isolated events.

Once the session is the unit of analysis, things that were invisible become first-class: slow launches, UI hangs, abandoned flows, thermal throttling, and the long tail of “didn’t crash but didn’t work.” User Journeys turn login, search, and checkout into measurable flows with completion rates and abandonment points — the metrics the business actually cares about.

What good looks like

A team operating with user-focused observability and a strategic posture can answer questions the golden signals will never reach:

• Which user segments are abandoning checkout, and on which device classes?
• Did the new app version regress startup time for users on Android 12?
• How many sessions had a network timeout followed by a rage-tap and a backgrounding?
• When orders per minute dropped at 14:07, which client-side change correlates with it?
• What is the revenue cost of the slow product detail page we shipped last sprint?

None of those questions can be answered from the four golden signals alone. All of them can be answered when the session is the unit of analysis, capture is unsampled, frontend and backend telemetry are connected, and the team treats user experience as the metric of record.

The takeaway

The golden signals are not wrong. They are necessary, and they will keep being necessary, because backend services still need to be kept alive. They are simply incomplete. They watch the server. They cannot watch the user.

User-focused observability is the missing half: a session-first model that captures the full reality of what users experience on devices and networks the operator does not control, then ties that experience back to the business outcomes it drives. The golden signals tell you the service is up. User-focused observability tells you the user is succeeding. A mature observability strategy needs both, and the teams that pull ahead will be the ones who stop confusing the first for the second.