OpenTelemetry

Frontend observability that works

99.9% uptime doesn't mean 99.9% of users had a good experience. One slow checkout flow for iOS users in Germany costs thousands in lost revenue. See exactly what's breaking, for whom, and why.

New to the topic? Start with our frontend observability guide, then come back when you're ready to implement.

Monitoring tells you WHEN. Observability tells you WHY.

Traditional monitoring is like a check engine light. It tells you something is wrong ("High Error Rate"), but it doesn't tell you why it's happening or who is affected.

You need more than just red lights. You need to know that the regression is only happening to users on iOS 18 who have 3 items in their cart. That's the difference between guessing and fixing. Learn more about frontend observability.

Monitoring (The "What")
[ERROR] 14:02:05 - API Timeoutstatus: 500 Internal Server Errorpath: /api/checkoutregion: eu-west-1

The struggle: "Checkout is broken."
Okay, but why? Is it the DB? The payment gateway? A code bug? You spend 4 hours guessing.

Observability (The "Why")
Trace ID: 7a92b...span: checkout_payment_processerror: 3rd_party_timeout (Stripe)user_agent: Mobile Safari (iOS 18)

The fix: "Stripe is timing out for iOS 18 users."
You know exactly where to look. You escalate to the partner API or deploy a fallback in minutes.

Problems observability reveals

Issues invisible to traditional monitoring that cost real revenue.

Hidden
10%
"Shop the Look" Failing
1 in 10 users, specific device
Blocked
3.2s
Apple Pay Button Delay
SDK issue blocked checkout
Silent
800ms
Search Interaction Delay
Tablets only, killed engagement
Intermittent
iOS 18
Payment Gateway Failures
Version + provider combo

These issues affect small user segments but have outsized revenue impact. Traditional monitoring shows healthy averages whilst these problems silently cost thousands per month.

Production-ready observability in days, not months

We handle the complexity. You get a battle-tested pipeline that respects privacy, scales with traffic, and delivers insights from day one. New to observability?

01

See what users actually experience

Know which checkout flows are slow, which buttons feel unresponsive, and which errors block conversions - with full device, browser, and network context.

  • Core Web Vitals traced to specific resources
  • Failed API calls with full request details
  • JavaScript errors with user journey context
02

Follow requests end-to-end

Trace a single user action from browser click through your entire backend stack. See exactly where time is spent and where failures occur.

  • Frontend → API → database → response in one view
  • Find slow queries blocking user interactions
  • Identify which third-party scripts cause delays
03

Ask any question about your data

No pre-aggregated dashboards. Query by any combination: device + geography + cart value + feature flag + user segment. Find the needle in the haystack.

  • "Show slow checkouts for iOS users in France"
  • "Which browsers have high error rates?"
  • "Does LCP correlate with conversion rate?"
04

Production-ready from day one

We configure privacy controls, sampling strategies, and retention policies based on your requirements. GDPR-compliant and ready for EU customers.

  • PII automatically scrubbed from traces
  • Adaptive sampling to control costs
  • EU data residency available

⚡ Performance Impact

Our instrumentation is designed for production environments:

  • Minimal overhead - runs asynchronously
  • Non-blocking - never delays user interactions
  • Adaptive sampling - scales with traffic
Frontend observability trace showing user interactions and performance layers

Why OpenTelemetry-based observability?

Not all observability solutions are built for modern frontend challenges. Here's how different approaches compare.

OpenTelemetry-Based
Traditional APM
GA4 + Sentry
High-cardinality queries
✓ Query any dimension
~ Often pre-aggregated
~ GA4: Limited
Sentry: Good for errors
Frontend-to-backend traces
✓ Native support
~ Varies by vendor
✗ Separate systems
Instrumentation standard
✓ OpenTelemetry (vendor-neutral)
~ Often proprietary
~ Mix of standards
Unified data model
✓ Performance + errors + business context
~ Focused on technical metrics
✗ GA4: marketing
Sentry: errors only
Implementation approach
✓ We set up and configure
~ Self-service or consulting
✓ Quick self-service setup
Vendor lock-in
✓ None - switch backends freely
✗ Proprietary agents
~ Platform-dependent
AI-powered analysis
✓ Via backend (Honeycomb, Grafana Machine Learning)
✓ Built-in (Dynatrace Davis AI)
~ Limited to error grouping
Best for
Revenue-critical apps needing deep debugging
Backend-heavy architectures
Marketing analytics + basic errors

Simple integration, powerful insights

Works with React, Next.js, Vue, or any modern JavaScript framework. Here's what implementation looks like.

Next.js / React
// app/layout.tsx or _app.tsx
import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
import { getWebAutoInstrumentations } from '@opentelemetry/auto-instrumentations-web';
import { registerInstrumentations } from '@opentelemetry/instrumentation';

const provider = new WebTracerProvider();
provider.register();

registerInstrumentations({
  instrumentations: [
    getWebAutoInstrumentations({
      '@opentelemetry/instrumentation-fetch': {},
      '@opentelemetry/instrumentation-xml-http-request': {},
    }),
  ],
});

export default function App({ Component, pageProps }) {
  return <Component {...pageProps} />
}
Track Custom Events
// Track checkout flow performance
import { trace } from '@opentelemetry/api';

function CheckoutButton() {
  const handleCheckout = async () => {
    const tracer = trace.getTracer('checkout');
    const span = tracer.startSpan('checkout.initiated');

    span.setAttribute('cart.items', cartItems.length);
    span.setAttribute('cart.value', totalValue);
    span.setAttribute('user.segment', userSegment);

    try {
      await processPayment();
      span.setStatus({ code: SpanStatusCode.OK });
    } catch (error) {
      span.recordException(error);
      span.setStatus({ code: SpanStatusCode.ERROR });
    } finally {
      span.end();
    }
  };

  return <button onClick={handleCheckout}>Pay Now</button>;
}

That's it. You now see every checkout attempt with full context: which items, what value, which user segment, and whether it succeeded or failed. Query by any combination in your observability platform.

What the work delivers

Mobile INP fell from 413ms to 150ms, lifting the UX Score from 82 to 100.

Simyo

The share of mobile URLs passing Core Web Vitals rose from 25.8% to 93%.

Autoweek

INP work across flannels.com, sportsdirect.com and houseoffraser.co.uk, with the UX Score computed weekly from their own RUM data.

Frasers Group

Common Questions

Stop flying blind.
Start seeing the truth.

Let's talk about your frontend blind spots. We'll show you exactly which user experiences are costing you revenue and how to fix them.