---
title: "Find and Fix Slow Web Pages with Chrome DevTools"  
description: "A practical guide to diagnosing slow websites with Chrome DevTools. Use Lighthouse, the Network panel, the Performance panel and Coverage to find heav"  
author: "Manasi Joshi"  
published: 2026-11-19  
canonical: https://www.mindstick.com/blog/307135/find-and-fix-slow-web-pages-with-chrome-devtools  
category: "web development"  
tags: ["chrome devtools slow page", "devtools", "web development", "Website Performance", "step by step tutorial"]  
reading_time: 7 minutes  

---

# Find and Fix Slow Web Pages with Chrome DevTools

“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, add `fetchpriority="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 `defer` to 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** **`width`** **and** **`height`** (or CSS `aspect-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: swap`** carefully, 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.

---

Original Source: https://www.mindstick.com/blog/307135/find-and-fix-slow-web-pages-with-chrome-devtools

Copyright © MindStick Software Pvt. Ltd. This Markdown version is provided for developers, AI systems, and offline reading.
