This is where web performance was always meant to live

The TL:DR Embrace Web RUM now includes the deepest, most diagnostically useful Core Web Vitals alongside full Synthetic Monitoring, because understanding what your pages are capable of, and what your users are actually experiencing, are two different questions that need two different lines of sight. With this full launch of Embrace web capabilities, you can capture unrivaled depth and breadth of page performance and user experience, all within the only OpenTelemetry-native, user-focused observability platform for every screen.

But before I get too far into what’s new, I want to talk about why it matters. Because the problem we’re solving isn’t really about features. It’s about a conviction the web performance community has held for years: that observability is at its best when it gives an organization a shared language for what’s happening to the people on the other end of the screen. When teams across the organization can look at the data and have the same conversation about real users, that’s transformative. That’s what user-focused observability means, and it’s the through-line of everything we’re announcing this week, and everything we stand for as a company.

Every page load is a transaction between a person and an idea. When it’s fast and functional, something good happens. When it isn’t, something small but real is lost. That’s always been the conviction. Now we have the platform to act on it.

We’re kicking off the full launch of Web RUM and Synthetics, new depth in Core Web Vitals diagnostics, and a clear answer to a question practitioners have been asking for years: Why do I have to choose between the performance tools I love and the observability stack my organization runs on?

The short answer: you don’t! Not anymore.

Let me say something that might sound counterintuitive: Web RUM is not new. Legacy vendors have had it for years. If you’re an SRE at a company running a major APM platform, you probably already have something that calls itself web monitoring.

The question isn’t whether you have it. The question is whether it’s deep enough to actually be useful to you when something goes wrong.

There’s a wide chasm between “checkbox” RUM and practitioner-grade RUM. One tells you your LCP score. The other tells you which third-party script is blocking your main thread, on which device class, in which geography, during which exact user session, and then lets you drill to the stack trace without leaving the platform. These are not the same product… They share a name and almost nothing else.

The web performance ecosystem has fractured along this line for years:

• On one side, specialist tools that developers and performance engineers love, that go genuinely deep on Core Web Vitals diagnostics, and treat synthetic monitoring as a first-class product rather than an afterthought.
• On the other side, observability platforms with web features that check the box for SREs but that no frontend developer would choose voluntarily if they had options.

The fracture has real consequences. Frontend teams can’t get their performance data into the observability stack where incidents get triaged. SREs responding to production fires have no frontend context. They can see that something is wrong, but they can’t see the rendering-level detail that would tell them why. Engineers on both sides are making decisions from incomplete pictures. Mean time to resolution suffers, trust between teams suffers, and, most importantly, users and business outcomes suffer.

I’ve seen this pattern at hundreds of organizations over the years. It’s not a tooling problem, exactly. It’s a maturity problem. The industry optimized for breadth: more signals, more dashboards, more coverage, when what practitioners were actually missing was depth.

Depth AND breadth. That is a guiding principle at Embrace. Embrace built Mobile RUM with depth for practitioners, and continues to pioneer user-focused observability for all screens. It’s full-fidelity and uncompromising on what practitioners actually need to do their jobs, with the clear-eyed belief that open, composable, standardized systems based on OpenTelemetry are the future.

Launching Synthetic Monitoring alongside Web RUM in the Embrace platform is a true milestone, providing unparalleled visibility into what is affecting end-users. There is no other user-focused, OTel-native observability platform going to this level of performance for the entire frontend.

Here’s what that combination looks like now:

For web developers and performance engineers: we’ve built the deepest Core Web Vitals diagnostics on the market: LCP subpart attribution, long animation frame analysis, first- vs. third-party script attribution, real support for SPAs and React applications. It means synthetic monitoring that establishes baselines, catches regressions before they reach users, and enables competitive benchmarking against the pages you’re actually trying to beat. And it means both RUM and synthetics in one place, on one data model, so you never have to explain why your numbers don’t match across tools. (And mobile app developers already using Embrace have the granularity and performance depth to match).

My colleague Tammy Everts puts it perfectly: Synthetic teaches you about your pages; RUM teaches you about your users. You need both. Now you have both, together.

For SREs and backend reliability engineers: Embrace’s web data is OpenTelemetry-native. That’s not a footnote, it’s the whole point. Your web performance data can flow directly into Honeycomb, Chronosphere, Elastic, or wherever your observability stack lives. The workflow of going from from alert, to affected session, to stack trace happens inside one platform. No tool-switching mid-incident. No asking the frontend team to dig through a separate system and report back. Web performance becomes part of your observability practice, not a silo next to it.

For engineers building and troubleshooting with AI: The Embrace MCP server now supports web. You can ask Claude about your JavaScript exceptions, query your spans by latency, and investigate networking issues conversationally. It’s early and it’s already genuinely useful, and it points clearly at where the practitioner workflow is heading. OTel-standard data combined with AI assistance is something the industry is only beginning to figure out. We’re already building it.

For the users at the heart of it all: Most observability tools are built around one mode: reactive. Something’s on fire, find it, fix it, move on. That work matters and Embrace does it well. But there’s a whole other mode that the category has barely named: proactive. The mode where you’re not chasing alerts, you’re going looking for the users who are quietly struggling. The ones whose experience is degraded but not broken. The long tail on the distribution chart. Web RUM and Synthetics together give you both modes in one tool with the user always in view.

We’ve designed Embrace’s Web Performance Week to give you the depth you actually need, not a series of product demos dressed up as education. Here’s what’s coming:

Tuesday

Cliff Crocker and Tammy Everts go deep on synthetic monitoring: what it catches, why it’s effective, and some real-world use cases for competitive benchmarking and diagnosing performance regressions. If you’ve ever wondered when to trust your synthetic data and when to go looking for more, this is the session.

Wednesday

Andy Davies and Cliff Crocker walk through Embrace Web RUM live: full-fidelity session capture, Core Web Vitals, fully OTel-enabled for the clearest picture you can get of what your users are actually experiencing. Learn how capturing real user behavior helps you make your site faster and more performant.

Thursday

Tammy Everts hosts a LinkedIn AMA. If you don’t already know her, Tammy has spent more than two decades at the intersection of web performance, user experience, and business impact (and has literally written the book on it.) Bring your questions about performance, observability, business outcomes, or anything in between to the industry’s best. Drop in for the web performance questions, stay for Tammy’s no nonsense answers and great sense of humor.

Friday

A week wrap-up lands in your inbox: recordings, highlights, and key takeaways. Plus, hear from Embrace engineer Jared Freeze on a real-world browser OpenTelemetry problem and what it reveals about where web observability is heading.

Register once. Attend what works for your schedule. Everything else comes to you.

Metrics flatten people. A P75 score is a number. It’s not 30% of your users having a slow checkout. It’s not the long tail of sessions where someone gave up. The whole industry has trained itself to talk about systems in a vocabulary that hides the humans those systems exist to serve. So I keep coming back to this: Every millisecond of latency is a small tax on curiosity. Every sluggish checkout, every search result that takes a beat too long, every feed that hesitates. These are tiny failures of trust that compound quietly over time into lost engagement, lost revenue, and a slightly worse experience of being alive on the internet.

The people in this community genuinely give a damn. They’re the performance engineers, the SREs, and the frontend developers who argue about INP at conferences, who contribute to W3C working groups, and who show up at WebPerf Days and Performance.now(). I’ve been proud to be part of that community for the last 15 years. I’m more proud of it now than ever. And we’re bringing together the most curious of mobile teams, web teams, and reliability teams to see what’s possible.

What we’re launching this week isn’t just a set of features. It’s the argument, made in product form, that performance and observability belong together: that every engineer from frontend to backend deserves to see the user impact of their work, and that the web gets measurably better when they can.

Let’s build. The fourth is strong with this one.