Users Pricing

blog

Home Blogs Find and Fix Slow Web Pages with Chrome DevTools – MindStick
Find and Fix Slow Web Pages with Chrome DevTools

Find and Fix Slow Web Pages with Chrome DevTools

Manasi Joshi 42 19 Nov 2026

“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:

MetricWhat it measures“Good” threshold
LCP – Largest Contentful PaintWhen the main content (often a hero image or heading) appears2.5 s or less
INP – Interaction to Next PaintHow quickly the page responds to clicks, taps and typing200 ms or less
CLS – Cumulative Layout ShiftHow much content jumps around while loading0.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.


Manasi Joshi

Data Analyst at BrowserStack

I am a Data Analyst at BrowserStack, with 7 years of experience in data analysis and business dashboards. I completed my B.Tech in Computer Science from Veermata Jijabai Technological Institute, Mumbai. Outside work I enjoy listening to music and playing the guitar.


Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md