Good website animation performance means motion that runs at the screen’s full frame rate without delaying the first paint, blocking taps or shifting the layout. You get it by animating only cheap properties (transform and opacity), keeping the first screen visible without waiting for scripts, reading scroll position efficiently and giving people who prefer less motion a calm version of the page. This guide explains why animation slows sites, the rules we follow on real builds, a step-by-step process, how to measure the result and the mistakes that cost the most.
Last updated: 18 November 2026.
Why does animation slow a website down?
Animation slows a website when it asks the browser to do expensive work on every frame or when it hides content until a script decides to show it. A screen refreshes about 60 times a second on most devices and faster on many phones and laptops, so each frame has only a few milliseconds of budget. Anything that takes longer drops frames, and people feel it as stutter.
The browser renders a page in stages: it works out styles, calculates layout (sizes and positions), paints pixels and then composites layers together. Changing a property that affects layout, such as width, height, top or margin, forces the browser to redo layout and paint for part of the page on every frame. Changing transform or opacity can usually be handled at the final compositing stage, often on the graphics chip, which is far cheaper.
The second cause is less visible but more damaging to search and conversion: entrance effects that start with content hidden. If the largest element on the first screen begins at zero opacity and waits for a script to fade it in, the browser cannot report it as painted. That pushes back Largest Contentful Paint, one of Google’s Core Web Vitals, even when the page itself loaded quickly.
Does scroll animation slow a site?
Scroll animation slows a site only when it is built carelessly. Effects that move elements as you scroll are among the most demanding kinds of motion, because they must respond to every scroll event without lag.
The three usual causes of slow scroll effects are:
- Reading layout inside the animation frame. Asking for an element’s position after changing styles forces the browser to recalculate layout immediately, sometimes many times per frame.
- Animating too many elements at once. Every element promoted to its own layer uses graphics memory, and phones run out quickly.
- Listening to scroll without restraint. Heavy work on every scroll event competes with the browser’s own scrolling.
Built properly, scroll effects stay smooth even on mid-range phones. The rules below are the ones that make the difference.
At Odduel, a creative and technology agency in Barcelona and São Paulo, motion is part of how we build sites through our website development service, and these rules come from tuning that motion on live pages.
In short: animate transform and opacity only; never hide the largest element of the first screen; read scroll position once per event and write styles once per frame; promote elements to layers only when they are close to the screen; and give reduced-motion users a still, complete page.
What are the website animation performance best practices?
These practices cover most of the gap between motion that feels premium and motion that feels heavy.
Animate transform and opacity, not layout
Move, scale and rotate with transform; fade with opacity. Avoid animating width, height, top, left, margin, padding, box-shadow spread and font size. If an element must appear to grow, scale it and correct the visual with a wrapper rather than changing its real size.
Keep the first screen visible from the first frame
Mark the largest element of the opening screen and exempt it from hidden start states. It may rise slightly into place, but it should be painted with the first frame, not after a fade. Load the web font with a fallback that has similar proportions, so lines do not re-break when the font arrives.

Separate reading from writing
Read the scroll position in the scroll event, store it, and apply styles in a single animation frame callback. Never read an element’s size or position after you have changed styles in the same frame.
Promote layers sparingly
The CSS property will-change, or a 3D transform, gives an element its own compositor layer. That makes its motion cheap but costs memory. Add it only to elements within roughly a screen of the viewport and remove it once the effect is over. Never give individual letters their own layers.
Prefer CSS and native browser features
CSS transitions and keyframe animations run efficiently, and the browser can optimise them. The Web Animations API is a good middle ground for script-controlled motion. Large animation libraries are not always needed; when they are, load them only on the pages that use them.
Respect reduced motion
People can ask their operating system for less motion. The CSS media feature prefers-reduced-motion lets the site answer with a calm version: content written in full, no parallax, no long entrance effects. It is an accessibility requirement as much as a courtesy, and it also helps on low-powered devices.
Which animation techniques are cheap and which are costly?
| Technique | Cost per frame | Use it for |
|---|---|---|
| transform (translate, scale, rotate) | Low | Movement, parallax, reveals |
| opacity | Low | Fades, cross-fades |
| filter (blur, brightness) | Medium to high | Short accents only, small areas |
| clip-path | Medium | Wipes, on a few elements at a time |
| width, height, top, left, margin | High | Avoid in animation |
| box-shadow, background-position | High | Avoid animating; swap static states |
| Canvas or WebGL | Depends on the shader | Hero visuals, with a still fallback |
What are the steps in website animation performance work?
Treat performance as part of the motion design, not a clean-up after launch.
- Design the motion with a purpose. Decide what each effect communicates: hierarchy, continuity between pages, feedback on a tap. Cut effects that do not earn their cost.
- Choose the technique per effect. Map each effect to transform, opacity or a canvas. If it needs a layout property, redesign it.
- Define the still state first. Every animated element must look complete without the animation: without scripts, with reduced motion and in print.
- Build behind feature checks. Run heavy effects only when the device and settings allow them: a fine pointer, a wide enough window, motion allowed, a hardware renderer for WebGL.
- Measure on real devices. Record a performance trace on a mid-range phone and a laptop, looking for long tasks, dropped frames and layout shifts.
- Check Core Web Vitals. Compare Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift before and after the motion is added.
- Monitor after launch. Field data from real visitors shows problems that lab tests miss, especially on older phones.
How long does it usually take?
On a new build, performance-minded animation adds little time if it is planned from the start: the still states, feature checks and measurements become part of each template. Retrofitting an existing site is slower, because effects built on layout properties often have to be redesigned rather than tuned.
As a rule of thumb, budget a dedicated round of measurement and tuning for each page type with significant motion, plus testing on real phones. Our guide on how long it takes to build a website shows where this fits in the overall schedule.
How do you measure animation performance?
Measure three things: frame rate during the effect, the impact on loading and the impact on interaction.
- Frame rate and long tasks: the Performance panel in your browser’s developer tools records each frame; look for frames that take longer than the screen’s refresh interval and for tasks over 50 milliseconds.
- Loading: Largest Contentful Paint should not move later because of entrance effects. Test with motion on and off to see the difference.
- Interaction: Interaction to Next Paint shows whether taps and clicks wait behind animation work.
- Stability: Cumulative Layout Shift catches effects that move surrounding content.
Test on a mid-range Android phone, not only on a fast laptop. Test with the browser’s CPU throttling as a rough stand-in, and with reduced motion switched on.
Does animation affect accessibility?
Yes. Motion can cause discomfort or nausea for people with vestibular disorders, and moving content can distract people with attention difficulties. The W3C’s guidance on animation from interactions explains the expectation that motion triggered by interaction can be switched off.
In practice, three habits cover most cases: honour reduced motion, avoid large parallax and flashing effects, and never put essential information inside an animation that only plays once. Our website accessibility guide covers the wider requirements.
What are the most common mistakes?
| Mistake | Why it hurts | Better approach |
|---|---|---|
| Hiding the hero until a script runs | Delays the largest paint | Paint it in the first frame; let it rise |
| Animating layout properties | Drops frames on phones | Transform and opacity only |
| One library for every page | Extra script on pages without motion | Load per page, or use CSS |
| Promoting every element to a layer | Memory pressure, crashes on phones | Promote near the viewport only |
| Ignoring reduced motion | Excludes people, fails accessibility checks | A complete still version |
| Testing only on a fast laptop | Misses real stutter | Mid-range phone and field data |
Typography deserves a special mention: animated text that splits into letters can be heavy and can break screen readers. Keep the full text available to assistive technology and animate as few pieces as possible. Our article on web typography covers the type side.
Questions people ask
Does scroll animation slow down a website?
It does only when built carelessly. Scroll effects stay smooth when they animate transform and opacity, read the scroll position once per event, write styles once per frame and limit layers to elements close to the screen. Problems come from animating layout properties, reading positions inside the frame and running effects on too many elements.
What is the best way to animate a website without hurting speed?
Animate only transform and opacity, keep the largest element of the first screen painted from the first frame, prefer CSS transitions or the Web Animations API, and load heavier libraries only where they are used. Then measure frame rate, Largest Contentful Paint and Interaction to Next Paint on a real mid-range phone before launch.
Do animations affect Core Web Vitals?
They can. Entrance effects that hide content delay Largest Contentful Paint, heavy scripts during interaction worsen Interaction to Next Paint, and effects that move surrounding content raise Cumulative Layout Shift. Motion designed with still states, compositor-friendly properties and careful script timing can leave all three unchanged.
Should a website respect reduced motion settings?
Yes. The prefers-reduced-motion media feature tells the site that a visitor has asked their device for less motion. The site should answer with complete, still content: no parallax, no long entrance effects, no scroll-driven movement. It supports people with vestibular disorders and also helps on low-powered devices.
Are animation libraries bad for performance?
Not by themselves. Mature libraries can be efficient, but they add script weight and are often loaded on every page. Use CSS and native browser features where they suffice, and load a library only on the pages that need it. What matters most is which properties you animate and when.
List every effect on your site, note the property it animates and test the page on a mid-range phone with motion on and off; the gaps will be obvious. If you want motion that feels premium and still loads fast, see our website development service or tell us about your project.


