CSS Performance: Layout, Paint, and Composite

To build high-performance web applications, you must understand how CSS styles impact the browser's rendering engine. When elements change on screen (during transitions or animations), the browser executes three primary stages in its rendering pipeline: Layout (Reflow), Paint, and Composite.

Writing inefficient styles can force the browser to run expensive layout recalculations, causing frame drops (jank) and draining mobile device batteries.

The Rendering Pipeline

When styles change (via hover states, CSS animations, or JavaScript changes), the browser runs a sequence of steps:

[ JavaScript / CSS Styles ] ──> [ Layout (Reflow) ] ──> [ Paint ] ──> [ Composite ]

Each stage has a different computational cost, and depending on which CSS properties you modify, the browser may skip certain stages.

1. Layout (Reflow) - Most Expensive

The Layout stage computes the geometry and position of all elements in the document.

If you change a property that affects the size, shape, or position of an element, the browser must recalculate the dimensions of that element and all elements affected by its change in the DOM flow.

Properties that trigger Layout:

• width, height
• margin, padding
• position, top, left, right, bottom
• display, float, font-size, border-width

Recommendation: Avoid animating layout properties. For example, animating left or top for a transition is highly inefficient because it forces layout calculations on every single frame.

2. Paint - Moderately Expensive

Once the geometry is calculated, the browser fills in pixels. The Paint stage draws text, colors, shadows, borders, and images onto visual layers.

If you change properties that alter the visual appearance of an element without modifying its size or position, the browser skips the Layout stage but must execute the Paint stage.

Properties that trigger Paint:

• color, background-color
• box-shadow, text-shadow
• border-radius, visibility
• background-image

Recommendation: Animating colors or shadows is cheaper than layout, but still demands CPU work, especially on complex pages with heavy layouts.

3. Composite - Cheapest (GPU Accelerated)

The Composite stage compiles all independent rendering layers and draws them onto the screen.

If you animate properties that do not change geometry or paint properties, the browser can offload layers directly to the GPU (Graphics Processing Unit). The GPU simply slides, rotates, or fades these pre-rendered layers.

Properties that only trigger Compositing:

• transform (translating, scaling, rotating)
• opacity

Recommendation: ALWAYS animate elements using transform and opacity where possible. Animating transform: translateX(50px) instead of left: 50px completely bypasses Layout and Paint, resulting in smooth 60fps animations.

Optimizing Animations: will-change

The CSS will-change property warns the browser that an element is expected to change in the future, allowing the browser to promote it to its own compositor layer ahead of time.

.animated-modal {
  will-change: transform, opacity;
  transition: transform 0.3s ease, opacity 0.3s ease;
}

Warning: Don't abuse will-change

Promoting layers consumes GPU memory. If you add will-change to too many elements on a page, the overhead will slow the application down instead of optimizing it. Apply will-change only to elements that are actively causing rendering performance issues, and remove it if the changes stop.

Summary of Animation Strategies

Key Takeaways for Interviews

• Name the Rendering Pipeline Stages: Layout (sizes/positions), Paint (colors/pixels), Composite (layer sorting via GPU).
• Explain Reflow (Layout): Recalculating sizes of nodes. Modifying layout properties (like width, margin, top) cascades reflow recalculations across the DOM tree.
• GPU Promotion: Explain why animating transform and opacity is faster. They skip layout and paint entirely, allowing the GPU to animate pre-drawn layers.
• will-change Usage: Explaining how it lets the browser pre-promote elements to composite layers, while cautioning against over-allocating GPU memory.