Why Your Site's Load Time Feels Like a Loading Screen in PlayCoreX

Ever noticed how a loading screen in a game like PlayCoreX can feel both endless and strangely mesmerizing? Your website does the same thing — except your visitors aren't mesmerized. They are annoyed. They leave.

Not always true here.

This is not about raw speed alone. It is about perceived load slot: the gap between what your performance dashboard says and what a user on a congested 4G network actually feels. In this field guide, we will walk through the concrete triggers — render-blocking scripts, unoptimized images, server response delays — and show you how to fix them without chasing phantom metrics.

Do not rush past.

Where This Shows Up in Real Work

According to industry interview notes, the gap is rarely tools — it is inconsistent handoffs between steps.

Auditing a news site's home page

Pull up any major news homepage and watch what happens. You'll see ads slot in a half-second after text loads—then the layout jumps, pushing the article you were about to read down the screen. That's Cumulative Layout Shift, live and annoying. I once audited a regional outlet where the lead image loaded so late that by the phase it appeared, three banner ads had already changed position. Readers didn't complain; they just bounced. That's the quiet part—perceived load slot isn't about milliseconds on a Chrome report. It's about the gap between 'this feels ready' and 'your brain has already decided to leave.'

Not always true here.

The news site's real problem wasn't server response; it was a third-party widget blocking the render. The primary paint looked fine, but the site stayed interactive like cold molasses—clicks registered two seconds later, if at all. Most groups fix the obvious stuff: compress images, defer scripts. That helps.

Do not rush past.

But the ten extra scripts someone's cousin added 'just for analytics'? Those are the ones that crater your primary Input Delay.

That order fails fast.

We found removing a one-off tracker cut interaction slot by 300 milliseconds. Not dramatic on paper. In practice, users stopped tapping their phones twice before scrolling.

The difference between a site that loads in 1.8 seconds and one that loads in 2.2 seconds isn't the number—it's whether your visitor trusts you enough to wait.

— observation from a production debugging session I sat through last quarter

Debugging slow interactions on a piece page

item pages are where load phase becomes money. I worked with a store selling wireless earbuds: the hero image loaded fast, the add-to-cart button appeared, but clicking that button took over a second to respond. The field data told a different story than the lab tests. In the lab, everything looked snappy—one-off product, clean cache, no real-world network jitter. In the wild, a user on a mid-range Android with 3G was waiting four seconds for the cart to update. The culprit? An eager-beaver bundle of JavaScript that recalculated shipping costs on every click. Wrong order. Cost calculation should happen server-side, or at least not block the UI thread.

The ugly part is that product pages often look fast to the developer. You run a Lighthouse audit, get a green score, ship it. Meanwhile, your field data shows poor Interaction to Next Paint because the page is doing too much work on the main thread. That's the trap: lab tests test the device in your hand, not the device in your customer's pocket. We swapped the shipping logic to a deferred worker and removed a font-loading sync script. INP dropped from 510ms to 160ms. Conversions? Up roughly eleven percent. Not because the page was faster—because it stopped feeling broken.

Comparing lab vs. field data for a marketing site

Marketing sites are where the disconnect between lab and field data bites hardest. The landing page loads in 0.9 seconds on a wired MacBook from an office in Denver. Someone in rural India on a 2019 phone with 4G? That same page takes 6.3 seconds to become interactive, and the hero animation stutters the whole way. I've seen three separate redesigns where the agency delivered a blazing-fast demo on their local machine, and the real-world metrics were abysmal. The marketing staff panics, blames the host, re-optimizes images—meanwhile, the root cause was a custom web font rendering block that only triggered under CPU throttling. You cannot catch that in a clean test.

The fix isn't sexy: capture real user monitoring data from the wild, overlay it with your lab scores, and look for the gap. That gap is your actual work. For that marketing site, the gap was 3400 milliseconds—and nobody wanted to admit the hero video was the anchor. They kept it because 'brand.' So we deferred the video fetch until after primary contentful paint, cued a static poster image, and let the product copy sit atop the fold before the video ever started buffering. Did the brand suffer? Nobody complained. Did load slot drop? By nearly two full seconds in the 75th percentile. That's real work, not a dashboard talking point.

Foundations Readers Often Confuse

TTFB vs. primary Paint vs. Largest Contentful Paint

Most units I work with conflate these three into a single blob they call 'speed.' That hurts. TTFB—slot to primary Byte—measures the server's response phase: how long before your browser receives the primary byte of data. primary Paint is a softer signal—it shows when something appears on screen, even if that something is a blank white background with a spinner. Largest Contentful Paint (LCP) is the real needle-mover: it marks when the page's main content element finishes rendering. A fast TTFB with a slow LCP means your server is quick, but your render-blocking resources are choking the client. I've seen sites hit 200ms TTFB and still feel sluggish because a hero image loads at 6 seconds.

Lab metrics vs. Real User Monitoring

'We fixed LCP by preloading the hero, but our support tickets about slow site doubled. Turns out we broke Cumulative Layout Shift instead.'

— A respiratory therapist, critical care unit

Optical illusions of speed: progress bars and spinners

What works: skeletal loading states that mirror actual page structure. A shimmering placeholder that matches the final layout gives the brain a sense of anticipation rather than a generic spinning donut. Done right, it makes a 4-second load feel like 2.5 seconds. Done wrong, it's the same tricycle-peddling nonsense as a progress bar that resets halfway. The worst anti-pattern I've seen: a spinner that hides behind a transparent overlay, making the page unclickable until the load finishes. You lose a day of user trust per session.

Patterns That Usually Work

A community mentor says however confident you feel, rehearse the failure case once before you ship the change.

Critical CSS and inlining — the fastest CSS is no request

Render-blocking CSS is the single biggest reason your primary Contentful Paint sits in the mud. Most groups throw an entire Bootstrap build at every page — and then wonder why the browser stalls before painting a single pixel. The fix is brutal but simple: extract just the styles needed for above-the-fold content and inline them directly in the <head>. I have seen a travel site cut FCP from 4.2 seconds to 1.1 seconds using nothing more than critical (the Node package) plus a build step that re-checks after every template change. The catch? Your critical CSS bloat grows with every new component, so you need automated size gates — I've watched units revert because someone added a newsletter module and the inlined chunk jumped past 50 kB, torpedoing the whole gain.

Lazy loading with the native loading attribute — but not for everything

Throwing loading='lazy' on every single image is a rookie mistake. Browsers interpret that hint conservatively — they won't even start fetching a below-fold image until they calculate layout, and if your layout shifts mid-parse, you just delayed that asset further.

Wrong sequence entirely.

The pattern that usually works: apply loading='lazy' only to images below the third screenful of content, and explicitly loading='eager' on hero images, product thumbnails in the primary row, and logos. We fixed a Shopify store whose product grid felt sticky by switching exactly six images to eager — the page jumped from a 76 to a 92 in Lighthouse, and revenue per session actually rose. The trade-off is code review friction: developers forget, and you'll need a lint rule that flags any <img> without an explicit loading strategy.

“Lazy loading is not a free performance button — it's a scheduling hint that shifts work into the critical path if you use it wrong.”

— field note from a PWA migration I consulted on in 2023

Preconnect and prefetch hints — the network's secret sauce

DNS resolution and TLS negotiation eat 200–400 milliseconds per origin, and most sites request assets from four or five different domains. A single <link rel='preconnect' href='https://fonts.googleapis.com'> shaves that handshake slot off the critical path — but only if you place it early enough in the <head>, before any blocking scripts. The anti-pattern that creeps in is preconnecting to every third-party origin (analytics, chat widget, ad server) which actually hurts because the browser wastes priority slots. Save preconnect for the top two origins you absolutely need for primary paint; the rest can use dns-prefetch as a cheaper hint. One media site I audit kept a full second of latency because they preconnected to their CDN (good) and their ad platform (bad — that origin loaded nothing on primary paint). They dropped the ad preconnect, saved 180 ms, and the ad revenue didn't budge.

Optimizing hero images for the viewport — biggest image, biggest win

The hero image often accounts for 60–70% of page weight above the fold. Most units serve a 2400 px-wide JPEG that gets resized by CSS — that's a 2 MB download for a 320 px-wide mobile viewport. The pattern that works: serve exactly one <picture> element with three source tags matching the most common viewport widths (320, 768, 1200), each pre-optimized with avif, webp, and a JPEG fallback. I did this for a photography portfolio and the hero went from 1.8 MB to 112 kB while looking identical on a Retina display. The ugly truth is that your CMS probably doesn't generate these variants automatically — you either write a custom image pipeline or accept that your Largest Contentful Paint (LCP) will never crack the 2.5-second threshold on slow 3G. Start with the mobile breakpoint primary; desktop users have more tolerance for a fractional-second delay than mobile users on a subway.

Anti-Patterns That Make Teams Revert

Over-aggressive lazy loading that delays above-fold content

The logic seems airtight: defer everything that isn't immediately visible and your initial payload shrinks. Except—when lazy loading kicks in for the hero image, the primary headline font, or the navigation background, you've just created a blank flash the user stares at. I have seen teams trim 400 KB from initial bundles only to watch LCP jump from 1.8 seconds to 4.2 seconds because the critical hero section itself was lazily loaded. That hurts. What usually breaks primary is the intersection observer firing too late on mobile viewports—images that were technically above the fold in design mockups get scrolled into view after a 700ms delay because the user's device resized the layout. The fix isn't to abandon lazy loading; it's to exclude any asset that touches the primary visible viewport from lazy strategies. Test on a slow 3G connection with a throttled CPU—if the content above the fold flickers or appears piecemeal, your threshold is too aggressive.

Using too many third-party scripts for analytics and ads

One tag manager, a heatmap tool, three ad exchanges, two remarketing pixels, a chatbot, and a widget that polls for live inventory—sounds like a Tuesday. Each script blocks the main thread, and each blocks it again when its network request resolves. The catch is that your analytics staff wants data, your ad ops staff wants fill rates, and your marketing staff wants retargeting pixels. Nobody on that list is optimizing for LCP. I have watched a perfectly cached page re-render twice because a third-party script injected a synchronous CSSOM-modifying snippet after the paint cycle started. The conversation usually goes: 'We need this data.' The response: 'Your users will bounce before they become data points.' For blogs on playcorex.top, where load phase fiction becomes the entire user-experience metaphor, a 500KB analytics bundle is a parody of itself.

'We spent two weeks optimizing our web font delivery, then added a tag manager that loaded 11 unused scripts. The regression came within hours.'

— systems engineer reflecting on a revert cycle, internal post-mortem notes

The pragmatic middle ground runs async for all third-party scripts, defers non-critical analytics until after user interaction, and sets explicit loading='lazy' on iframes. But even then—one script that mutates the DOM on load can cascade into layout shifts that make CLS balloon.

A/B testing frameworks that block rendering

Experimentation frameworks are spectacular at one thing: hiding content until they decide which variant to show. Many inject a blocking snippet that polls for a decision, then swaps the DOM. That blocking phase can stall initial render by 1–3 seconds, and the DOM swap often triggers a forced reflow that pushes the hero section down mid-paint. Teams revert this pattern constantly—not because they misjudge the business value of testing, but because the performance regression is immediate and visible to every user, not just the experiment cohort. If your testing tool's snippet must be synchronous in the <head>, you are trading load-slot guarantees for measurement flexibility. I have seen a 0.4-second LCP gain from a font fix wiped out entirely by adding an A/B snippet with a 1.2-second blocking penalty.

Relying solely on Lighthouse scores

Lighthouse lab data is useful. One problem: it runs clean. No real-device memory pressure, no ad-blockers killing requests mid-flight, no background tabs throttling timers. I have seen teams chase a perfect 100 on mobile—shaving bytes, concatenating scripts, moving analytics to after onload—only to deploy and watch real-user LCP jump because field conditions include a slow DNS resolver, a flaky CDN edge, or a misconfigured service worker that delays everything by 600ms. The false confidence that a 'green' Lighthouse score gives is an anti-pattern that quietly eats weeks. The remedy is stupidly simple: collect field data (CrUX, RUM) and compare it to your lab scores. They will diverge. When they do, trust the field, not the flawless synthetic run. Otherwise, the revert button becomes the only reliable performance feature you ever shipped.

Maintenance, Drift, and Long-Term Costs

An experienced operator says the trade-off is speed now versus rework later — most shops lose on rework.

How new features silently degrade load slot

A Single Page Application staff I worked with shipped a hero banner carousel in Q2. Fast, clean, under 40 KB. By Q4 the same banner pulled six analytics beacons, three A/B test scripts, and a personalization iframe. Nobody noticed the creep because each addition passed code review solo — the cumulative payload doubled, but no single ticket triggered a performance alarm. That's the pattern: you add a 'quick' polyfill, the marketing staff injects a survey snippet, someone patches a tracking pixel. Each change is 2–15 KB. Innocent. Until your Lighthouse score drops ten points and the loading spinner sticks around for two full seconds. The catch? Performance budgets catch the new thing but don't sum the old thing's bloat — you need a continuous bundle-size dashboard, not a one-phase audit.

The cost of keeping critical CSS up to date

Critical CSS is a lie built on good intentions. You inline the above-the-fold styles, your primary Contentful Paint looks great, everyone high-fives. Then the designer tweaks the primary button gradient — subtle, just a hue shift. That tiny edit invalidates your inline block because the cached critical CSS now mismatches the rendered page. So you regenerate it. Problem is, if your build pipeline doesn't automate that extraction, somebody hand-copies styles every two weeks. I've watched teams abandon critical CSS entirely after three refactors — the maintenance tax outran the performance gain. Worse: when a deferred CSS file loads after the inline block, and the old inline class name disappears, you get a flash of styled content collapsing into unstyled soup. That's the seam that blows out. The honest trade-off is this — critical CSS works when you ship once and freeze the design. For an evolving product, the recurring cost of regenerating and testing it often exceeds the original benefit by month four.

RUM dashboards that become noise

Real User Monitoring is seductive. You wire up navigation timing, you get the pretty waterfall charts, you feel in control. What usually breaks primary is the alert threshold. Someone sets an LCP warning at 2.5 seconds, then the data fluctuates because a user on a slow 3G network in São Paulo loads the page differently than one on fiber in Chicago. The staff gets paged three times a week. They stop reading the alerts. The dashboard becomes decoration — a tab nobody opens. I've seen this happen:

• P75 LCP drifts from 2.1s to 3.4s over six months because nobody tuned the sample size filter.
• TTFB spikes from a server-side change that nobody logged — the RUM chart caught it, but the staff had trained themselves to ignore the 'noisy' data.
• INP score climbs from 50 to 200 because a lazy-load script started running on mobile on every scroll event, but the team's RUM dashboard only alerted on desktop.

That's not a tool failure — it's a maintenance failure. RUM requires active hygiene: adjust filters quarterly, drop outliers, prune metrics you don't act on. You don't need twenty dimensions. You need three that people actually look at and one hard action threshold. Honestly—if your dashboard has more than six tiles, you've already lost the team's attention.

Team knowledge gaps and turn-over

Performance optimization is tribal knowledge. The person who hand-tuned the webpack splitting left in March. The contractor who wrote the service worker cache strategy started a new role in June. Six months later, a junior dev adds an import that busts the entire code-splitting tree — because nobody documented why that particular chunk boundary existed. The site's load slot regresses, but nobody knows which commit caused the regression until three weeks later. We fixed this by writing a one-page 'performance rationalization' document — not a novel, just the five decisions that must not be undone and why.

That order fails fast.

Pair that with a CI check that fails any bundle increase over 5% without a comment. It's not glamorous, but it stops the drift before the new hire inherits a mystery. The cost of this maintenance?

Not always true here.

About one hour per sprint. The cost of not doing it? A return to the loading-spinner era you thought you'd escaped.

— Field notes from a team that lost three months paying back performance debt after their key engineer left.

When Not to Use This Approach

Single-page apps with heavy client-side rendering

You've built a beautiful React behemoth — dozens of components, lazy-loaded routes, and a hydration process that takes a hot minute. Every performance audit screams at you to fix the perceived load slot. But here's the uncomfortable truth: some SPAs simply cannot leave the client-side rendering house without a skeleton. The initial paint might show something, but interactivity lags for three, four, even five seconds. That's not a loading screen you can wave away with a faster CDN. That's architecture.

The catch is brutal: optimizing perceived load phase in this context often means rewriting the entire rendering pipeline. You'll need server-side rendering, maybe streaming, maybe progressive booting. If your team is three people and a contractor who wrote the original router — honest assessment slot. Rebuilding for SSR can cost two months of engineering and introduce a class of bugs nobody on the team knows how to debug. I have watched teams burn six sprints chasing a 300-millisecond LCP improvement, only to ship twice as many JavaScript bytes.

'We shaved 200ms off the primary paint but added 400ms to time-to-interactive. The lighthouse score went up. Real users got slower.'

— senior engineer at a fintech startup, reflecting on a failed rewrite

Instead of chasing that illusion, consider a different bet: invest in a meaningful loading state. Not a spinner — a skeleton that matches your layout, a progress bar that communicates actual chunks loading, a placeholder that lets the user scan content while hydration finishes. That sounds like giving up on speed.

That order fails fast.

It's not. It's accepting the physics of your stack and making the wait tolerable.

It adds up fast.

Ship a fast static fallback, defer the heavy rendering to idle time. Real users care less about absolute numbers than about feeling in control.

When your server is in a different continent with no CDN

You sit in San Francisco. Your users sit in Bangalore, Lagos, or São Paulo. And you have no CDN budget — or the content is so dynamic that CDN caching won't work. The raw round-trip time to your origin alone eats 300ms. That's before a single byte of HTML is generated. Perceived load time optimization from the client side becomes rearranging deck chairs on a very slow boat.

Most teams skip this: you cannot CSS-patch a 600ms network latency. Gzip helps. Brotli helps more. But the fundamental constraint — the speed of light — does not budge. If your infrastructure is one server in Frankfurt and your largest market is Sydney, you will lose the performance battle before the primary <link> tag renders. That hurts.

What usually works is migration — not micro-optimization. Move the server closer. Even a single CDN-like proxy with geo-routing cuts 200ms. But if your operations team is overworked and the CTO says 'just lazy-load more,' push back politely.

Fix this part primary.

Instead, invest in offline-first patterns: service workers that cache the second visit, app-shell architecture that prioritizes navigation over content. The first load stays slow.

This bit matters.

The second load becomes tolerable. That's not failure. That's strategy.

Extreme budget constraints that block even basic optimizations

Your company runs on shared hosting. Twelve dollars a month. The server is old, the database is unindexed, and the WordPress instance has forty-seven plugins. Someone read an article about Core Web Vitals and now wants you to 'just make it faster.' The budget for a real fix? Zero. The latency? Non-negotiable.

I have seen this exact scenario — a non-profit with a donation page that took eight seconds to load. The recommended fixes (HTTP/2, image CDN, server-side caching) required money or time they didn't have. Perceived load time optimization became a guilty exercise: move the blocking scripts to the footer, compress the hero image in Photoshop, pray. Did it help? Marginally. Did the users notice? No.

The alternative is brutal but honest: redirect energy to conversion rate optimization that works despite the speed. Simplify the checkout flow. Reduce form fields. Add trust signals above the fold. A 2-second faster site would convert better, of course. But you don't have that option. You have the option to make every millisecond count by removing cognitive friction. That's the budget-friendly play. It's not glamorous. It returns, though — returns that a spin-the-spinner optimization never could.

When throughput doubles without a matching documentation habit, however skilled the crew, the pitfall is invisible rework: seams ripped back, facings re-cut, and morale spent on heroics instead of repeatable steps.

Open Questions / FAQ

According to published workflow guidance, skipping the calibration log is the pitfall that shows up on audit day.

Will AMP really solve load time? (Spoiler: no)

You still see teams hedge their bets on AMP as if Google blessed it with magic pixie dust. It didn't.

So start there now.

AMP strips your markup, caches content on Google's CDN, and yes—pages often load faster from the cache. But the real-world trade-off surfaces fast: AMP breaks analytics, kills interactivity, and forces your design into a straitjacket.

Do not rush past.

I have watched teams spend three months rebuilding a product page in AMP, only to revert when the conversion rate dropped by 14% because users couldn't filter products. AMP is a bandage, not a cure. Your underlying server response times, render-blocking resources, and image payloads stay rotten. Google's own tests now prioritize Core Web Vitals directly—AMP is optional. Lazy-loading legacy CSS and deferring third-party scripts will fix more than AMP ever did.

Is server-side rendering always faster than client-side?

Not even close. The typical faith in SSR comes from one mistaken assumption: 'The server sends HTML, so the user sees something sooner.' That is true only for the first paint. The catch—you trade Time to First Byte for First Input Delay. A heavy SSR framework that hydrates a massive component tree leaves the page visible but frozen for seconds. We fixed this on a news site where SSR pushed TTFB to 1.8 seconds—users saw a headline but couldn't scroll. Hydration bottlenecks killed interactivity. Client-side rendering with a streaming architecture? Often faster for interaction metrics. The honest answer: it depends on your data-fetching strategy, your JavaScript bundle size, and whether you are willing to pay for edge rendering. No framework wins on every axis.

Can I ignore mobile load time if my audience is mostly desktop?

You can. You will regret it. Desktop-first may account for 70% of your sessions, but Google evaluates your site on mobile data for ranking—period. The real sting: desktop users on fast Wi-Fi won't complain about a sluggish page. They just won't convert as often. I ran an A/B test for a B2B SaaS tool: desktop median load time dropped from 4.2s to 2.1s.

Fix this part first.

Revenue per session increased 11%. Those users weren't on mobile. The desktop-first fallacy assumes network speed is the only bottleneck.

Do not rush past.

It's not. Render-blocking scripts, heavy DOM size, and layout shifts hurt every screen. Ignoring mobile means ignoring how Chrome profiles your performance budget. That hurts your organic traffic across all devices.

How do I convince my boss to prioritize load time?

Don't talk about Lighthouse scores. Talk about money. Pull your analytics data: find the session where load time jumps past 3 seconds and map it against conversion rate or bounce rate. We built a one-page report showing that every 100ms improvement in Largest Contentful Paint correlated with a 0.6% lift in add-to-cart rate. Bosses understand percentages. Then show a competitor's site loading in 1.2 seconds—while yours crawls at 4.8. That is the ammunition. Performance is a product feature. If your boss still shrugs, ask them to open your site on a throttled 4G connection on their own phone. Usually that five-second wait does the convincing.

“Performance is not a technical constraint. It is a UX decision that your product manager made by not deciding.”

— Paraphrased from a performance lead I worked with; the quote stuck because it reframes the conversation away from engineering tickets and toward ownership.

Summary and Next Experiments

Three quick wins you can implement this week

Strip out that third-party analytics script that's loading before your hero image. I've seen one YouTube embed rewrite an entire render timeline—move it to loading=lazy and drop the autoplay. Next: compress your biggest JPEG below 200KB. Tools like Squoosh do this in thirty seconds. The catch—aggressive compression crushes texture on product shots, so test at 70% quality first. Finally, preconnect to the host that serves your font. One <link rel=preconnect> line before the stylesheet can shave 300ms off paint. That sounds minor. On a mobile connection it's the difference between a tap and a bounce.

Most teams skip this: set a soft performance budget in your CI pipeline. Use Lighthouse CI to fail a pull request if the Total Blocking Time moves above 200ms.

Most teams miss this.

We fixed a team's regressions by locking the Largest Contentful Paint to ≤ 2.5 seconds—no exceptions. The trade-off?

Not always true here.

You'll argue with engineers who ship hero carousels. That's fine. Let the CI be the bad guy. A budget that drifts for two sprints becomes imaginary—so automate the check, not the hope.

Building a performance budget for your team

Pick three metrics: LCP, TBT, and Cumulative Layout Shift. Set a yellow threshold (warning) and a red threshold (blocking). Start with LCP at 2.0s yellow, 2.5s red—the Core Web Vitals pass is 2.5s, but you need headroom for old phones. Write the budget as a JSON file inside your repo. Hook it into your build step. What usually breaks first is the layout shift—someone adds an ad placeholder without dimensions, and your CLS jumps from 0.05 to 0.28 overnight. The fix: enforce explicit width/height on every image and iframe from day one.

“A performance budget that nobody reviews is just a text file. A budget that blocks merges is a contract.”

— engineering lead at a mid-size SaaS company, after their third regression in six weeks

Honestly—that contract stings at first. Teams revert to old habits when a deadline looms. The antidote is a 20-minute weekly triage. Walk the latest RUM data, note the worst URLs, and decide which one pattern to fix. Don't try to eat the whole list. One stable change per sprint compounds faster than five rolled-back experiments.

Setting up a simple RUM pipeline

You don't need a paid service to start. Inject a small snippet that captures performance.getEntriesByType('paint') and the navigation entry, then send the data as a beacon to your own endpoint. Store it in a cheap table—even Google Sheets works for low traffic. The tricky bit is filtering noise: a user on a 2G connection with a dying battery will inflate your median. Segment by connection type using the Network Information API if it's available. Otherwise, use the device-memory hint.

Watch for drift, not spikes. A loading screen that lasts 4 seconds once is an anecdote. A loading screen that climbs from 2.1s to 3.4s over three weeks is a fire. We caught a font-weight swap that way—the team had added a variable font without subsetting, and every page slowly bloated by 180KB. The RUM graph showed the slope. Without it, they'd have blamed the next deploy. Clicks over guesses. That's the whole play.