Picture a fundraising total at the bottom of a charity homepage. As the visitor scrolls down, each digit lifts into place a fraction after the one before it, so the number seems to build itself. It is a small touch, but it rewards people for reaching the end of the page.
Effects like this are now possible in pure CSS, with no JavaScript scroll listeners at all. The catch is that a few of the techniques doing the rounds are far more complicated than they need to be. A recent approach used custom CSS functions and a long mathematical formula to work out each element’s offset, and even its own explanation admitted the maths looked intimidating. In most cases, a single property does the same job.

Jargon Buster
A few terms crop up whenever scroll-driven animation is discussed. Here they are in plain English.
Scroll-driven animation
An animation whose progress is tied to how far the page (or an element) has been scrolled, rather than to the clock. Scroll back up and it plays in reverse.
Staggering
Starting the same animation on a group of elements one after another instead of all at once, so they arrive in a ripple.
View timeline
A timeline that tracks a single element as it travels through the visible part of the screen, from the moment it appears to the moment it leaves.
Why Delay Doesn’t Work Here
With ordinary, time-based animations, staggering is easy: give each item a slightly longer animation-delay than the last. Many developers reach for the same trick when they switch to scroll-driven animations, and are puzzled when nothing happens.
The reason is simple. A delay is measured in seconds, and a scroll timeline has no concept of seconds. Once an animation is attached to scroll position, time-based delays are ignored. That gap is exactly what prompted people to invent their own formulas, but the specification already filled it with animation-range-start, which lets you say how far into the scroll an animation should begin.
One Line Instead of a Formula
Here is a typical time-based stagger, using sibling-index() to give every digit its own delay:
@keyframes rise-in {
from { opacity: 0; translate: 0 1.5em; }
to { opacity: 1; translate: 0 0; }
}
.digit {
animation: rise-in 0.4s ease-out both;
animation-delay: calc(sibling-index() * 80ms);
}
To make the same ripple follow the scrollbar, swap the delay for a start point on the view timeline. Each digit begins a little further into its entry than its neighbour:
.digit {
animation: rise-in linear both;
animation-timeline: view();
animation-range-start: entry calc(5% + 3% * sibling-index());
animation-range-end: entry 100%;
}
That third line is the whole stagger. The first digit starts just after the number enters the screen, the second 3% later, and so on. Want a tighter or looser ripple? Change the 3%. There is no master formula to untangle and nothing to recalculate when you add or remove an item.

What About Easing?
A common worry is that easing curves stop working once time is taken out of the picture. They don’t. The name animation-timing-function suggests a link to the clock, yet the property shapes progress along a scroll timeline in exactly the same way, so ease-out, cubic-bezier(), linear() and even steps() all apply.
Ironically, it is the do-it-yourself approach that breaks easing. When every element is merged into one big animation driven by a single progress value, any easing you add is applied to the whole sequence rather than to each item, so developers end up writing their own easing maths too. Using the built-in properties keeps each element’s curve separate.
Built-In or Home-Made? Weighing It Up
Reinventing something the browser already does is not always wrong. Plenty of popular tools started that way because they offered control the platform couldn’t. It is worth knowing the trade-off before you commit.
Using animation-range-start
- Short, readable CSS that the next developer will understand at a glance
- Easing works per element, as you would expect
- Adding or removing items needs no changes
- Limited to scroll or view progress as the driver
A custom progress formula
- Can, in theory, be driven by any value, not just scrolling
- Treats the whole group as one coordinated effect
- Much harder to read, debug and hand over
- Easing has to be rebuilt by hand
That first point in the second list is the one genuinely interesting idea. Imagine an animation that advances as someone fills in a form, works through a quiz or adds items to a basket. CSS has no native way to link an animation to inputs like those yet, so a custom formula may be the closest option for now. For a simple scroll reveal, though, it is overkill.
Whichever route you take, wrap decorative motion in a prefers-reduced-motion check so visitors who find movement uncomfortable still see the finished content. Browser support for these newer features is still uneven, so treat them as an enhancement and make sure the page reads perfectly without them.
For most small business sites, a gentle staggered reveal on a key statistic or call to action is plenty. So, where on your own website would a little scroll-triggered movement actually help a visitor, rather than just decorate the page?










