
Some visits come from real users opening a page in a visible browser tab. Others come from reloads, back-forward navigations, hidden tabs, search crawlers, AI bots, preview tools, uptime monitors, automation frameworks or in-app browsers.
That does not automatically make those visits bad. Some are useful. Some are expected. Some are even business-critical.
But they can still add noise to performance analysis.
That is why RUMvision is adding a broader traffic noise classification layer. Not just to detect bots, but to better understand which data is representative of real users, and which data deserves extra context.
Not every RUM page view answers the same question
Real-user data is incredibly valuable, but it still needs context.
A page view can be valid, collected correctly and still not be the right data point for the question you are trying to answer.
Real-user data still needs filtering
When teams discuss website speed, they usually mean the experience of a real person visiting a page.
But a RUM dataset can contain more than that:
- a user navigating to a page for the first time
- a user returning through the back button
- a page loading in a background tab
- a crawler visiting a product page
- a preview tool generating a social sharing card
- an automated browser checking a URL
- an in-app browser opening a campaign page
These are all different situations.
If you mix them together without context, your analysis can become harder. You might miss actual improvements, overestimate regressions or spend time debugging data that does not represent normal user experience.
Human Visible Navigations
This is not a new problem in RUM.
Tim Vereecke wrote and even talked about this using the concept of Human Visible Navigations: focus on traffic that is human, visible and based on actual navigations. That framing is still very useful today. Especially when you are debugging Core Web Vitals, not every collected page view should carry the same weight.
The idea is simple:
- Human: exclude bots, synthetic tests and automation when analyzing real users
- Visible: exclude pages that loaded in hidden or partially hidden browser states
- Navigations: understand whether the visit was a fresh navigation, reload or back-forward navigation
This helps teams get closer to the experience they actually care about.
Why traffic noise deserves its own layer
The modern web has become more diverse.
Search crawlers, AI bots, preview tools, automation frameworks, embedded browsers and monitoring tools all add their own flavor of traffic. Some of this traffic should be excluded from Core Web Vitals analysis. Some of it should be analyzed separately. And some of it is useful context.
That is why we prefer the broader term traffic noise.
Calling everything a bot would be too blunt. An in-app browser is not a bot. A strange viewport is not a bot. A preview tool is not necessarily unwanted traffic.
But all of them can influence how you interpret RUM data.
Traditional bot protection and RUM classification are different
Most serious websites already have bot protection in place.
That is still important.
Blocking unwanted traffic
Hosting platforms, CDNs and cloud providers can apply managed bot rules, reputation checks, rate limiting and other protections before traffic reaches the website.
These layers are useful. They help reduce abuse, protect infrastructure and block traffic that clearly should not be there.
But edge-level bot protection and RUM-level traffic classification solve different problems.
Bot protection is mostly about deciding whether traffic should be allowed.
RUM classification is about understanding what kind of traffic produced measurements.
Classifying traffic that reaches the browser
Some traffic is perfectly acceptable from an infrastructure point of view, while still being less useful for real-user performance analysis.
For example, a visit might:
- use a real browser engine
- load the page successfully
- pass through regular infrastructure
- run the RUM script
- report performance data
- still behave unlike a normal visitor
That does not mean something failed.
It means there is value in adding a browser-side classification layer. The browser can expose signals that are not always available at the edge, such as runtime automation traces, viewport dimensions or in-app browser indicators.
Not every signal should become a block rule
Blocking is a hard decision.
Classification is more flexible.
If you block too aggressively, you may block useful crawlers, integrations, preview tools or legitimate users. If you classify too little, you may mix too much noise into your performance data.
RUMvision’s approach is to make this traffic visible and filterable.
Not every noisy session needs to be blocked. But it should be explainable.
What we mean by traffic noise
Traffic noise is not one thing.
It is a collection of signals that help explain whether a page view is likely to represent normal user behavior.
Known bots and crawlers
Some bots identify themselves clearly in the user agent string.
This can include:
- search engine crawlers
- AI crawlers
- SEO tools
- uptime monitors
- synthetic testing tools
- headless browsers
This kind of traffic is not always bad. A search engine crawler visiting your pages is expected. An AI crawler visiting documentation or blog content might be relevant for visibility. A monitoring tool might be part of your own setup.
But for Core Web Vitals analysis, these visits are usually not the same as a real person visiting the website.
That is why classifying them matters.
Runtime automation
Not all automation reveals itself through the user agent.
Some automated browsers leave traces in the browser runtime. This can include signals related to tools such as WebDriver, Playwright, Cypress or older headless browser setups.
Instead of exposing every raw browser detail as a permanent dashboard filter, RUMvision groups these signals into stable categories.
For example:
bot:runtime:high:webdriver
bot:runtime:high:playwright
bot:runtime:medium:preview_toolThis keeps the data useful without turning dashboards into a long list of technical internals.
In-app browsers and webviews
A visitor opening your website inside an app can have a different experience from someone opening it in Chrome, Safari, Edge or Firefox directly.
This can happen through apps such as:
- TikTok
- Google Search App
- Microsoft News
These visits are often real users. So we should not treat them as bots.
But they are still useful to classify, because in-app browsers can affect browser capabilities, viewport dimensions, navigation behavior and conversion paths.
A signal could look like this:
inapp:social:facebook:fban
inapp:chat:wechat:micromessenger
inapp:news:google-news:gnewsIn the dashboard, this can be shown as a cleaner label such as:
facebook
wechat
google-newsThat gives both readable reporting and detailed filtering.
Viewport and browser mismatches
Some traffic becomes noisy because the browser environment does not look like a typical user setup.
For example:
viewport:small:desktop
viewport:small:mobile
viewport:large:mobile
viewport:dimension:squareA strange viewport does not prove automation. Users resize windows. Devices differ. Accessibility setups exist. Embedded browsers can behave differently.
But when analyzing field data, viewport mismatches can explain unusual patterns.
That is why these signals should not automatically be treated as high-confidence bots. They are better handled as traffic noise with a lower confidence level, unless the dimensions are clearly invalid.
Different questions need different filters
There is no single perfect filter for all RUM analysis.
The right filter depends on the question.
Core Web Vitals analysis
When debugging Core Web Vitals, you usually want to focus on representative user experiences.
That often means filtering toward traffic that is:
- human
- visible
- based on relevant navigation types
- not high-confidence bot or automation traffic
This gives teams a cleaner view of what real visitors are experiencing.
For example, if LCP gets worse on a product page, you do not want to immediately chase a regression that was actually caused by a crawler, preview tool or synthetic environment.
For Core Web Vitals, high-confidence traffic noise should usually be excluded or at least separated by default.
Traffic noise analysis
For traffic noise analysis, the opposite is true.
You do not want to hide bots, crawlers, preview tools or automation. You want to inspect them.
A traffic noise dashboard can answer questions such as:
- which pages are visited by known bots?
- which AI crawlers are showing up?
- which pages are requested by preview tools?
- is automation traffic concentrated on checkout, login or search pages?
- are strange viewport patterns limited to specific templates?
- which in-app browsers are common for this site?
This makes traffic noise useful in its own right.
It is not just something to remove from performance reports. It is a separate layer of insight.
SEO, AI and crawler visibility
Crawler traffic is especially interesting because it is not always unwanted.
Search engines, AI systems and preview tools can all influence how your content is discovered, indexed, summarized or shared.
For SEO and content teams, it can be useful to know:
- which crawlers visit which pages
- whether AI bots reach commercial or informational content
- whether important templates are visited often
- whether crawl behavior changes after a release
- whether certain URL groups attract unusual non-human traffic
In that context, traffic noise is not just pollution.
It becomes visibility.
How RUMvision makes traffic noise visible
RUMvision already collects real-user performance data at page level.
Traffic noise classification adds another layer to that same dataset.
Noise levels
Instead of turning traffic noise into a simple yes-or-no field, RUMvision uses a noise_level.
Possible values are:
none
low
medium
highThis allows more flexible filtering.
For example:
noise_level = none
noise_level != high
noise_level = highThat means different teams can choose the view that fits their question.
A developer debugging Core Web Vitals might exclude high noise. An SEO specialist might inspect high-noise crawler traffic. A consultant might compare both.
Stable traffic signals
RUMvision also uses stable traffic signals.
These are designed to be filterable, groupable and readable in dashboards.
Examples:
bot:known:high:googlebot
bot:runtime:high:webdriver
viewport:small:desktop
inapp:social:facebook:fbanThe goal is to avoid vague labels.
Instead of just saying “bot”, we can show whether traffic was classified because of a known crawler, runtime automation, an in-app browser or a viewport mismatch.
That makes analysis easier.
Debug context
Sometimes you need more detail.
That is where debug context can help. For example:
ua:googlebot-image
runtime:navigator.webdriver
runtime:window.__pwInitScriptsThese details can explain why a session received a certain classification.
The distinction is important:
- traffic signals are stable dashboard filters
- debug matches explain what was detected
This keeps dashboards clean while still allowing deeper investigation when needed.
Page-level analysis
The page dimension is where this becomes especially useful.
Knowing that a bot exists is interesting. Knowing which pages it visits is much more useful.
Because traffic noise is connected to RUMvision’s existing page-level reporting, teams can analyze it by:
- URL
- page group
- template
- device type
- browser
- country
- in-app browser
- noise level
- traffic signal
This makes traffic noise analysis feel like a natural extension of Core Web Vitals monitoring.
You can use the same type of dashboard logic, but answer a different question.
Not only:
How fast was this page for users?
But also:
What kind of traffic is reaching this page?
Why we classify instead of simply removing
It may be tempting to remove all noisy traffic from the dataset.
But that would throw away useful information.
Cleaner defaults
For performance analysis, clean defaults are important.
Most teams do not want high-confidence bot traffic mixed into their main Core Web Vitals reporting. They want dashboards that reflect real users as closely as possible.
Traffic noise classification helps with that.
It allows RUMvision to offer better filtering without pretending that every noisy session is the same.
More useful investigations
At the same time, noisy traffic can explain strange patterns.
A sudden shift in CLS, LCP or page views might be easier to understand when you can see that the affected pages were also visited by bots, preview tools or automation.
This can prevent teams from chasing the wrong issue.
For example, a spike that appears around a deploy might look like a performance regression. But if the same timeframe also contains unusual automated traffic, the investigation becomes very different.
More visibility for business teams
Traffic noise is not only technical.
Marketing, SEO, content and e-commerce teams may also care about it.
For example:
- AI crawlers visiting product content
- preview tools hitting campaign pages
- social in-app browsers opening landing pages
- automation traffic touching checkout flows
- strange viewport traffic affecting certain templates
This is why classifying traffic is more useful than blindly removing it.
Different teams can use the same data in different ways.
Closing words
Real-user data remains one of the best ways to understand website performance.
But real-user datasets still need context.
The modern web is visited by humans, crawlers, AI bots, monitoring tools, preview services, automation frameworks and embedded browsers. Some of that traffic belongs in Core Web Vitals analysis. Some of it should be filtered out. Some of it deserves its own dashboard.
Cleaner performance data
For Core Web Vitals, traffic noise classification helps teams focus on the visitors that matter most.
That means fewer distractions, fewer misleading spikes and better investigations.
More visibility into modern traffic
At the same time, traffic noise itself can be valuable.
Knowing which bots, crawlers, tools and in-app browsers visit your website gives teams a better understanding of how their pages are accessed beyond regular human browsing.
That is why RUMvision is treating traffic noise as an additional RUM layer.
Not as a replacement for bot protection.
But as a way to make modern website traffic more understandable, more filterable and more useful.

