“The site feels slow” is one of the most common complaints a web team hears, and one of the least helpful. Slow how? On which page? On which device?
Chrome DevTools, built into every copy of Chrome, can answer those questions precisely. You don’t need paid tools to find most performance problems. You need to know which panel to open and what to look for.
Press F12 (or Ctrl+Shift+I, or Cmd+Option+I on a Mac) and let’s get started.
Before you measure: set up a fair test
Your development laptop on office Wi-Fi is not what most users experience, especially in India where many visitors use mid-range Android phones on mobile data.
- Use an Incognito window so extensions don’t affect results.
- Throttle the network: in the Network panel, choose a preset like “Fast 4G” or “Slow 4G”.
- Throttle the CPU: in the Performance panel’s settings (gear icon), set CPU to 4× or 6× slowdown to simulate a mid-range phone.
- Disable cache (Network panel checkbox) when testing first-time visits.
- Test the pages that matter: home page, top landing pages, product or listing pages, and checkout.
Step 1: Get an overview with Lighthouse
Open the Lighthouse panel, select Performance (and Mobile), and click Analyze page load.
You’ll get a score and, more usefully, the Core Web Vitals and related metrics:
| Metric | What it measures | “Good” threshold |
|---|---|---|
| LCP – Largest Contentful Paint | When the main content (often a hero image or heading) appears | 2.5 s or less |
| INP – Interaction to Next Paint | How quickly the page responds to clicks, taps and typing | 200 ms or less |
| CLS – Cumulative Layout Shift | How much content jumps around while loading | 0.1 or less |
Google uses Core Web Vitals as part of its page experience signals. INP replaced First Input Delay (FID) as the responsiveness metric in March 2024.
Lighthouse is a lab test: one load, in controlled conditions. Real users vary. Check field data too, in Google Search Console’s Core Web Vitals report or PageSpeed Insights, which use data from real Chrome users.
Read Lighthouse’s Diagnostics and Opportunities lists. They often point straight at the biggest problems. Then use the other panels to dig in.
Step 2: The Network panel – what’s being downloaded?
Reload the page with the Network panel open.
Look at the summary bar at the bottom: number of requests, total transferred size, and load times. Several megabytes for a simple page is a red flag.
Sort by Size. The biggest files are usually:
- Images: uncompressed photos, PNGs used for photographs, images much larger than their display size
- JavaScript bundles: entire libraries loaded for one small feature
- Fonts: several weights and styles of web fonts
- Videos that autoplay
Sort by Time, or look at the Waterfall column. A long bar in the “Waiting for server response” (TTFB) phase means the server is slow, not the browser. Hover over a bar to see the breakdown.
Check the first request (the HTML document). If its TTFB is high (for example over about 600 ms), look at the back end: slow database queries, no caching, under-powered hosting, or a server far from your users.
Filter by Fetch/XHR to see API calls. Slow APIs, or many API calls made one after another (a “waterfall” of dependent requests), delay content.
Filter by third-party domains. Analytics, ads, chat widgets, social embeds and A/B testing scripts often add surprising weight.
Step 3: The Performance panel – what’s the browser doing?
Open Performance, click the reload-and-record button, and wait for the page to load.
You’ll see a timeline. Key things to look for:
Long tasks. Tasks over 50 ms are marked with red triangles. During a long task, the browser can’t respond to the user, which hurts INP and makes the page feel frozen. Click a long task, open the Bottom-Up or Call Tree tab, and see which scripts and functions took the time.
The LCP marker. In the timings track, find LCP and click it to see which element it was. Then ask: why did that element appear so late? Common reasons:
- the hero image is large or loaded late
- the image is lazy-loaded (it shouldn’t be, for above-the-fold content)
- render-blocking CSS or JavaScript delays everything
- the HTML itself arrived late (slow TTFB)
Layout shifts. The Layout Shifts track shows what moved. Click a shift to see the elements responsible.
To diagnose INP, record while you interact: click buttons, open menus, type in search boxes. Look for long tasks triggered by your interactions.
Step 4: Coverage – how much code is unused?
Open the Command Menu (Ctrl+Shift+P / Cmd+Shift+P), type Coverage, and start recording. Reload the page.
You’ll see each CSS and JavaScript file with the percentage of bytes that weren’t used. It’s common to find that 60–80% of a large bundle is unused on a given page. That’s a strong case for code splitting or removing libraries.
Common problems and fixes
Slow LCP
- Compress and resize images. Use modern formats like WebP or AVIF. Serve sizes matched to the screen with
srcset. - Don’t lazy-load the hero image. Use
loading="lazy"only for images below the fold. For the LCP image, addfetchpriority="high". - Preload critical resources, such as the hero image or main font, with
<link rel="preload">. - Reduce render-blocking resources. Inline critical CSS, defer non-critical CSS, and add
deferto scripts that don’t need to run before the page displays. - Improve server response. Cache pages, optimise database queries, use a CDN.
Poor INP
- Break up long tasks. Split heavy JavaScript work into smaller chunks, or move it off the main thread with Web Workers.
- Reduce JavaScript. Remove unused libraries, split bundles by page, and load third-party scripts only where needed.
- Avoid expensive work in event handlers. Give visual feedback immediately, then do the heavy work.
- Watch for large DOM sizes that make every update slow.
High CLS
- Set
widthandheight(or CSSaspect-ratio) on images and videos, so space is reserved before they load. - Reserve space for ads, embeds and banners.
- Avoid inserting content above existing content, like cookie banners or promos that push the page down. Overlay them instead.
- Use
font-display: swapcarefully, with fallback fonts of similar size to reduce text jumps.
Too many or too heavy third-party scripts
- Audit every tag: is it still needed? Who uses the data?
- Load non-essential scripts after the page is interactive.
- Self-host fonts and key libraries where licences allow.
Make it stick
Performance tends to decay as features and scripts are added. To prevent that:
- Set a performance budget: for example, page weight under 1.5 MB and LCP under 2.5 s on mobile.
- Run Lighthouse in CI (Lighthouse CI) and fail builds that break the budget.
- Monitor real-user data in Search Console or a real-user monitoring tool.
- Review new third-party scripts before they go live.
In short
Lighthouse tells you what is slow. The Network panel shows what is being downloaded and whether the server is slow. The Performance panel shows what the browser is busy doing. Coverage shows how much code is wasted.
Test under realistic conditions, fix the biggest problems first (usually images, JavaScript and server response time), and keep a budget so the site stays fast. Your users, and your search rankings, will notice.
Leave a Comment