Website Speed Test
Analyze your site's performance with Core Web Vitals metrics. Get a score out of 100 with LCP, CLS, TBT, resource breakdown and actionable insights.
Why Website Speed Directly Impacts SEO and Revenue
Google has used page experience as a ranking signal since 2021, with Core Web Vitals at the center. A 1-second delay in page load time can reduce conversions by 7%, and 53% of mobile users abandon a page that takes longer than 3 seconds to load.
What our speed test measures:
- LCP (Largest Contentful Paint): How fast the main content appears. Should be under 2.5s for a good user experience.
- CLS (Cumulative Layout Shift): How stable the layout is while loading. Unexpected jumps frustrate users and hurt rankings.
- TBT (Total Blocking Time): How much JavaScript is blocking interaction. High TBT makes the page feel frozen.
- TTFB (Time to First Byte): Your server's raw response speed — the foundation of all page performance.
- Resource breakdown: Exactly how much HTML, CSS, JavaScript, images, and fonts are loaded, so you know where to optimize first.
Understanding the performance numbers
Core Web Vitals are the first place to look. LCP under 2.5 s, CLS under 0.1, and INP under 200 ms are the Google "good" thresholds. Above those, you are losing rankings and conversions. The resource waterfall shows which asset dominates each metric.
- LCP > 4 s with a hero image: the image is not preloaded or is larger than needed — preload it with
fetchpriority="high". - High TBT and large JS bundle: main thread is starved; code-split and defer non-critical scripts.
- CLS spike mid-load: an ad slot, font swap, or late-loaded banner is pushing content — reserve space in CSS.
Common issues and fixes
- Render-blocking fonts: add
font-display: swapand preload WOFF2 files. - Third-party tags blocking main thread: move analytics and chat widgets to
deferor load after user interaction. - Unoptimized hero image: serve AVIF/WebP, size it to the viewport, and set explicit width/height.
- No CDN / slow TTFB: front the origin with a CDN and enable edge caching for HTML where possible.
- Huge bundled JS: audit with a bundle analyzer, remove unused deps, enable route-level code splitting.
What to do next
Fix LCP first — it is usually the highest-impact metric for both users and rankings. Then reduce JavaScript weight and only after that worry about CLS microfixes.
For continuous monitoring, FlashMon.app tracks changes automatically and alerts you the moment something breaks.
Monitor your site speed continuously
Get alerted the moment your site slows down — before your users notice.
Frequently Asked Questions
Core Web Vitals are Google's set of specific factors for measuring real-world user experience. Our performance score (0–100) is calculated from three metrics: LCP (Largest Contentful Paint, worth 33 points) measures loading performance; CLS (Cumulative Layout Shift, worth 33 points) measures visual stability; and TBT (Total Blocking Time, worth 34 points) approximates interactivity. A score of 90–100 is Excellent, 50–89 is Good, 25–49 Needs Improvement, and 0–24 is Poor. Google uses these metrics as direct ranking signals since 2021.
LCP (Largest Contentful Paint) measures how long it takes for the largest visible element in the viewport — typically a hero image, background image, or large text block — to fully render. Google considers LCP under 2.5 seconds as Good, 2.5–4 seconds as Needs Improvement, and above 4 seconds as Poor. Common causes of slow LCP: slow server response times, render-blocking CSS/JS, slow image loading, client-side rendering. Optimizations include using a CDN, compressing images, using Next.js or similar SSR frameworks, and preloading critical resources.
CLS (Cumulative Layout Shift) measures the total amount of unexpected layout shifts that occur during page loading — when elements visually jump as the page loads. A CLS under 0.1 is Good, 0.1–0.25 Needs Improvement, and above 0.25 is Poor. The most common causes: images without explicit width and height attributes, ads or embeds without reserved space, dynamically injected content, and web fonts causing FOIT/FOUT. Fix CLS by always setting dimensions on images and videos, reserving space for ads and embeds, and using font-display: optional or swap carefully.
TBT (Total Blocking Time) measures the total time between First Contentful Paint and Time to Interactive during which the main thread was blocked long enough to prevent input response. It's a lab proxy for First Input Delay (FID) and Interaction to Next Paint (INP). Under 200ms is Good, 200–600ms Needs Improvement, above 600ms is Poor. High TBT is almost always caused by large JavaScript bundles or third-party scripts blocking the main thread. Fix it by code-splitting, deferring non-critical scripts, removing unused JavaScript, and avoiding long-running tasks.
TTFB (Time to First Byte) is the time between the browser sending an HTTP request and receiving the first byte of the response. It reflects your server's raw response speed. A fast TTFB (under 200ms) is the foundation of a fast website — everything else happens after this. Slow TTFB is caused by slow database queries, server processing time, geographic distance from the server, or lack of caching. Fix it with server-side caching, database query optimization, edge CDN deployment, and HTTP/2 or HTTP/3.
Running a one-time speed test only shows you the performance at that specific moment. Page speed can vary significantly based on server load, third-party service availability, CDN caching, and changes to your site. FlashMon continuously monitors your site's uptime and response times from multiple regions worldwide, alerting you the moment performance degrades — before your users notice. This proactive approach means you can catch performance regressions introduced by deployments, plugin updates, or traffic spikes immediately.