Why your website loads slowly: what to check first

Why a site loads slowly cannot be determined by one overall score or owner’s feeling. The delay can occur before the first byte is received, when loading a large image, while JavaScript is running, or after the page is displayed, when the interface takes a long time to respond to a click.

Correct diagnostics begin with a reproducible scenario: a specific page, device, connection type, and user action. The loading path is then broken down into stages and the confirmed bottleneck is corrected. This way, the team doesn’t waste time accidentally enabling plugins or compromising stability for the sake of a nice number in one test.

1. Measure performance before drawing conclusions

Open the page in PageSpeed ​​Insights and check the mobile and desktop modes separately. The tool shows Lighthouse lab diagnostics and, if there is enough data, aggregated real user experiences from the Chrome UX Report. These data sets answer different questions, so their discrepancy does not mean an error.

For real-world experiences, Google uses three Core Web Vitals: LCP evaluates core content loading, INP evaluates post-interaction responsiveness, and CLS evaluates visual stability. Google’s official documentation lists LCP as less than 2.5 seconds, INP as less than 200 ms, and CLS as less than 0.1 as good guidelines. The assessment is based on the 75th percentile of visits, and not on the most successful test run.

Write down the initial values ​​​​and the address of the page being tested. Repeat the measurement after each significant change – otherwise it will be impossible to understand what really helped.

2. Check server response and processing

If the browser waits a long time for HTML, the images have not yet had time to cause a delay. Check server response times, slow request logs, database calls, external APIs, and background tasks. On WordPress, latency is often not caused by the platform itself, but by a specific combination of the theme, extensions, queries, and PHP configuration.

Test without cache bypass and with cache warmed up. The big difference shows that dynamic page generation requires a separate check. Don’t disable plugins on your production site at random: create a backup and use a test copy where you can eliminate components one by one.

A weak tariff is not always the root of the problem. Consider CPU, memory, disk, and slow queries before increasing resources. If the infrastructure has truly become a limitation, use the criteria from the material when to switch from hosting to VPS.

3. Find the heaviest element above the fold

On many pages, the LCP element becomes the main image, a large text block, or the banner of the first screen. In DevTools or Lighthouse, identify a specific element, then test when the browser becomes aware of it and how long it takes to load.

For the image, use a real size, a modern format, and reasonable compression. Don’t force your phone to download a photo that is several times wider than the screen. However, the main image of the first screen should not be lazily loaded: web.dev LCP recommendations advise making the LCP resource available in the HTML source and starting loading it as early as possible.

If the large element is text, check the web font. It should not hide the contents for long. Keep only the styles you need, set your display strategy, and make sure the format you’re using actually loads.

4. Review images, fonts, styles and scripts

The request waterfall shows not only the overall page size, but also the order of requests. Look for large files, duplicate libraries, styles for unused blocks, and scripts that run before the first display. One heavy file can be less harmful than dozens of small dependencies blocking each other.

The images below the first screen can be lazily loaded, but be sure to set their width and height. The CSS for the first screen should arrive on time and the optional JavaScript should not block the display. Minification reduces the transfer volume, but does not correct the architecture: a large unnecessary file remains unnecessary after minification.

Check fonts and icons separately. If a whole set is loaded for the sake of a few characters, it is better to reduce the composition. After the changes, open a page with a clean cache and make sure that nothing has disappeared or changed the order.

5. Check external services and user interactions

Chat, map, video, analytics, advertising pixels and review widgets often load additional scripts from other people’s domains. Their speed cannot be completely controlled, but you can change the moment of connection: some services are launched after consent, interaction, or the appearance of a block in the visible area.

For INP, not only the network request is important, but also the busyness of the main thread. Long JavaScript can delay the button response even after the page has visually loaded. Break down heavy tasks, reduce unnecessary handlers and test a real-life scenario – a menu, form, filter or cart.

Don’t blindly delete analytics. Make a list of third-party services, owners and purposes. If no one uses the tool or it duplicates another, this is an argument for removal. If your business needs it, set up later and secure loading.

6. Find layout shifts and late content

CLS occurs when already shown content moves unexpectedly. Typical reasons include images with no dimensions, banners appearing above text, late fonts, and blocks for which space has not been reserved in advance. The user may click the wrong button even though the page technically loaded quickly.

Specify media sizes, reserve space for widgets, and do not insert new elements above already visible content without user action. For fonts, choose a backup option with similar proportions. It is better to build animations on properties that do not recalculate the entire layout.

Test not only the main page. A service card, article, form, and client dashboard can use different templates and move differently. The material about checking a site before launch contains other conditions that are important to go through on real devices.

7. Check caching, the CDN and return visits

The browser cache speeds up revisit times, the server cache reduces HTML generation, and the CDN brings static files closer to the user. These levels solve different problems. Before connecting a new service, make sure that you understand which part of the chain it should speed up.

After updating the site, the cache must be cleared correctly, otherwise the visitor will see old styles or scripts. Version files, exclude personal pages and the trash can from the public cache, check response headers. For a multilingual or regional site, also consider individual page variations.

Compare the first open versus the second, and then test a page from the region where the audience is located. If the server is far away, static files may benefit from a CDN, but a slow database query will not be fixed by a CDN. The cause must be addressed at the appropriate level.

A practical order for performance checks

To understand why a site is loading slowly, move in a fixed order:

  1. Select one important page and script;
  2. Keep original lab and field data;
  3. Check HTML response time;
  4. Identify LCP element and blocking resources;
  5. Evaluate images, fonts and third-party scripts;
  6. Check INP and CLS on a real device;
  7. make one change and repeat the measurement.

Don’t promise yourself the required 100 points: Google explicitly states that a perfect result from a single tool does not guarantee high rankings, and the quality of the page is assessed more broadly. The goal is a stable experience for real visitors and the absence of confirmed bottlenecks.

If system diagnostics are needed, describe the task and page in the brief. We’ll review the server, template, resources, and user script, and then create a prioritized fix plan. After implementation, it is useful to enable regular monitoring – it is included in site support after launch.

If the site began to load more slowly after the update, send a link to the problem page and indicate when the delay appeared. If you need to figure out the reason and fix it, contact help from a website programmer.