The quick download:
Your throttling method decides whether performance tests reveal the real bottleneck or hide it.
-
Packet-level throttling simulates real network conditions by controlling every packet, capturing DNS lookups, TCP handshakes, TLS negotiation, redirects, and packet loss that browser DevTools throttling misses.
-
In one comparison, third-party connection costs jumped from 20 to 40ms under DevTools throttling to roughly half a second each under packet-level throttling.
-
Redirect costs showed the same pattern: under 20ms with DevTools throttling, but around 1.4 seconds with packet-level throttling.
-
Run the same page under both throttling modes, compare the waterfalls, and trust the packet-level view when they disagree.
When you’re doing performance testing, one of the most important variables to consider is the connection type. The web runs on chatty protocols, with a lot of back and forth between the browser and the server throughout the browsing experience. Each trip from the server to the browser, and back, is subject to the limits of the network in use: how much bandwidth is available, how high the latency is, how much packet loss there is, and so on.
Get throttling wrong, and you’ll spend weeks chasing the wrong bottleneck while the real constraint continues to slow the page down.
Accurate synthetic testing shows what a user would have experienced under constrained conditions. Correlating those results with Internet path, application, and infrastructure health helps identify where the delay actually originated. That starts with getting network throttling right during the test.
WebPageTest uses packet-level network throttling, which applies added latency to every packet. Of the available throttling methods, this most closely reflects real network conditions, although it can produce more variation between test runs than other approaches.
WebPageTest also supports optionally running tests using DevTools throttling instead. We don’t recommend it for everyday scoring, but it’s useful for comparing packet-level throttling with DevTools throttling and understanding how each approach affects your results.
Differences in Throttling Approaches
DevTools throttling applies at the request level and operates between the HTTP disk cache and the connection layer of the browser. The activity that happens at that connection layer stays out of reach for DevTools throttling, so it won’t affect things like:
- TCP slow-start
- DNS resolutions
- TCP connection times
- Packet-loss simulation
- TLS handshake
- Redirects
Because of where it operates in the stack, DevTools throttling also skips any network-level protocol prioritization that happens below it.
Simulated throttling, which Lighthouse uses, works differently again. It doesn’t apply any throttling during the page load. Instead, Lighthouse runs a test with no throttling, then applies adjustment factors to estimate how that load would have looked over a slow connection.
That approach is fast and repeatable, which is why it’s a sensible default for a tool that scores pages at scale.
Packet-level throttling applies to the underlying network, so its effect reaches each of those connection-layer processes and preserves protocol prioritization. The result is a more faithful representation of real network conditions. The table below compares the three methods.
| Method | How it works (mechanism) | Strengths | Blind spots | Variance | Best use |
| Simulated (Lighthouse) | Runs the page unthrottled, then applies adjustment factors to model a slow connection. | Fast, cheap, highly repeatable; good for scoring at scale. | Estimates rather than measures; can miss connection-setup and protocol effects. | Low | Fast, consistent Lighthouse scoring and regression tracking. |
| DevTools / request-level | Shapes traffic between the HTTP cache and the connection layer inside the browser. | Convenient local approximation; easy to run in Chrome. | Misses DNS, TCP setup, TLS, redirects, packet loss, and below-layer prioritization. | Low to moderate | Quick local checks when connection cost isn’t the focus. |
| Packet-level | Shapes traffic at the OS network layer, affecting every packet. | Models connection setup, redirects, packet loss, and protocol behavior most faithfully. | Needs OS-level network control; can vary more between runs. | Higher | Investigating DNS, connection setup, TLS, redirects, packet loss, and third-party connection cost. |
Modern Lighthouse documentation distinguishes simulated, request-level (DevTools), proxy-level, and packet-level throttling. It notes that packet-level shaping can cover TCP, UDP, and ICMP, which matters because HTTP/3 runs over QUIC on UDP. You can read the details in the Lighthouse throttling docs.
The impact might sound academic, so let’s look at specific examples where the type of throttling leads you to different conclusions.
Why throttling choice still matters
Throttling accuracy isn’t a settled topic you can safely ignore. A few things keep it relevant:
- Traffic increasingly runs over HTTP/3 and QUIC, not only HTTP/2. Because QUIC uses UDP, a method that only shapes TCP-style traffic can miss it.
- Test locations and network profiles should represent your real users, so match your profiles and regions to where your audience connects from.
- Fast, repeatable lab scoring and deeper diagnostic investigation serve different purposes. Lab scoring tracks performance changes, while diagnostic investigation explains what caused them.
- Comparisons between tools are only meaningful when they’re configured the same way. Match network profiles and throttling modes before comparing the results.
The Lighthouse throttling documentation is a good reference when you’re deciding which mode fits the question you’re trying to answer.
Revealing third-party connection costs
It’s common to find render-blocking requests loaded from a third-party domain. We load JavaScript libraries, CSS files, client-side A/B testing tools, tag management, ads, and more from third-party domains, and many of those load directly in the critical path. The page can’t display until those resources have been requested and downloaded.
The interesting question is how much those connections actually cost, and that’s where the throttling method changes what you see. Consider the two screenshots below, captured in 2021 on an emulated Moto G4 over a 4G connection using an older WebPageTest and browser environment.
Treat the exact numbers as an illustrative comparison from that setup rather than universal values, though the pattern holds today. The first screenshot shows three third-party domains serving render-blocking resources.

Here we’ve applied DevTools throttling. The connection cost (TCP + DNS + TLS) for these resources doesn’t look particularly high:
- cdn.shopify.com: 18ms
- use.typekit.net: 37ms
- hello.myfonts.net: 18ms
Here are the same requests with the same settings, this time with WebPageTest’s default packet-level throttling.

The connection costs look much more expensive:
- cdn.shopify.com: 550ms
- use.typekit.net: 549ms
- hello.myfonts.net: 545ms
Reading the DevTools numbers alone, you might conclude that the third-party connection cost is light. In isolation, 20 to 40ms can seem insignificant, so reducing it looks like more work than it’s worth.
The packet-level run tells a different story. In this capture those same connections cost roughly an order of magnitude more, around half a second each. That’s the point of the comparison: the accurate method reveals a cost the request-level method hides, and the right conclusion depends on seeing it.
Once you can see the actual cost, you have options. Self-hosting is one. Proxying the resources through an edge platform such as Fastly’s Compute@Edge, Cloudflare Workers, or Akamai EdgeWorkers, which reduces the connection cost by terminating requests closer to the user.
Proxying isn’t universally preferable, though. Its value depends on licensing terms, cache behavior, your Content Security Policy, Subresource Integrity, privacy considerations, and who owns updates when the third party ships a new version. Weigh those factors against the measured cost before you commit.
Third-party risk also reaches beyond connection time. A dependency you don’t control affects your availability, your users’ privacy, your security posture, and your change-control process. Accurate measurement helps you size the performance cost; those other factors belong in the same decision.
To re-emphasize the point, the actual download times for these requests stay close once you exclude the connection costs. Without the connection costs, the CSS requested from Shopify took 185ms to retrieve with packet-level throttling and 176ms with DevTools throttling in this capture. DevTools throttling can be applied at that download stage, so you see its effect there. Matt Zeunert’s article on throttling highlights this well too.
Masking the Cost of Redirects
UNPKG is a popular CDN for node modules (HTTP Archive data has found it on well over 100,000 sites). To pull in a library, you pass the package name, version number, and file like so:
You can also omit the version, or use a semver range or tag. When you do, unpkg issues a redirect to the latest matching version of the file. That’s convenient, but an unversioned URL adds two problems at once. You get a redirect on every request, and you get release unpredictability, because the version you receive can change whenever the package publishes an update. For example, a request to a neutral, unversioned package URL:
gets a 302 redirect to whatever the resolved, versioned URL happens to be at that moment:
React makes the unpredictability concrete. An unversioned https://unpkg.com/react URL won’t durably point at any one release; React’s current documented major version is 19, and you can check the latest at react.dev/versions. Pin the version when you need a stable, cacheable URL, and treat any unversioned example as accurate only at the moment it was recorded.
The redirect itself carries a cost. The browser has to issue the request, wait for the response, process the redirect, then issue a new request. With DevTools throttling, that cost looks minimal.
In the following screenshot of a truncated waterfall, the first group of requests (#12 to #14) all return 302 redirects, which trigger the actual requests (#27 to #29).

The redirects here look cheap: they all take under 20ms. DevTools throttling isn’t shaping them, because they happen at the network level, so the picture looks fine. Reading this alone, you might decide that removing the redirect is a minor improvement at best.
Here are the same requests on the same browser and network setting, with packet-level throttling applied instead.

Now the redirects look far more expensive. Instead of 17ms for the longest redirect, this capture shows around 1.4s.
The request order changes too. Because packet-level throttling reflects connection costs more accurately, downloads for requests with connection costs start at different times, so the ordering shifts.
Choosing a throttling method
You don’t need to be an expert in throttling internals to improve your site. Knowing where each method reaches its limits helps you read results across tools and avoid the wrong conclusion. Here’s a short decision guide:
- Use simulated throttling for fast, consistent Lighthouse scoring and regression tracking.
- Use DevTools / request-level throttling for a convenient local approximation.
- Use packet-level throttling when investigating DNS, connection setup, TLS, redirects, packet loss, protocol behavior, or third-party connection cost.
- Validate important conclusions with multiple runs and test locations that represent your real users.
One more caveat on protocol behavior: in modern Chrome, network-level prioritization applies below where request-level throttling operates, so a request-level test can miss it. HTTP/3 changes prioritization again, so don’t assume behavior from one protocol version carries over to another. When protocol behavior is the thing you’re studying, test it directly rather than inferring it.
Applying throttling insights to performance testing
Misleading lab results have a real cost. They send engineering effort in the wrong direction, ship slower pages, increase the risk of lost conversions, and delay incident resolution while the real bottleneck remains unresolved.
The practical habit is simple: run the same page under two throttling modes, compare the waterfalls, and validate what you find with multiple runs and representative test locations. When the two modes disagree, the more accurate method usually points to the real bottleneck.
A lab profile is a controlled model, not proof that every user experiences the same conditions. That’s why field validation remains an important part of performance testing.
Where synthetic testing fits within digital experience
Accurate throttling tells you what users experienced under constrained network conditions. It doesn’t explain why the delay occurred.
Finding the root cause requires correlating synthetic test results with Internet path, application, and infrastructure telemetry. A practical workflow looks like this:
- Detect a page-performance regression with WebPageTest or synthetic monitoring.
- Inspect the waterfall and connection phases to characterize the symptom.
- Correlate the timing with Internet-path, application, and infrastructure health to locate the cause.
- Route the issue to the right team or provider for resolution.
LogicMonitor Digital Experience extends this workflow by helping teams connect Internet-path telemetry with infrastructure health. That context makes it easier to move from “this page slowed down under constrained conditions” to “here is where the delay likely originated.”
Start by validating the same page under different throttling methods. Then use Internet Performance Monitoring to understand how those lab results relate to real production conditions.
Pair accurate synthetic testing with Internet path telemetry to find where delays start.
LogicMonitor connects throttling-accurate synthetic results with Internet, application, and infrastructure health, so you can move from spotting a slow page to pinpointing its cause.
FAQs
What is the difference between packet-level and DevTools throttling?
DevTools throttling shapes traffic at the request level, between the browser’s HTTP cache and connection layer, so it skips DNS, TCP setup, TLS, redirects, and packet loss. Packet-level throttling shapes traffic at the OS network layer, affecting every packet, so it reflects real connection costs and protocol behavior more faithfully.
Which throttling method should I use for performance testing?
Use simulated throttling for fast, repeatable Lighthouse scoring and DevTools throttling for convenient local checks. Choose packet-level throttling when you are investigating DNS, connection setup, TLS, redirects, packet loss, or third-party connection costs. Validate important findings across multiple runs and representative test locations.
Why does throttling choice still matter with HTTP/3 and QUIC?
QUIC runs over UDP, so a method that only shapes TCP-style traffic can miss it entirely. Packet-level shaping can cover TCP, UDP, and ICMP, which makes it better suited to modern traffic. Because HTTP/3 changes prioritization again, test protocol behavior directly rather than assuming it carries over from earlier versions.




