Skip to content
Tutorials Center
My learning

Topics

Lesson 19 of 36 ยท Performance Panel

A Tour of the Performance Panel

Open the Performance panel, learn its toolbar, tracks and summary tabs, and understand the 16 ms frame budget that every smooth page has to respect.

Every other panel in DevTools shows you a state: the DOM right now, the files that were downloaded, the values in storage. The Performance panel is different, because it shows you time. You press record, use the page, press stop, and DevTools gives you a detailed film strip of everything the browser did: running JavaScript, calculating styles, laying out boxes, painting pixels, and waiting for the network.

This lesson is a guided tour of the panel. You will learn where the controls live, what each track means, and why one number, 16.7 milliseconds, shows up in almost every performance conversation. The next lesson then teaches you how to actually read a recording.

DevTools itself cannot run on this site, so the screens are described in words and the exercises use small JavaScript stand-ins that model the same ideas. Menu names follow current desktop Chrome; Google renames small things between releases, so use the command menu (Ctrl+Shift+P, then type "Performance") if a label looks different.

Opening the panel

Open DevTools with F12 or Ctrl+Shift+I (Cmd+Option+I on macOS), then choose the Performance tab. If you cannot see it, click the double-arrow at the end of the tab bar. A few habits make your measurements trustworthy:

  • Use an Incognito window with extensions disabled. Extensions inject scripts and slow pages down, and they would pollute your trace.
  • Close other heavy tabs. Chrome shares CPU between them.
  • Remember that your development laptop is much faster than a typical phone. The panel has throttling controls for exactly this reason.

The toolbar

At the top of the panel you will find these controls:

Control What it does
Record (circle) Starts and stops a recording. Use it for interactions such as clicking, scrolling or typing.
Record and reload (circular arrow) Reloads the page and records until it has loaded. Use it for load performance.
Clear Throws the current recording away.
Screenshots checkbox Captures a small image every time the screen changes, so you can see what the user saw.
Memory checkbox Adds a graph of JavaScript heap size, DOM nodes and listeners.
Network dropdown Throttles the network (Fast 4G, Slow 4G, Offline, custom).
CPU dropdown Slows the processor by 4x, 6x or 20x to imitate weaker devices.

In recent versions, the panel also opens with a live metrics view when you have not yet recorded anything. It shows Largest Contentful Paint, Cumulative Layout Shift and Interaction to Next Paint for the page you are looking at right now, taken from your own session. That view is useful for a quick check, but a recording gives you the explanation behind the numbers.

The anatomy of a recording

After you stop, the panel fills with several horizontal bands. Learn their names, because the rest of the course uses them.

  1. Overview: a thin strip at the very top that shows CPU activity as a colored graph over time, plus FPS and network indicators. You drag across it to select the part of the recording you want to inspect.
  2. Timings and screenshots: markers for First Contentful Paint (FCP), Largest Contentful Paint (LCP), DOMContentLoaded and the load event, plus the screenshots you asked for.
  3. Network track: a compressed waterfall of requests made during the recording.
  4. Frames track: every frame the browser produced, drawn as a small block. Slow or dropped frames are marked in red or yellow.
  5. Interactions track: clicks, key presses and pointer events, each with the time it took to respond.
  6. Layout Shifts track: purple marks that show when content jumped.
  7. Main track: the flame chart of everything the main thread did. This is the track you will spend most of your time in.
  8. Other threads: Compositor, GPU, Raster, and any web workers.

Below the tracks, the summary drawer has four tabs. Summary shows a pie chart that splits the selected time into Loading, Scripting, Rendering, Painting, System and Idle. Bottom-Up lists functions sorted by the time they spent themselves. Call Tree shows the same data as a tree from the root call down. Event Log lists events in order.

The colors are consistent everywhere: yellow is scripting, purple is rendering (style and layout), green is painting, blue is loading, and grey is the rest.

Parts of a recording

Overview CPU, FPS, network
Main track Flame chart
Frames One block each
Summary tabs Where time went

Select a range, then read the tabs.

1 / 2

The frame budget

Most screens refresh 60 times per second. That leaves 1000 / 60 = 16.67 ms to produce each frame: run your JavaScript, recalculate styles, lay out, paint, and hand pixels to the GPU. The browser also needs a few milliseconds for its own housekeeping, so you realistically have about 10 ms for your code. On a 120 Hz display the whole budget is 8.33 ms.

When work takes longer than the budget, the browser skips frames. The user sees stutter in scrolling and animation. Here is a small stand-in that turns a list of per-frame work times into a verdict, the way the Frames track marks them.

JS Stand-in: frame budget checker

Press Run (or Ctrl + Enter) to see the console output here.

No output.

A frame that finishes in 22 ms did not drop to zero; it simply missed one refresh and shows up on the next, which users feel as a small hitch. The 80 ms frame is a visible freeze.

Throttling: testing like your users

If your users have mid-range Android phones, a trace recorded on a fast desktop will lie to you. Set CPU: 4x slowdown (or 6x) and Network: Fast 4G before recording. The throttling is an approximation: it makes the main thread wait, it does not make your CPU actually weaker, but it is good enough to reveal problems early. The stand-in below shows how scaling changes the story.

JS Stand-in: what a CPU slowdown does to task times

Press Run (or Ctrl + Enter) to see the console output here.

No output.

At 1x nothing is a problem. At 4x the analytics script becomes a 120 ms task, which blocks input. This is exactly the kind of surprise throttling brings forward.

Common mistakes

  • Recording with the DevTools window docked and huge; the page shrinks and may load a different layout. Use a fixed device mode when comparing runs.
  • Recording a minute of activity. Keep recordings short and focused on one action; long ones are hard to read and heavy to open.
  • Trusting one run. Record two or three and compare; noise from the OS and GC is normal.
  • Forgetting Disable cache in the Network panel when you want to measure a cold load.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the time budget per frame on a 60 Hz display?

    1000 ms divided by 60 frames is about 16.7 ms. 8.3 ms is the budget at 120 Hz.
  2. 2. Which toolbar button is best for measuring page load?

    Record and reload refreshes the page and records until it has loaded, so the whole load is in the trace.
  3. 3. In the colors used by the Performance panel, what does yellow represent?

    Yellow is scripting. Purple is rendering, green is painting and blue is loading.
  4. 4. Why use CPU throttling when recording?

    Throttling makes the main thread slower, so problems that only appear on weaker phones become visible on your machine.

Summary

  • The Performance panel records what happens over time, not just a snapshot.
  • Use Record for interactions and Record and reload for load performance.
  • Tracks to know: Overview, Timings, Network, Frames, Interactions, Layout Shifts, Main.
  • Summary, Bottom-Up, Call Tree and Event Log answer "where did the time go?".
  • Aim for work that fits inside the 16.7 ms frame budget, and test with CPU and network throttling.

Next: Recording and Reading the Flame Chart