Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 36 ยท Getting Started

What Is Chrome DevTools? A Tour of the Panels

Learn what Chrome DevTools is, what each main panel is for, and how to choose the right panel for a task, with a runnable stand-in that maps problems to panels.

Chrome DevTools is a set of tools built into the Chrome browser that lets you look inside a web page while it runs. You can see the HTML the browser built, the CSS rules it applied, the JavaScript it executed, the network requests it made, and how long each step took. Instead of guessing why a page looks wrong or loads slowly, you inspect it and know.

Almost every front-end developer uses DevTools daily. This course teaches it panel by panel, with a task-oriented approach: each lesson starts with a question ("why is this button misaligned?", "why is this request failing?") and shows which tool answers it.

DevTools is part of Chrome, not part of this website. The examples in this course that you can run here are small stand-ins: plain JavaScript programs that teach the same ideas (a cascade resolver, a waterfall printer, a source-map decoder). They are clearly labelled, and they never pretend to be the real tool. To follow the steps themselves, open any page in Chrome and press F12.

What DevTools can and cannot do

DevTools works on the page that is loaded in the tab. It reads the live page, and many changes you make are temporary: edit a color in the Styles pane and the page changes, but when you reload, the change is gone. DevTools does not edit your source files unless you set up a workspace (covered later in this chapter's lessons on customizing) or copy the changes back by hand.

It is also not only for Chrome pages. Because Edge, Brave, Opera and many other browsers are built on the same engine (Chromium), they ship almost identical tools. Firefox and Safari have their own developer tools with similar ideas but different layouts.

The main panels at a glance

DevTools is organized as a row of panels along the top. The set you see depends on your Chrome version and settings, but these are the ones you will use most:

Inspect and change the page

Elements DOM tree and CSS
Console Logs and live JavaScript
Sources Files and breakpoints

Layout bugs and logic bugs start here

1 / 3
  • Elements shows the DOM tree and the CSS applied to each node. Use it for layout and styling problems.
  • Console prints messages from the page and lets you run JavaScript against it.
  • Sources shows the page's files, lets you set breakpoints and step through code.
  • Network lists every request with timing, headers and response bodies.
  • Performance records what the browser did over time: scripting, layout, painting.
  • Memory takes heap snapshots to find memory that is never released.
  • Application shows storage (cookies, local storage, IndexedDB), service workers and the web app manifest.
  • Lighthouse runs automated audits for performance, accessibility, best practices and SEO.
  • Security and the more specialized panels (Recorder, Rendering, Layers, and others) can be reached from the menu or the Command Menu.

You will meet each of these in depth later. For now, the goal is to know where to look first.

Choosing a panel from the symptom

Experienced developers match symptoms to panels almost automatically. Here are common examples:

Symptom First panel
Text is the wrong color or size Elements (Styles pane)
An element is missing from the page Elements (is it in the DOM? is it hidden?)
"Uncaught TypeError" in red Console, then Sources
A feature works wrong but throws nothing Sources (breakpoints)
An image or API call fails Network
The page feels slow or janky Performance
Memory use grows over time Memory
Login state is lost after refresh Application (cookies, storage)
A manager asks for a quality report Lighthouse

The stand-in below turns this table into code. It is a tiny lookup that you can extend with your own symptoms.

JS Stand-in: which panel should I open first?

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

No output.

The function is a crude keyword match, nothing more. The real skill is the mental map it represents: symptoms first, tools second.

How DevTools stays in sync with the page

DevTools talks to the page through a debugging protocol (the Chrome DevTools Protocol). That is why the Elements panel updates when scripts change the DOM, why the Console can read the same variables your page uses, and why breakpoints can pause the page mid-run. The same protocol is used by automation tools such as Puppeteer and Playwright, which is one reason what you learn here carries over to testing tools.

A useful mental model is two live views of the same page:

flowchart LR
  A["Your page<br/>HTML, CSS, JS"] --> B["Browser engine<br/>DOM, styles, network"]
  B <--> C["DevTools<br/>inspects and edits live state"]
  C -. "temporary edits" .-> B

DevTools reads the browser's live state and can push temporary edits back; your source files are untouched.

Your first five minutes

Try this on any web page in Chrome:

  1. Press F12 (or right-click an element and choose Inspect).
  2. In Elements, hover over nodes and watch the page highlight them.
  3. Switch to Console and type document.title, then press Enter.
  4. Open Network, reload the page, and sort by size to see the heaviest request.
  5. Close DevTools and reload: all your temporary edits are gone.

That last point is a feature. You can experiment freely, because nothing you do to the live page damages the real site.

A second stand-in: what survives a reload?

New users often lose work because they forget what is temporary. This stand-in models the rule: edits to the live page vanish on reload, edits to a source file (or an override you saved) survive.

JS Stand-in: what survives a reload?

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

No output.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What happens to a CSS change you type into the Styles pane when you reload the page?

    Edits are applied to the live page only. Reloading rebuilds the page from the real source files.
  2. 2. A request to your API returns an error. Which panel do you open first?

    The Network panel lists every request with its status, headers and response body.
  3. 3. Which panel runs automated audits for performance, accessibility and SEO?

    Lighthouse produces scored reports in those categories.
  4. 4. Why do other Chromium-based browsers have similar developer tools?

    Edge, Brave and Opera are built on Chromium, which includes the DevTools front end.

Summary

  • DevTools is a built-in toolbox for inspecting and debugging a running page.
  • Elements (DOM and CSS), Console, Sources, Network, Performance, Memory, Application and Lighthouse are the core panels.
  • Choose a panel from the symptom: styling in Elements, errors in Console, failed requests in Network, slowness in Performance.
  • Edits are temporary unless you save them to files, so experiment freely.

Next: Opening DevTools, Docking and Layout