skip to content

Before recording a page-load trace in the Chrome DevTools Performance panel, which recording conditions do you set, and why is an unthrottled run on a developer laptop with a warm cache a misleading baseline?

level: juniorimportance: should knowfreq 48%

answer

  1. your laptop is not the user's device
  2. warm cache answers a different question
  3. throttle both CPU and network
  4. start the recording before navigation
  5. extensions run in your trace too

basics

~20 s

Record a production build with CPU throttling, network throttling and the cache disabled, in a clean browser profile with extensions off, using the reload-and-record option so the trace covers startup. Otherwise the trace measures your laptop, not your users.

solid answer

~50 s

A trace is only true about the machine, build and cache state you recorded it on, so I set those deliberately. I enable **CPU throttling** — a 4x slowdown is a rough stand-in for a mid-range phone and 20x for a low-end one — because a developer laptop hides script cost that dominates on real devices. I apply a **network throttling** preset so download and latency cost appears at realistic scale, and I disable the cache so the recording reflects a first visit rather than an already-primed one. I record in a **clean profile with extensions disabled**, since injected extension scripts land in your trace as if they were your code. And I use the **reload-and-record** control so the recording starts before navigation and captures parse and startup, not just what happens after paint. Preset labels have changed across Chrome versions; the reasoning has not. Throttling is still a simulation — it approximates a slow device, it does not become one.

go deeper

for a junior

Be ready to list the conditions you would set before recording — production build, CPU and network throttling, cache disabled, clean profile — and say why each one matters.

for a middle

Explain what each setting changes about the trace: why CPU throttling exposes script cost, why cache state changes which question you are answering, and why the recording must start before navigation for a load trace.

for a senior

Show judgment about matching conditions to the scenario under investigation, and state the limits of simulated throttling honestly rather than presenting a throttled number as what a user will experience.

for a principal

Own the standard: which device and network profile the organization treats as its reference for performance decisions, and how that choice is kept consistent so numbers from different engineers mean the same thing.

## The trace describes the machine you recorded it on Every performance recording is a measurement of one specific combination: this build, this hardware, this network, this cache state, this browser profile. Change any of those and the numbers change, sometimes by an order of magnitude. The reason to configure the recording carefully is not ritual — it is that the default configuration (your fast laptop, a warm cache, a development build, your everyday browser with a dozen extensions) is the configuration *least* like the users complaining. ## CPU throttling The single largest gap between a developer's machine and a real user's is single-core CPU speed. Script parsing, compilation and execution scale almost directly with it, so a 200 ms startup on a laptop can be well over a second on a mid-range phone. The Performance panel's CPU throttling dropdown applies a multiplier that slows the main thread down artificially — a 4x slowdown is the common proxy for a mid-range device and 20x for a low-end one. Two caveats worth saying out loud in an interview. First, the multiplier is uniform: it slows everything, whereas a real phone also has different cache sizes, thermal throttling and memory pressure, so the *shape* of the trace can still differ. Second, throttling makes CPU-bound problems visible, which is exactly why unthrottled traces of script-heavy pages look deceptively fine. ## Network throttling and cache state Network throttling constrains bandwidth and adds latency so requests take a realistic amount of time. Without it, everything served from localhost arrives essentially instantly and the trace cannot show you a loading problem at all. Chrome ships presets for slower connections; their labels have been renamed across versions, so pick the one that matches the audience you care about rather than memorizing a name. Cache state matters just as much. A reload with a warm cache skips downloads, skips some parsing work, and produces a page that is genuinely faster than a first visit — so a warm-cache trace silently answers a different question. Disabling the cache while DevTools is open gives you the first-visit picture. Both are legitimate questions; the mistake is not knowing which one you asked. ## A clean browser profile Extensions inject content scripts into pages, add listeners, and run their own work on your main thread. In a trace, that work is often indistinguishable at a glance from the page's own. Recording in a fresh profile, a guest window, or with extensions disabled removes an entire class of phantom costs — and a surprising number of "our page has a mysterious 300 ms of scripting" investigations end here. ## Recording the right span For a load investigation, use the panel's reload-and-record control rather than starting a recording on an already-open page: it begins capturing, then navigates, so HTML parsing, script evaluation and the first paints are all inside the trace. If you are investigating an interaction instead, do the opposite — get the page to the pre-interaction state, start recording, perform the single interaction, and stop. Keep recordings short. Long ones are harder to read, the profiler's own overhead accumulates, and you end up scrolling past minutes of nothing. ## Also profile the right build Throttling a development build does not save it. Dev builds carry unminified modules, development-only warnings and a hot-reload client, and those costs can easily outweigh whatever you are investigating. Point the profiler at a production build served the way production serves it. ## What throttling is not Simulated throttling remains a simulation. It approximates a slow device and a slow link well enough to expose problems and to compare a before against an after, and it is repeatable in a way a real device never is. It does not reproduce a specific phone's behaviour, and it should not be presented as though it did. The honest framing is: throttled recordings tell you *whether the problem exists and whether your fix helped*; they do not tell you the exact number a given user will see.

  • When is a warm-cache, unthrottled recording actually the right thing to record?
    When that is the question you are asking. If the complaint is about a repeat visit or an in-app interaction on a desktop-heavy internal tool, a warm cache and a fast machine match the real conditions. The rule is not "always throttle" — it is that the recording conditions must match the scenario you are investigating, and that you say which conditions you used when reporting numbers.
  • Why does profiling in your everyday browser profile risk a wrong conclusion?
    Extensions inject content scripts and run their own listeners and timers on the page's main thread, so their cost appears in the trace alongside your code and is easy to misattribute. Recording in a clean profile, a guest window, or with extensions disabled removes that noise. It is worth ruling out before investigating any unexplained block of scripting work.
  • What does a 4x CPU slowdown fail to reproduce about a real mid-range phone?
    It scales main-thread speed uniformly, but a real device also differs in memory, cache sizes, GPU, thermal throttling and network variability, so the shape of the trace can differ, not just its scale. Treat throttling as a repeatable proxy that exposes CPU-bound problems and lets you compare before and after — not as a prediction of what a particular handset will show.

saying these in an interview costs you the question

  • Reports laptop numbers as if users would see them
  • Records a reload with the cache already warm
  • Throttles the network but leaves the CPU at full speed
  • Starts the recording after the page has already loaded
  • Treats simulated throttling as equivalent to a real device

context