The fastest way to fix a slow website is to identify which phase is slow before changing code. Reproduce the delay under known conditions, compare PageSpeed Insights field data with its Lighthouse lab run, inspect the main document request in Chrome DevTools, then follow the Network waterfall to the resource or script that blocks the visible page. Make one targeted change and repeat the same measurement.
A long wait before the first byte is a server, redirect, connection, caching, or application-latency problem. A page that receives its document quickly but becomes usable slowly has a different problem: large transfers, too many requests, render-blocking CSS, fonts, images, or JavaScript execution. Keeping those cases separate prevents random “optimizations” that improve a score without improving the user’s experience.
1. Reproduce the slowness under fixed conditions
Start with the exact URL that feels slow. Record the conditions instead of testing only once on your own desktop connection.
- Page: note the full URL, including query parameters and whether it is a home page, landing page, search result, or logged-in view.
- Device and browser: record mobile or desktop, operating system, browser version, and whether extensions are enabled.
- Network and location: note the approximate location and connection type when they are relevant to the report.
- Visit state: test a first (cold) visit and a repeat visit separately. A cached repeat visit can hide a slow uncached load.
- Comparison: test a page known to be faster on the same site, using the same device and network.
Keep these variables stable while you investigate. If the device, location, cache state, or URL changes between runs, a different result may reflect the test rather than your fix.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
2. Use PageSpeed Insights for field and lab evidence
Run the URL through PageSpeed Insights and read its two evidence streams separately.
Chrome UX Report (field data)
When available, field data describes what real Chrome users experienced for the page or origin. It is useful for discovering whether the reported problem occurs in the wild and under which device conditions. Data may be unavailable for an individual page; that absence does not prove the page is fast or slow.
Lighthouse (lab data)
The Lighthouse run is a controlled initial-load test that gives repeatable diagnostics for requests, transfer sizes, images, stylesheets, fonts, scripts, and other resources. It is not a complete record of every user session. In particular, lab measurements can miss post-load layout shifts and long JavaScript tasks that users still notice. Treat the lab as an investigation instrument, not a guarantee of a particular field result.
When the two views disagree, label the difference rather than averaging it away: field versus lab, cold versus repeat visit, mobile versus desktop, and main document versus later resources are different questions.
3. Check the initial document request in Chrome DevTools
- Open the affected page in Chrome.
- Open DevTools with F12 or Ctrl+Shift+I (Windows/Linux) or Cmd+Option+I (macOS).
- Select Network, enable Disable cache if you are testing a cold load, and reload the page. Use Preserve log when redirects make the request history disappear.
- Find the first document request, usually the row whose type is document and whose name is the page URL. Click it and open Timing.
Pay particular attention to time before the browser receives the first byte. A chain of redirects, connection setup, cache misses, or server-side application work can delay the document even when the rest of the page is small. Chrome’s Document request latency guidance uses 600 ms as a server-response recommendation and references 800 ms as a recommended TTFB threshold. These are Chrome guidance values, not universal pass/fail boundaries.
Interpret the timing phases
- Redirect: an unnecessary HTTP-to-HTTPS, host, or trailing-slash hop adds a round trip. Inspect every hop and remove redirects that are not required.
- Queueing or stalled time: the browser is waiting for a connection or an available socket. Compare runs and check whether many earlier requests are competing for connections.
- Waiting for server response (TTFB): investigate server-side application work, upstream dependencies, cache behavior, and the network path when this dominates.
- Content download: the server has started responding, but the document itself takes time to transfer. Check its size and delivery conditions.
A high TTFB is not fixed by shrinking an image that arrives later. Conversely, a quick document response does not rule out a page that remains unusable while resources download or JavaScript runs.
Rank #2
- Vinyl Hard Cover: Durable grey vinyl hard cover provides long-lasting protection for your notes and records
- 200 Sewn Pages: Features 200 sewn pages with lined rule for organized and secure documentation
- Oilfield Book: Specifically designed for oilfield use with standard industry specifications
- Directional Drilling: Tailored for directional drilling operations and pipe tally marking on oil rigs
- Standard Driller Size: Measures 8.25 inches tall and 3.5 inches wide, the dimensions used by professional drillers
4. Follow the Network waterfall after the document arrives
Use the waterfall to find the request that actually delays the visible page, rather than changing every large file. Sort or filter by type and inspect the request’s Timing, Headers, and transferred size.
Images and media
Look for oversized images, images delivered at dimensions far larger than their display size, and below-the-fold media fetched during the initial view. Resize an image to the size it is displayed at and avoid loading media that is not needed for the initial display. Confirm the image’s transfer size and its position in the waterfall after the change.
Stylesheets and fonts
Identify stylesheets that block the first display and fonts that arrive late or trigger visible text changes. Remove CSS that is not needed for the initial view, split or defer noncritical styles where your build allows it, and reduce avoidable font requests. Do not remove a stylesheet merely because it is large; first verify that it is on the critical path.
JavaScript
Check scripts that block parsing, delay rendering, or keep the main thread busy after resources have arrived. Limit the JavaScript needed for the initial display and defer work that can happen after the page is usable. The Performance panel is the right place to confirm long tasks; a slow-looking waterfall alone cannot tell you how much time was spent executing code.
Request count and transfer size
Review the complete list for repeated libraries, duplicate resources, slow third-party requests, and files that are fetched but never needed on this view. Lighthouse resource diagnostics can point to excessive requests and transfer sizes, but inspect the individual request before removing or combining it. A single large transfer and dozens of small blocking requests require different remedies.
5. Use the Performance panel when the waterfall is not enough
In DevTools, open Performance, start a recording, reload the page, and stop after the page becomes interactive. The trace helps distinguish network waiting from main-thread work such as script execution, style calculation, layout, and painting.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #3
- EASY FORGOT YOUR PASSWORD? - This small password journal allows you to save all your passwords, account & login details in one place. Managing your online web account information & user data safe. The set comes with 2 password logbooks one to keep at work and one at home. Never forget your passwords again.
- SIMPLE & PRACTICAL - Wire bound password journals with durable plastic cover the sturdy plastic cover resists rips, tears, and folds. Features alphabetic tabs to help organize your data and navigate your accounts easily.
- POCKET SIZE - 2 pack 5"x7" and 3.5"x5.25" mini password journal with A-Z tabs and 120 pages each, lots of space, easy to write, there's even room to add to your password journal.
- DURABLE - Thick frosted poly covers will protect your password book from damage. Made out of premium paper great for fountains pens and ink. No feathering and bleeding. Thick paper & Strong Binding.
- GUARANTEED QUALITY - High quality, heavy-duty and BUILT TO LAST! Made by Excello Global Products. We are a family owned USA company and we have been making quality products for over 50 years.
This is especially important when the document and its resources arrive promptly but the interface still feels frozen. Compare the trace with the user’s report and with field data: a lab trace may not reproduce a post-load layout shift or a long task that occurs only on a particular device or session.
6. Match the fix to the measured bottleneck
If the main document has a long first-byte delay
- Remove unnecessary redirects and verify that the final URL is requested directly.
- Profile server-side application work and slow upstream calls that occur before the response begins.
- Check cache behavior and compare cold and repeat visits; do not assume a fast cached result represents a first visit.
- Repeat the document timing after each change, using the same URL and test conditions.
If the document is fast but the first view is delayed
- Resize oversized images and verify their transferred bytes.
- Reduce requests and bytes needed for the initial display.
- Limit or defer CSS and JavaScript that is not required to show the first view.
- Investigate fonts and media that appear late in the waterfall.
If the page loads but interaction is sluggish
Use the Performance trace to find long JavaScript tasks and rendering work. A higher Lighthouse score by itself does not establish that the interaction problem is gone; confirm the affected task or user-visible timing improved.
7. Measure one change at a time
- Write down the suspected cause and the timing or request that supports it.
- Apply one meaningful change, such as removing a redirect, resizing a specific image, or deferring a known noncritical script.
- Repeat the same PageSpeed Insights mode and the same DevTools procedure. Keep device, network, location, URL, and cache state comparable.
- Verify the affected metric or request, not just the aggregate performance score.
- Keep the change only if the user-visible delay or its measured cause improves without creating a new blocking request or rendering problem.
Performance is a feedback loop. Diagnostic tools identify opportunities; they do not promise a fixed score or improvement for every site.
8. Common diagnostic disagreements
| What differs | Why the results can disagree | What to compare |
|---|---|---|
| Field versus lab | Real Chrome sessions use varied devices, locations, cache states, and interactions; a lab run is controlled. | Look for the same symptom in field data, then use Lighthouse and DevTools to isolate a cause. |
| Main document versus later resources | A quick first byte can be followed by blocking images, fonts, CSS, or scripts. | Compare document TTFB with the waterfall and the Performance trace. |
| Cold versus repeat visit | Cached documents and resources can conceal the first-visit delay. | Run both states and label them in your notes. |
| Mobile versus desktop | CPU, network, viewport, and resource priorities differ. | Reproduce the device class named in the complaint before choosing a fix. |
9. Troubleshooting checklist
| Symptom | Likely investigation | Next action |
|---|---|---|
| Large blank interval before the document begins | Redirects, server application work, cache miss, or network path. | Inspect the document Timing tab and each redirect; profile server work. |
| Document arrives quickly, but the hero area appears late | Large image, blocking stylesheet, font, or script. | Find the first blocking request in the waterfall and inspect its size and timing. |
| Waterfall looks complete, but scrolling or clicking stutters | Long JavaScript tasks or rendering work. | Record a Performance trace and locate main-thread long tasks. |
| Only repeat visits are fast | Cold-cache transfer or server response is expensive. | Compare disabled-cache and normal-cache runs; fix the cold path if first visits matter. |
| PageSpeed Insights has no field data | The page may not have enough eligible Chrome UX Report data. | Use the Lighthouse run and your own controlled DevTools reproduction; do not infer speed from missing field data. |
| A score improves but users still report slowness | The changed audit was not the bottleneck, or the lab did not reproduce the field issue. | Return to the reported device and path, inspect field evidence, and verify the specific user-visible delay. |
Or skip the browser setup
When you need repeatable screenshots while checking a visual fix, ScreenshotNeo provides a website screenshot API. It is not a replacement for TTFB or waterfall diagnostics, but it can capture the same URL under consistent viewport and wait settings without maintaining a browser script.
One GET request returns PNG, JPEG, WebP, or PDF. The API can wait for a selector, a delay, or network idle; use a device preset or custom viewport; capture full pages or one CSS-selected element; apply custom CSS or JavaScript; hide selectors; set cookies, headers, user agent, timezone, geolocation, or Authorization; and block selected requests or resource types. Those controls let you make before-and-after captures comparable while DevTools supplies the timing evidence.
See the ScreenshotNeo documentation for the complete parameter list. The following calls target Stripe and save the returned image.
Rank #4
- Used Book in Good Condition
cURL
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be disabled. Only clean shots are billed. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and the response identifies the result with X-Page-Verdict and X-Billed headers. An MCP server supplies take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients, so an AI agent can collect the same evidence.
| Plan | Included shots | Price |
|---|---|---|
| Free | 1,000 per month | $0, no card |
| Starter | 3,000 | $5 |
| Growth | 15,000 | $15 |
| Pro | 60,000 | $39 |
| Scale | 250,000 | $99 |
| Business | 1,000,000 | $249 |
Yearly billing gives two months free, and every feature is on every plan. Create a free ScreenshotNeo account to get 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots.
FAQ
Should I test a private or authenticated page the same way?
Yes, if that is where the complaint occurs, but preserve privacy: use a representative account, avoid exposing real personal data in recordings, and document the authentication state so another run can reproduce it. A public home-page result cannot diagnose a slow dashboard.
When is a hosting or application-team escalation justified?
Escalate after repeated, comparable document timings show a persistent first-byte delay and you have ruled out avoidable redirects and test-condition changes. Include the URL, timestamp, device and location, cache state, redirect chain, and the document Timing breakdown so the team can investigate server work rather than guessing from a score.
