Sections sticky et scrollytelling : le guide complet

Maîtrisez les techniques de position sticky, Intersection Observer et scroll-timeline pour créer des expériences de scroll narratives et immersives qui captiveront vos utilisateurs.

Introduction

Le scrollytelling est une technique de narration visuelle qui utilise le scroll pour révéler progressivement une histoire ou des informations. Combinée avec la propriété CSS position: sticky, elle permet de créer des expériences web immersives dignes des plus grands sites éditoriaux comme le New York Times ou Bloomberg.

Dans ce guide complet, nous allons explorer en profondeur les techniques fondamentales et avancées pour maîtriser ces effets. Vous apprendrez à utiliser position sticky, l'Intersection Observer API, et même les nouvelles scroll-driven animations natives de CSS.

💡
Pourquoi le scrollytelling ?

Des études montrent que les contenus interactifs avec scrollytelling ont un taux d'engagement 3x supérieur aux contenus statiques. C'est particulièrement efficace pour la visualisation de données et les articles longs.

Position sticky expliquée

La propriété position: sticky est le fondement de nombreux effets de scrollytelling. Elle permet à un élément de basculer entre un comportement relative et fixed en fonction de la position de scroll.

Le fonctionnement de base

Un élément sticky commence par se comporter comme un élément positionne relativement. Puis, lorsqu'il atteint un seuil défini (par exemple top: 0), il devient "colle" à cette position comme un élément fixed, jusqu'à ce que son conteneur parent sorte de la vue.

Je reste colle en haut !

Faites défiler pour voir l'effet sticky en action. L'élément violet reste colle en haut du conteneur pendant que vous scrollez.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Continuez à scroller pour voir l'élément sticky suivre le défilement jusqu'à la fin du conteneur.

sticky-basic.css
/* Conteneur qui definit la zone de scroll */
.sticky-container {
    position: relative;
    height: 300vh; /* Grande hauteur pour le scroll */
}

/* Element qui reste colle */
.sticky-element {
    position: sticky;
    top: 20px; /* Distance depuis le haut */
    background: linear-gradient(135deg, #6366f1, #8b5cf6);
    padding: 24px 32px;
    border-radius: 12px;
}

Points importants

  • Le parent doit avoir une hauteur : sticky ne fonctionne que si le conteneur parent a suffisamment de hauteur pour permettre le scroll
  • Pas de overflow: hidden sur les ancêtres : cette propriété peut casser le comportement sticky
  • Spécifiez top, bottom, left ou right : au moins une de ces propriétés doit être définie
  • Fonctionne avec tous les navigateurs modernes : support à 95%+ sans préfixe
⚠️
Piège courant

Si votre élément sticky ne fonctionne pas, vérifiez que vous n'avez pas overflow: hidden, overflow: auto ou overflow: scroll sur un élément parent entre le sticky et le viewport.

Scrollytelling avec Intersection Observer

L'API Intersection Observer permet de détecter quand un élément entre ou sort du viewport (ou d'un autre élément). C'est l'outil idéal pour déclencher des animations ou des changements d'état lors du scroll.

Demo interactive

Scrollez dans la zone de droite pour voir le visuel changer en fonction de l'étape active :

1

Étape 1 : Introduction

Le cercle commence dans sa forme initiale, avec un gradient violet classique.

Étape 2 : Transformation

Le cercle s'agrandit et prend une forme arrondie carrée avec un nouveau gradient.

Étape 3 : Rotation

L'élément pivote et change de couleur vers des tons cyan-vert.

Étape 4 : Conclusion

Retour à une forme circulaire avec des couleurs chaudes orange-rouge.

scrollytelling.js
// Selection des elements
const steps = document.querySelectorAll('.scroll-step');
const visual = document.querySelector('.visual-circle');

// Configuration de l'observer
const observerOptions = {
    root: document.querySelector('.scrollytelling-steps'),
    rootMargin: '-30% 0px -30% 0px', // Zone de detection
    threshold: 0
};

// Callback de l'observer
const observerCallback = (entries) => {
    entries.forEach(entry => {
        if (entry.isIntersecting) {
            // Recuperer le numero de l'etape
            const step = entry.target.dataset.step;

            // Mettre a jour le visuel
            visual.setAttribute('data-step', step);
            visual.textContent = step;

            // Mettre a jour les classes actives
            steps.forEach(s => s.classList.remove('active'));
            entry.target.classList.add('active');
        }
    });
};

// Creation et activation de l'observer
const observer = new IntersectionObserver(observerCallback, observerOptions);
steps.forEach(step => observer.observe(step));

Comprendre les options

  • root : l'élément de référence (null = viewport)
  • rootMargin : marges pour étendre ou réduire la zone de détection
  • threshold : pourcentage de visibilité pour déclencher le callback (0 à 1)

Scroll-timeline CSS natif

Les scroll-driven animations sont une nouvelle spécification CSS qui permet de lier directement des animations au scroll, sans JavaScript ! C'est la méthode la plus performante car tout se passe sur le GPU.

📊
Support navigateur

En 2025, scroll-timeline est supporté par Chrome, Edge et Opera. Firefox et Safari sont en cours d'implementation. Utilisez une détection de fonctionnalité pour le fallback.

scroll-timeline.css
/* Definition de la timeline de scroll */
@scroll-timeline scroll-progress {
    source: auto; /* Element scrollable (auto = ancetre) */
    orientation: vertical;
    scroll-offsets: 0%, 100%;
}

/* Animation liee au scroll */
.progress-bar {
    animation: fillProgress linear;
    animation-timeline: scroll-progress;
}

@keyframes fillProgress {
    from { width: 0%; }
    to { width: 100%; }
}

Nouvelle syntaxe simplifiée

La spécification a évolué vers une syntaxe plus simple avec animation-timeline: scroll() :

scroll-animation-modern.css
/* Barre de progression liee au scroll de la page */
.reading-progress {
    position: fixed;
    top: 0;
    left: 0;
    height: 4px;
    background: linear-gradient(90deg, #6366f1, #8b5cf6);
    transform-origin: left;

    /* Animation liee au scroll */
    animation: scaleProgress linear forwards;
    animation-timeline: scroll(root);
}

@keyframes scaleProgress {
    from { transform: scaleX(0); }
    to { transform: scaleX(1); }
}

/* Animation liee a la visibilite d'un element (view timeline) */
.fade-in-element {
    animation: fadeIn linear forwards;
    animation-timeline: view();
    animation-range: entry 0% cover 40%;
}

@keyframes fadeIn {
    from {
        opacity: 0;
        transform: translateY(50px);
    }
    to {
        opacity: 1;
        transform: translateY(0);
    }
}

Exemples pratiques avancés

Voyons maintenant des cas d'usage concrets et plus élaborés.

1. Indicateur de progression de lecture

Une barre qui montre ou vous en êtes dans la lecture de l'article :

Scrollez cette page pour voir la progression
reading-progress.js
// Indicateur de progression de lecture
function initReadingProgress() {
    const progressBar = document.querySelector('.progress-fill');
    const article = document.querySelector('article');

    function updateProgress() {
        // Calculer la position de scroll
        const scrollTop = window.scrollY;
        const docHeight = article.offsetHeight - window.innerHeight;
        const progress = (scrollTop / docHeight) * 100;

        // Limiter entre 0 et 100
        const clampedProgress = Math.min(100, Math.max(0, progress));

        // Mettre a jour la largeur
        progressBar.style.width = clampedProgress + '%';
    }

    // Ecouter le scroll avec throttling
    let ticking = false;
    window.addEventListener('scroll', () => {
        if (!ticking) {
            requestAnimationFrame(() => {
                updateProgress();
                ticking = false;
            });
            ticking = true;
        }
    });
}

2. Timeline verticale animée

Un composant de timeline qui s'anime à mesure que l'utilisateur scrolle :

Phase 1 : Recherche

Analyse des besoins utilisateurs

Phase 2 : Design

Création des maquettes UI/UX

Phase 3 : Développement

Implementation technique

Phase 4 : Lancement

Déploiement en production

animated-timeline.html
<!-- Structure HTML de la timeline -->
<div class="timeline-track">
    <div class="timeline-item">
        <div class="timeline-dot"></div>
        <div class="timeline-content">
            <h4>Titre de l'etape</h4>
            <p>Description de l'etape</p>
        </div>
    </div>
    <!-- Autres items... -->
</div>

<style>
.timeline-track {
    position: relative;
    padding-left: 40px;
}

/* Ligne verticale */
.timeline-track::before {
    content: '';
    position: absolute;
    left: 12px;
    top: 0;
    bottom: 0;
    width: 2px;
    background: rgba(255,255,255,0.1);
}

.timeline-dot {
    position: absolute;
    left: -34px;
    width: 16px;
    height: 16px;
    border-radius: 50%;
    background: #12121a;
    border: 2px solid rgba(255,255,255,0.1);
    transition: all 0.3s ease;
}

/* Etat actif */
.timeline-item.active .timeline-dot {
    background: #6366f1;
    border-color: #6366f1;
    box-shadow: 0 0 20px rgba(99,102,241,0.5);
}
</style>

3. Parallaxe avec sticky

Combiner sticky avec des transformations pour créer un effet de parallaxe :

sticky-parallax.css
/* Section avec parallaxe sticky */
.parallax-section {
    height: 200vh;
    position: relative;
}

.parallax-background {
    position: sticky;
    top: 0;
    height: 100vh;
    overflow: hidden;
}

.parallax-image {
    width: 100%;
    height: 120%;
    object-fit: cover;
    will-change: transform;
}

.parallax-content {
    position: absolute;
    bottom: 0;
    left: 0;
    right: 0;
    padding: 100vh 20px 50px;
    background: linear-gradient(
        to bottom,
        transparent,
        rgba(10,10,15,0.8) 30%,
        #0a0a0f
    );
}

Bonnes pratiques

Pour créer des expériences de scrollytelling performantes et accessibles, suivez ces recommandations :

Performance

  • Utilisez requestAnimationFrame pour les animations liées au scroll en JavaScript
  • Privilégiez transform et opacity pour les animations (propriétés qui ne déclenchent pas de reflow)
  • Activez will-change avec parcimonie sur les éléments animés
  • Préférez scroll-timeline CSS quand c'est possible (rendu GPU)
  • Limitez le nombre d'observers : un seul observer peut surveiller plusieurs éléments
performance-tips.js
// Optimisation avec requestAnimationFrame
let rafId = null;
let lastScrollY = 0;

function onScroll() {
    lastScrollY = window.scrollY;

    if (!rafId) {
        rafId = requestAnimationFrame(updateAnimations);
    }
}

function updateAnimations() {
    // Vos animations ici
    // Utilisez transform au lieu de top/left
    element.style.transform = `translateY(${lastScrollY * 0.5}px)`;

    rafId = null;
}

window.addEventListener('scroll', onScroll, { passive: true });

Accessibilité

  • Respectez prefers-reduced-motion : désactivez ou réduisez les animations
  • Le contenu doit être lisible sans JS : progressive enhancement
  • Testez au clavier : le focus doit suivre le contenu visible
  • Utilisez aria-live pour les changements dynamiques importants
accessibility.css
/* Desactiver les animations pour les utilisateurs sensibles */
@media (prefers-reduced-motion: reduce) {
    * {
        animation-duration: 0.01ms !important;
        animation-iteration-count: 1 !important;
        transition-duration: 0.01ms !important;
        scroll-behavior: auto !important;
    }

    /* Les elements sticky restent fonctionnels */
    .sticky-element {
        position: sticky; /* conserve */
    }
}

UX et Design

  • Donnez des indices visuels : l'utilisateur doit comprendre qu'il peut scroller
  • Évitez le scroll jacking : ne modifiez pas la vitesse de scroll native
  • Testez sur mobile : le comportement peut différer significativement
  • Prévoyez des fallbacks : le contenu doit être accessible sans les effets
💡
Conseil de pro

Utilisez le DevTools pour profiler vos animations. Dans Chrome, ouvrez Performance > Record pendant que vous scrollez, puis analysez les "Frames" pour détecter les chutes de FPS.

Pourquoi position: sticky ne fonctionne pas

C'est le problème le plus fréquent avec position: sticky : la propriété est bien appliquée, le navigateur la supporte, et pourtant l'élément ne colle pas. Dans la quasi-totalité des cas, la cause n'est pas dans l'élément lui-même mais dans un de ses parents.

  • Un parent a overflow: hidden, auto ou scroll — c'est la cause n°1. Sticky se rattache au plus proche ancêtre defilable : si un parent a un overflow différent de visible, l'élément colle à ce conteneur au lieu de la fenêtre, et le comportement parait mort. Remontez l'arbre DOM et retirez l'overflow, ou sortez l'élément de ce parent.
  • Aucune valeur de décalage — position: sticky seul ne fait rien. Il faut au moins top, bottom, left ou right. Un simple top: 0 suffit à activer l'effet.
  • Le parent n'est pas plus haut que l'élément — sticky ne peut coller que dans les limites de son parent direct. Si le parent fait la même hauteur que l'élément, il n'y a aucune marge de défilement et rien ne bouge.
  • Le parent est un conteneur flex ou grid — par défaut, align-items: stretch étire l'enfant sur toute la hauteur du parent, ce qui supprime la marge de défilement. Passez le parent en align-items: flex-start.
  • Une hauteur fixe sur un ancêtre — une height figée qui coupe le contenu produit le même effet qu'un overflow cache.
💡
Diagnostic en 10 secondes

Collez ceci dans la console : let e=document.querySelector('.mon-element');while(e=e.parentElement){const o=getComputedStyle(e).overflow;if(o!=='visible')console.log(e,o)}. Chaque élément affiche est un parent qui casse le sticky.

Si après ces vérifications l'effet ne convient toujours pas, c'est peut-être que sticky n'est pas le bon outil : pour une navigation qui s'aimante section par section, CSS Scroll Snap donne un résultat plus net et reste entièrement déclaratif.

Conclusion

Le scrollytelling et les sections sticky sont des outils puissants pour créer des expériences web mémorables. En combinant position: sticky, l'Intersection Observer et les nouvelles scroll-driven animations, vous disposez de tout l'arsenal nécessaire pour rivaliser avec les meilleurs sites éditoriaux.

Les points clés à retenir :

  • position: sticky est la base de nombreux effets de scroll
  • Intersection Observer permet de déclencher des actions sans impact sur les performances
  • scroll-timeline CSS est l'avenir des animations liées au scroll
  • La performance et l'accessibilité doivent toujours être prioritaires

N'hésitez pas à expérimenter et à combiner ces techniques. Les possibilités sont infinies !

🎨
Allez plus loin

Découvrez nos templates de scrollytelling prêts à l'emploi dans la bibliothèque Effect.Labs, avec des effets sophistiques et du code optimisé.

70+ effets Scroll prêts à copier

Aperçu live, customizer, code vanilla — zéro dépendance.

Voir les effets Scroll

Les effets de cet article dans le catalogue

Les mêmes techniques, prêtes à copier : aperçu en direct, réglages et code complet sur la page de leur catégorie.

À lire aussi

Trois articles proches pour aller plus loin.