A phone waits 4.0 seconds for the main content. Its load is split by owner: the server's 1.9 seconds runs 0.9 seconds over the hosting's 1.0 second share of a good 2.5 second load, so the host is the first call. Worked example.

Why is my website slow? Slow website or slow hosting, the theme or the code

If you run a business website that feels slow, you are probably about to pay a host, a theme seller or a developer to fix it. Three free readings tell you which of them owns the problem before you spend anything.

Slow website or slow hosting: how do you tell which?#

One slow page load splits into three parts you can read for free: server time points at the hosting, download size at the theme, and browser work at the code. Google's web.dev guide to optimizing LCP, read in November 2026, gives each part an ideal share of a good load. About 40% goes to the server's first byte and about 40% to downloading the main image or text. Then each of the two waits around them should take under 10%, by the same guide.

Show data table
Ideal shares of a good load: server 40%, load delay under 10%, download 40%, render delay under 10%. Source: Google web.dev, Optimize Largest Contentful Paint, read November 2026.
SegmentValue (% of a good load)Share
Server4040%
Load delay1010%
Download4040%
Render delay1010%

Server time and download each get about 40% of a good load, so the two waits around them should stay small.

Ideal shares of a good loadIdeal shares of a good load: server 40%, load delay under 10%, download 40%, render delay under 10%. Source: Google web.dev, Optimize Largest Contentful Paint, read November 2026.Google web.dev, Optimize Largest Contentful Paint, read November 2026

That split is useful because each slice belongs to someone different. The first slice is the host and the server setup. Next, the download slice is mostly the theme, its images and its fonts. Finally, render delay is the browser running code before it can paint. So the question "slow website or slow hosting" has a measured answer: whichever slice runs furthest past its share.

Google adds a caution in the same 2026 reading of that guide, and it matters. In its words, "these time breakdowns are guidelines, not strict rules". If your loads already finish inside 2.5 seconds, the proportions do not matter. But once a page is slow, they show you where to look.

Is your website slow for real people, or only in one test?#

Google's PageSpeed Insights documentation, read in November 2026, describes two kinds of result: field data from real Chrome users over the last 28 days, and one Lighthouse lab run. Lighthouse is Google's automated test that loads your page once on a simulated phone. Meanwhile, the field data comes from the Chrome UX Report, a public record of what real Chrome visitors experienced.

So trust the 28-day field data at the 75th percentile over one lab score, because the field data is what real people on real phones got. The 75th percentile means three in four visits were at least that fast. The PageSpeed Insights documentation, read in November 2026, notes that "Both data sources represent trailing 28-day periods". So a fix you make today takes weeks to show in full.

The two halves often disagree, and that is normal. Google's web.dev article on lab and field differences explains that a lab test uses fixed device and network settings. Real visitors bring their own. And the LCP guide is blunt about which to believe: if Lighthouse and the Chrome UX Report disagree, the field data "likely provides a more accurate picture". In practice, read the top half of the report first and treat the lab score as a clue, not a verdict.

Most sites still fall short on phones. HTTP Archive is a public crawl of millions of websites. Its 2025 Web Almanac reported that 48% of mobile websites passed all three Core Web Vitals, Google's user-experience measures, up from 32% in 2021.

Show data table
Mobile rose from 32% to 48% and desktop from 41% to 56%. Source: HTTP Archive, Web Almanac 2025 Performance.
Dimensionmobiledesktop
202132%41%
202231%44%
202336%48%
202444%55%
202548%56%

Fewer than half of mobile websites passed until 2025, when 48% did.

Websites with good Core Web VitalsMobile rose from 32% to 48% and desktop from 41% to 56%. Source: HTTP Archive, Web Almanac 2025 Performance.HTTP Archive, Web Almanac 2025 Performance

How much of the wait is the server, and when is the hosting to blame?#

Google's web.dev guidance, read in November 2026, calls a server response of 0.8 seconds or less good and anything over 1.8 seconds poor. That reading is TTFB, and PageSpeed Insights shows it in the field data as an experimental metric. Google's Lighthouse test is stricter in the lab. Its server response audit, read in November 2026, fails when the browser waits more than 600 ms (milliseconds) "for the server to respond to the main document request".

If time to first byte is over the poor line on several pages, the hosting is a suspect. And if a plain file with nothing of the site in it is slow too, the hosting or the server setup is the first call. Many sites sit in that zone. In HTTP Archive's 2025 Web Almanac, 44% of mobile websites had a good TTFB and 17% had a poor one.

Show data table
Mobile TTFB: 44% good, 40% needs improvement, 17% poor. Mobile LCP: 62% good, 25% needs improvement, 13% poor. Source: HTTP Archive, Web Almanac 2025 Performance.
DimensionTTFBLCP
Good44%62%
Needs improvement40%25%
Poor17%13%

Fewer than half of mobile websites had a good server response in 2025, against 62% with a good LCP.

Mobile field pass rates, 2025Mobile TTFB: 44% good, 40% needs improvement, 17% poor. Mobile LCP: 62% good, 25% needs improvement, 13% poor. Source: HTTP Archive, Web Almanac 2025 Performance.HTTP Archive, Web Almanac 2025 Performance

Then confirm it with the plain-file test. OVHcloud is a large web hosting company, and its hosting guide, read in November 2026, says to "Test the hosting with a file independent from your website". Upload one small file the site's code never touches, such as a tiny text page, and open it. If that file also crawls, the server or the network is slow. But if it opens instantly while your pages wait, the host is serving files fine and is being asked to do slow work by the site.

You can see the same number on your own machine. Chrome DevTools, the inspector built into Chrome, has a Network panel with a timing view. There, the row labelled Waiting (TTFB) is the time the browser sat waiting for the first byte. If you use Cloudflare, a service that sits in front of many sites, its slow-website guide, updated in October 2026, points you to origin response times. That checks your own server separately.

Still, pause before you blame the host. Google's web.dev guide to optimizing TTFB notes that a slow first byte can also come from redirects, missing server caching or slow database queries. Those belong to whoever built the site, even though they show up as server time.

How do you tell if the theme and its images are too heavy?#

HTTP Archive's 2025 crawl, read in November 2026, puts the median mobile home page at 911 KB of images and 632 KB of JavaScript, so compare your page against those first. Here KB means kilobytes, HTML is the page's text and structure, and CSS is its styling. Lighthouse lists your page's total weight under its diagnostics. When the server answers fast but the page still crawls, the bytes the theme ships are the next suspect. Those are mostly images, fonts and the theme's own scripts. So their weight by type shows which.

Show data table
HTML 22 KB, CSS 77 KB, fonts 122 KB, JavaScript 632 KB, images 911 KB. Source: HTTP Archive, Web Almanac 2025 Page Weight.
ItemValue
HTML22 KB
CSS77 KB
Fonts122 KB
JavaScript632 KB
Images911 KB

Images and JavaScript are most of the median mobile home page.

Median mobile home page, bytes by typeHTML 22 KB, CSS 77 KB, fonts 122 KB, JavaScript 632 KB, images 911 KB. Source: HTTP Archive, Web Almanac 2025 Page Weight.HTTP Archive, Web Almanac 2025 Page Weight

Then place your whole page on the curve. The same HTTP Archive 2025 Page Weight report put the median mobile page at 2,164 KB in total. In that 2025 report, the 75th percentile was 4,119 KB and the 90th was 8,337 KB. A page near the median is normal. But a page past the 90th percentile is heavier than nine in ten pages on the web, and the theme or its images are a likely cause.

Show data table
Mobile page weight runs from 516 KB at the 10th percentile to 8,337 KB at the 90th. Source: HTTP Archive, Web Almanac 2025 Page Weight.
ItemValue
10th percentile516 KB
25th percentile1,127 KB
Median2,164 KB
75th percentile4,119 KB
90th percentile8,337 KB

A page past 8,337 KB is heavier than nine in ten mobile pages.

Mobile page weight by percentileMobile page weight runs from 516 KB at the 10th percentile to 8,337 KB at the 90th. Source: HTTP Archive, Web Almanac 2025 Page Weight.HTTP Archive, Web Almanac 2025 Page Weight

Images are the usual culprit because a theme often ships large photos scaled down by the browser. Then fonts come next, especially when a theme loads several families and weights. If one type dwarfs the others, that type is the job to hand over. But Google's LCP guide adds one twist. A smaller main image only helps when the browser can paint it promptly. Otherwise the time just moves to the next slice.

How do you tell if scripts and code are the problem?#

A page whose bytes arrive quickly but still shows its main content late, or freezes after a tap, is waiting on code rather than on the server or the download. Long render delay and a poor INP (Interaction to Next Paint) reading point at code and third-party scripts, which run on the phone after everything has downloaded.

When the code, not the host, is the slow partGood TTFB plus long render delay or poor INP points at code and third-party scripts, not the host. Source: Google web.dev, Optimize LCP, INP and Load third-party JavaScript, read November 2026.

INP measures how fast the page reacts when someone taps or types. Google's web.dev INP guide, read in November 2026, calls 200 milliseconds or less good and anything over 500 milliseconds poor. PageSpeed Insights shows INP in the field data, so you can read it for your own site. A poor INP with a good TTFB is a strong sign the host is not the problem.

Third-party scripts are the most common code suspect. These are pieces of code loaded from other companies, such as chat widgets, analytics tags, ad tags and booking tools. Google's web.dev guide to third-party JavaScript puts it plainly. If your own code is fine and the site is still slow, "it's probably the fault of third-party scripts." Almost every site has them. In particular, HTTP Archive's 2025 Web Almanac found that around 90% to 92% of pages use at least one.

Render delay shows up in Chrome DevTools too. Google's LCP guide, read in November 2026, says the Performance panel shows a breakdown of the LCP parts in its insights. If render delay is the big slice, the browser had the image and was still busy running code. That points at the theme's scripts or the plugins and tags added on top, not at the host.

Which part of your own load is over its share?#

In this worked example a phone waits 4.0 seconds for the main content, and a 1.9 second server response alone is 0.9 seconds over the hosting's share of a 2.5 second load. Split the 2.5 second good line by Google's ideal shares and the part furthest over its seconds is the first one to fix.

The budget is simple arithmetic on Google's numbers, as read in November 2026. Take web.dev's 2.5 second good line for LCP and its ideal shares from the optimizing guide. That gives about 1.0 second for the server and 0.25 seconds for the load delay. Then the download gets 1.0 second and render delay 0.25 seconds.

Which part of your load is furthest over its share

Enter your own readings in seconds from PageSpeed Insights or Chrome DevTools; the defaults are the illustrative example below.

Your field readings, in seconds

an assumption, change it

Budgets from a 2.5 second LCP: server 1.0 s, load delay 0.25 s, download 1.0 s, render delay 0.25 s. The part furthest over is the first call: server time to the host, download to the theme, render delay to the code.

Largest overrun, ms: the first call

900

Server over its 1.0 s share, ms (the host)
900
Download over its 1.0 s share, ms (the theme)
400
Render delay over its 0.25 s share, ms (the code)
150
Load delay over its 0.25 s share, ms
50

Arithmetic from Google web.dev, Optimize LCP and Largest Contentful Paint, read November 2026. Modelled, not measured.

Now the illustrative numbers for this 2026 example. Say the server takes 1.9 seconds and the load delay is 0.3 seconds. Then the download takes 1.4 seconds and render delay is 0.4 seconds. Those add up to the 4.0 seconds the phone waited. Against the budget, the server is 0.9 seconds over and the download is 0.4 over. Render delay is 0.15 over and load delay only 0.05.

So the host is the first call in this 2026 example. Also, the 1.9 second server time is also past web.dev's 1.8 second poor line for TTFB, which settles it. Run the plain-file test before calling, though. If the plain file is fast, the slow server time comes from the site's own code. Then the call goes to the developer instead.

What can you check yourself before paying anyone?#

The first checks cost nothing: read the field data in PageSpeed Insights, test a plain file on the same hosting, and switch off third-party scripts one at a time on a copy. So the cheap checks narrow the cause to one part, and only the fix, not the diagnosis, usually needs paid help.

  1. Check 1

    Read the field data

    First, run your busiest page through PageSpeed Insights on mobile. Write down the field LCP, INP and TTFB with the date. That matters because the PageSpeed Insights documentation, read in November 2026, says the data covers the previous 28 days. Then run the same test on two or three other pages. A problem on every page points at the server or the theme. But a problem on one page points at that page's content.

  2. Check 2

    Test a plain file

    Second, do the plain-file test from OVHcloud's guide. Then open the same file from your phone on mobile data, so you know whether the slowness follows the network or the server.

  3. Check 3

    Test the scripts

    Third, test the scripts. Ask whoever manages the site for a staging copy, a private duplicate where changes do no harm. Then switch off one third-party tool at a time and test again. When one switch moves INP or render delay a lot, you have found your script. Google's third-party JavaScript guide suggests the same idea, checking what each script costs before deciding whether to keep it.

  4. Check 4

    Compare the page weight

    Finally, compare your page weight with HTTP Archive's figures from the earlier section. If your images alone are several times the median, compressing them is a fix you can often do yourself.

When is this three-part test the wrong tool?#

The split is the wrong tool when the site is erroring rather than slow, when only one person on one network sees it, or when there is no field data to read. Each of those needs a different check first. That means a status page, a second network, or a lab run repeated several times.

When the three-part test does not apply, and the first check instead. Source: Chrome UX Report methodology, November 2026

WhenCheck first
The site is erroring rather than slowThe host's status page and your error logs
Only one person on one network sees itA second network and device
There is no field data to readRun the lab test several times and read the middle result

If pages fail to load or show error messages, check your host's status page and your error logs first. Speed numbers on a broken page measure nothing useful. And if only you see the slowness, try a second network and device before you change anything. Your own office connection may be the slow part.

The Chrome UX Report also leaves some sites out. Chrome's methodology page, read in November 2026, says a page must be publicly discoverable and "sufficiently popular" to be included. It also lists Chrome on iOS among the excluded browsers, so iPhone visitors in Chrome are not counted. A small or new site may show no field data at all. In that case, run the lab test several times and look at the middle result, because one lab run can swing.

What should you send a host or a developer?#

Send the page address, the field TTFB and LCP readings with their date, the plain-file test result, and which part was furthest over its share. A handover with the readings and the suspect part turns a vague complaint into a job someone can scope and finish.

Five lines are enough, and they look like this.

  1. The page address

    First, the page address and whether the problem is on one page or all of them.

  2. The field readings

    Second, the field LCP, INP and TTFB from PageSpeed Insights, with the date you read them.

  3. The plain-file result

    Third, the plain-file result, fast or slow, on which network.

  4. The part furthest over

    Fourth, the part that ran furthest over its share, with the seconds.

  5. What changed recently

    Fifth, anything that changed recently, such as a new plugin, tag or host.

Send the server lines to the host and the rest to whoever built the site. A host that sees a fast plain file will point you back to the site. But a developer who sees a slow TTFB on a plain file, say the 1.9 seconds from the example, will point you back to the host. With the readings in hand, neither conversation goes in circles.

Where to go next#

If the readings point at the code or the theme, the guides below go deeper, and website speed optimization services exist for when you want someone to fix it. So pick the route that matches what you found.

When you want the fix done for you, our website speed optimization services start from the same readings. If the site has slowed slowly over months, ongoing maintenance and support keeps someone watching it. Either way, the free readings above are enough to name the slow part on your own.

Questions this post answers

Is it a slow website or slow hosting?
Check the server response and a plain file on the same hosting first, because together they settle it. If TTFB is over 1.8 seconds, Google's 2026 poor line on web.dev, and a plain file on the same hosting is also slow, it is the hosting. If the plain file is fast, the site itself is slow.
Why does PageSpeed Insights show two different sets of numbers?
The top half is field data from real Chrome visitors over the previous 28 days, per Google's 2026 documentation. The bottom half is one Lighthouse lab run on a simulated phone. When they disagree, trust the field data.
Will better hosting fix a slow website?
Only when the server is the slow part. If TTFB is good and the page is still slow, the theme's weight or the code is the cause, and a bigger hosting plan leaves that delay in place.

Keep reading