Le produit possède désormais quatre boutons bleus. L’un a des coins de 6 pixels, l’autre de 8, le troisième affiche un indicateur de chargement et le quatrième peut être cliqué deux fois pendant l’enregistrement. Personne ne l’a décidé. Chaque bouton est simplement né dans une fonctionnalité différente, à quelques semaines d’intervalle.
Faut-il arrêter la feuille de route et construire un design system ? Pas forcément. Pour un MVP de quatre écrans, harmoniser les composants existants suffit souvent. Pour un SaaS utilisé par plusieurs équipes, décliné sur des dizaines de parcours et développé par plusieurs personnes, l’absence de règles finit en revanche par facturer la même décision à chaque fonctionnalité.
En résumé : investissez quand les incohérences ralentissent réellement la conception, le développement, les tests ou l’usage. Commencez par les composants les plus répétés, reliez design et code, documentez les décisions utiles et mesurez l’adoption. Un design system est un produit interne vivant. Ce n’est ni un fichier Figma bien rangé, ni une cathédrale de composants construite avant d’avoir des utilisateurs.
Un design system, trois couches
Le terme mélange souvent plusieurs choses.
Les fondations définissent couleurs, typographies, espacements, rayons, ombres, mouvements et principes d’accessibilité. Elles forment le vocabulaire visuel.
Les composants combinent ces fondations en éléments réutilisables : bouton, champ, tableau, modale, notification, navigation. Ils existent dans le design et dans le code, avec états et comportements.
Les règles d’usage expliquent quand choisir un composant, comment écrire ses libellés, quels cas éviter et comment composer une page. Elles empêchent qu’un même outil soit utilisé correctement de vingt façons incompatibles.
Une bibliothèque de composants sans règles n’est pas tout à fait un système. Un guide graphique sans code laisse chaque développeur réinterpréter les maquettes. Un paquet de composants sans représentation côté design crée le problème inverse.
Le design system relie ces couches pour rendre les décisions reproductibles.
Le but n’est pas que tout se ressemble
La cohérence n’est pas l’uniformité. Une page de paiement, un écran de supervision et un onboarding n’ont pas la même densité ni la même tension. Ils peuvent pourtant partager les mêmes règles de couleur, de contraste, de feedback et de navigation.
Le système garantit que :
- une action principale se reconnaît ;
- une erreur est expliquée de façon cohérente ;
- le clavier fonctionne partout ;
- les espacements suivent un rythme ;
- les états chargement, vide et désactivé sont prévus ;
- les mêmes mots désignent les mêmes choses.
Il ne doit pas interdire toute composition nouvelle. Si chaque besoin inédit exige de contourner le système, celui-ci devient un règlement de copropriété. S’il n’encadre rien, il devient une boîte de Lego renversée.
Le bon niveau de contrainte préserve les invariants utiles et laisse varier la structure selon le problème.
Quand il est trop tôt
Un produit qui cherche encore son usage principal change vite. Les parcours sont supprimés, les écrans fusionnent, le modèle économique bouge. Construire cinquante composants robustes à ce moment revient à industrialiser une hypothèse.
Il est probablement trop tôt si :
- moins d’une dizaine d’écrans existent ;
- une seule personne conçoit et développe ;
- le produit n’a pas encore de pilotes ;
- les flux principaux changent chaque semaine ;
- aucune répétition douloureuse n’apparaît ;
- la survie dépend davantage de la validation du besoin que de la vitesse de livraison.
Le guide du MVP SaaS place l’apprentissage avant l’exhaustivité. Utilisez un socle technique cohérent, quelques variables et composants de base, mais ne suspendez pas le lancement pour définir la hauteur idéale de huit tailles de cartes.
« Pas de design system complet » ne signifie pas « aucune discipline ». Décidez au moins typographie, couleurs, espacements et composants élémentaires. La différence tient au niveau d’investissement et de promesse de stabilité.
Les signaux du bon moment
Le besoin apparaît souvent par accumulation.
Les mêmes problèmes reviennent
À chaque fonctionnalité, l’équipe rediscute la modale, le tableau, le sélecteur de date et les messages d’erreur. Le temps n’est pas consacré au problème métier, mais à des décisions déjà prises ailleurs.
Les incohérences atteignent les utilisateurs
Une action s’appelle « Enregistrer », « Valider » ou « Confirmer » selon les pages. Le bouton retour ne revient pas toujours. Les filtres se réinitialisent ici mais pas là. Cette incohérence augmente l’apprentissage et les erreurs.
Plusieurs personnes contribuent
Avec un designer et un développeur, la mémoire partagée masque l’absence de documentation. Avec trois équipes, les interprétations divergent. Le système devient un outil de coordination.
Le produit se décline
Portail client, back-office, application mobile, marque blanche ou plusieurs offres partagent des fondations. Sans architecture, chaque surface dérive et les corrections se répètent.
La dette ralentit les changements
Modifier la couleur d’erreur ou le comportement des champs nécessite de retrouver trente implémentations. Le coût d’une amélioration transversale révèle le besoin de centralisation.
Le bon moment arrive lorsque cette répétition coûte davantage que sa réduction, pas lorsque le sujet devient à la mode.
Auditez avant de dessiner
Commencez par l’existant. Capturez les écrans et inventoriez :
- couleurs proches mais différentes ;
- tailles et graisses de texte ;
- espacements ;
- boutons ;
- champs et validations ;
- tableaux ;
- cartes ;
- modales ;
- notifications ;
- états vides ;
- chargements ;
- navigation ;
- comportements responsive ;
- problèmes d’accessibilité.
Regroupez les variantes visuellement semblables. Puis cherchez pourquoi elles diffèrent. Certaines incohérences sont accidentelles. D’autres répondent à un contexte réel : un bouton compact dans un tableau n’est pas forcément le même que l’action principale d’une page.
Mesurez la fréquence et l’impact. Le composant utilisé sur soixante pages mérite plus d’attention que le sélecteur rare d’un écran d’administration.
Associez les tickets connus : erreurs d’usage, bugs récurrents, difficultés mobiles, lenteur de développement. L’audit ne doit pas seulement produire une galerie des horreurs ; il doit relier les écarts à un coût.
Commencez par les fondations
Les variables de design, souvent appelées tokens, donnent un nom aux décisions :
color-action-primaryplutôt que#2E8BFF;space-4plutôt que16pxcopié partout ;radius-controlplutôt que des arrondis libres ;text-body-smplutôt qu’un assemblage local de taille et d’interligne.
Les noms décrivent l’intention quand elle existe. Une variable blue-500 peut être utile dans la palette, mais les composants gagnent à utiliser une variable sémantique : action, texte secondaire, bordure, danger.
Préparez les thèmes sans les surconcevoir. Si le mode sombre ou la marque blanche est un besoin réel, séparez valeurs et rôles. Sinon, ne construisez pas neuf thèmes imaginaires.
Les fondations couvrent aussi :
- grille responsive ;
- largeurs de contenu ;
- ordre de focus ;
- durée et courbe des animations ;
- icônes ;
- règles de rédaction.
Une couleur cohérente n’aide pas si l’utilisateur ne comprend pas « Exécuter la mutation ».
Construisez les composants selon l’usage
Choisissez d’abord cinq à dix composants très utilisés :
- bouton ;
- lien ;
- champ ;
- sélection ;
- message de validation ;
- notification ;
- modale ;
- tableau ou liste ;
- navigation ;
- état vide.
Pour chacun, documentez :
- objectif ;
- anatomie ;
- variantes ;
- tailles réellement nécessaires ;
- états ;
- comportement clavier ;
- responsive ;
- contenu ;
- exemples ;
- cas à éviter.
Les états sont souvent la partie oubliée. Un champ n’existe pas seulement au repos : focus, rempli, invalide, désactivé, lecture seule, chargement. Un bouton peut être en attente et empêcher une seconde soumission. Une table peut être vide, partiellement chargée ou en erreur.
Le composant doit couvrir les situations réelles sans devenir une usine à options. Une API avec quarante propriétés permet tout, donc n’explique plus rien.
Design et code doivent raconter la même histoire
Le fichier de design peut afficher un composant parfait tandis que l’application utilise une version vieille de six mois. À l’inverse, le code évolue et les maquettes continuent d’assembler des éléments disparus.
Établissez un lien :
- mêmes noms ;
- mêmes variantes ;
- mêmes états ;
- mêmes variables ;
- responsable identifié ;
- version ou historique ;
- exemples exécutables ;
- processus de mise à jour.
Le designer doit savoir ce qui existe en production. Le développeur doit comprendre l’intention, pas seulement les valeurs. Une documentation générée ou un catalogue de composants exécutables aide à tester la réalité.
Dans un développement SaaS sur mesure, ce pont raccourcit les revues. On discute de la fonction spécifique au produit au lieu de vérifier pour la quinzième fois la hauteur du bouton.
L’accessibilité n’est pas une phase finale
Centraliser un composant multiplie ses qualités, mais aussi ses défauts. Un bouton accessible améliore toutes les pages. Une modale qui piège mal le focus diffuse le problème partout avec une efficacité industrielle.
Vérifiez dès la conception :
- contraste ;
- navigation clavier ;
- focus visible ;
- libellés ;
- annonces aux technologies d’assistance ;
- taille des cibles ;
- zoom ;
- réduction des animations ;
- ordre logique ;
- erreurs compréhensibles.
Les tests automatiques détectent une partie des problèmes. Les parcours au clavier et avec lecteurs d’écran demandent une vérification humaine.
Documentez les responsabilités. Le composant garantit par exemple le focus et les attributs structurels ; la personne qui l’utilise doit fournir un titre explicite. Sans cette frontière, chacun suppose que l’autre a réglé le sujet.
Le contenu fait partie du système
Une interface cohérente utilise un vocabulaire stable.
Décidez :
- tutoiement ou vouvoiement ;
- verbes des actions ;
- formulation des confirmations ;
- structure des erreurs ;
- format des dates et nombres ;
- ton des états vides ;
- termes métier ;
- place de l’aide.
« Une erreur est survenue » confirme surtout que l’ordinateur connaît la situation. Dites ce qui n’a pas fonctionné, ce qui a été conservé et ce que l’utilisateur peut faire.
Les libellés doivent décrire l’action : « Envoyer le devis » vaut mieux que « Valider ». Une action destructive nomme sa conséquence. Une notification évite de célébrer bruyamment chaque petite sauvegarde.
Le guide de contenu peut rester court. Une page avec des exemples réels apporte davantage qu’un manifeste de quarante principes jamais relu.
Tables, formulaires et filtres : là où le SaaS vit vraiment
Les vitrines montrent souvent les boutons et les cartes. Les logiciels métier vivent dans les tableaux, formulaires, recherches et états.
Pour une table, définissez :
- densité ;
- alignement des nombres ;
- tri ;
- filtres ;
- sélection ;
- pagination ;
- actions ;
- responsive ;
- chargement ;
- absence de résultats ;
- préférences conservées.
Pour un formulaire :
- regroupement ;
- largeur ;
- champs obligatoires ;
- aide ;
- validation ;
- sauvegarde ;
- abandon ;
- données partielles ;
- erreurs serveur ;
- édition concurrente.
Pour les filtres, réfléchissez au partage et à la persistance. Dans un logiciel authentifié, une URL représentant la vue peut être très utile. Sur les pages publiques, ces paramètres doivent au contraire être maîtrisés pour éviter les variantes indexables inutiles. Le composant ne peut pas décider seul : le contexte de routage compte.
Un système qui soigne ces composants fait gagner davantage qu’une collection de cartes élégantes, parce qu’il touche les gestes répétés toute la journée.
Ne construisez pas un composant pour chaque exception
Lorsqu’une équipe rencontre un besoin inédit, trois réponses existent :
- composer des éléments existants ;
- étendre un composant ;
- créer un nouveau modèle.
Commencez par comprendre si le problème se répétera. Une mise en page unique peut rester locale. Une interaction appelée à apparaître dans plusieurs domaines mérite une solution partagée.
Évitez la généralisation immédiate. Le premier cas ne révèle pas toujours la bonne abstraction. Construisez une version locale propre, observez un second usage, puis extrayez ce qui est commun. C’est le même principe que pour le choix entre no-code et sur-mesure : consolider lorsque la répétition est réelle.
À l’inverse, ne copiez pas cinq fois en attendant la révélation parfaite. Une règle simple peut aider : au troisième usage, une revue est obligatoire.
Organisez la contribution
Un design system sans mode de contribution devient soit figé, soit contourné.
Définissez :
- comment proposer un besoin ;
- quelles informations fournir ;
- qui évalue ;
- comment prototyper ;
- quels tests sont attendus ;
- qui valide design et code ;
- comment annoncer un changement ;
- combien de temps une ancienne version reste disponible.
Le processus doit être proportionné. Une correction de contraste ne nécessite pas un comité mensuel. Une modification du comportement de tous les formulaires mérite davantage de contrôle.
Acceptez les contributions des équipes produit. L’équipe centrale, s’il y en a une, ne peut pas découvrir seule tous les contextes. Elle assure la cohérence, la qualité et la documentation ; elle ne devient pas un guichet qui bloque chaque livraison.
Versionner sans paralyser
Les composants évoluent. Une propriété est renommée, un espacement change, un comportement est corrigé.
Utilisez :
- notes de version ;
- changements dépréciés avant suppression ;
- outils ou instructions de migration ;
- recherche des usages ;
- tests visuels et fonctionnels ;
- calendrier prévisible pour les ruptures.
Toutes les modifications ne doivent pas être cassantes. Une amélioration interne qui préserve l’interface peut être diffusée directement. Pour une rupture, montrez le gain et le coût.
Dans un monolithe, modifier tous les usages dans la même évolution est possible. Dans plusieurs applications ou paquets, la compatibilité demande plus de discipline. Choisissez l’architecture selon la réalité de l’organisation, pas selon le prestige du mot « package ».
Le soin invisible qui fait durer un logiciel vaut ici aussi : versionner, tester, documenter et surveiller. Le design system est du code de production, pas une annexe artistique.
Combien cela coûte
Le coût dépend moins du nombre de boutons que de la dispersion existante et du niveau de maturité attendu.
Les postes sont :
- audit ;
- décisions de fondation ;
- conception des composants ;
- implémentation ;
- accessibilité ;
- documentation ;
- tests ;
- migration des écrans ;
- gouvernance ;
- maintenance.
Une petite équipe peut consolider fondations et dix composants en quelques semaines, en parallèle d’un produit. Une suite multi-application avec plusieurs marques, technologies et équipes représente un chantier beaucoup plus important.
Ne cherchez pas un prix universel au composant. Une table de données riche coûte davantage qu’un badge. La migration peut dépasser la création si le produit contient beaucoup d’implémentations divergentes.
Le calcul honnête ressemble à celui du prix d’un logiciel sur mesure : investissement initial, coût de maintenance, temps économisé et risque réduit sur plusieurs années.
Calculer le retour sur investissement
Mesurez avant de commencer.
Temps de conception
Combien de temps faut-il pour produire et valider un écran courant ? Quelle part concerne des décisions déjà prises ?
Temps de développement
Combien d’heures sont consacrées à recréer, adapter et corriger les éléments communs ?
Défauts
Combien de tickets concernent incohérence, responsive, accessibilité ou comportement de composants ?
Vitesse de changement transversal
Combien coûte aujourd’hui la modification d’un style, d’un message ou d’une interaction sur tout le produit ?
Adoption
Quelle proportion des nouvelles fonctionnalités utilise le système ? Combien de variantes locales apparaissent ?
Résultat utilisateur
Les parcours deviennent-ils plus rapides, plus compréhensibles, plus accessibles ? La cohérence n’a de valeur que si elle améliore l’usage ou la capacité à livrer.
Ne promettez pas « 40 % plus vite » sans point de départ. Comparez quelques fonctionnalités similaires avant et après. Prenez en compte le coût de contribution au système, pas seulement les économies. Les mêmes règles que pour un dashboard métier qui aide vraiment à décider s’appliquent : une métrique, une définition, une source et l’action qu’elle éclaire.
Le ROI augmente avec la fréquence de réutilisation. Un composant utilisé une fois peut être très bon ; il ne rembourse pas une infrastructure complète.
Migrez par opportunité, pas par peinture générale
Refaire tous les écrans avant de livrer une nouvelle valeur transforme le design system en tunnel.
Trois approches peuvent cohabiter :
- nouveaux écrans obligatoirement basés sur le système ;
- écrans modifiés migrés au passage ;
- parcours très critiques traités dans des lots dédiés.
Évitez une application moitié ancienne moitié nouvelle dans le même parcours pendant trop longtemps. Priorisez les zones où l’incohérence gêne l’utilisateur.
La méthode de refonte sans arrêter l’activité s’applique : tranches verticales, observation, coexistence maîtrisée et critère de fin. Conservez une liste des anciens composants et leur remplacement.
Les corrections opportunistes ne doivent pas devenir invisibles. Suivez la couverture et les exceptions pour savoir si la migration progresse réellement.
Les pièges classiques
Construire une vitrine
Le site documentaire est superbe, mais les composants sont difficiles à utiliser. L’adoption restera faible. Priorisez l’API, les exemples et l’intégration.
Copier un système célèbre
Le design system d’une grande entreprise répond à son organisation, ses plateformes et ses contraintes. Inspirez-vous des principes, pas du volume. Vous n’avez peut-être pas besoin de ses 72 composants.
Tout rendre configurable
Chaque option augmente les combinaisons, les tests et la documentation. Préférez des choix opinionnés correspondant au produit.
Oublier les cas réels
Les exemples « John Doe » sur une carte vide ne testent ni les longs contenus, ni les erreurs, ni les grands volumes.
Imposer sans accompagner
Une règle sans explication ni aide produit du contournement. Montrez le bénéfice, fournissez des migrations et écoutez les blocages.
Ne prévoir personne pour maintenir
Après le lancement, le produit évolue. Sans responsabilité et temps alloué, le système devient une seconde couche de dette, mais mieux documentée.
Une feuille de route en quatre étapes
1. Observer
Auditez l’existant, mesurez les répétitions, interrogez designers, développeurs, support et utilisateurs. Choisissez les résultats attendus.
2. Fonder
Définissez variables essentielles, accessibilité, contenu et architecture technique. Construisez les composants les plus fréquents avec leurs états réels.
3. Prouver
Utilisez le système sur un nouveau parcours et sur la migration d’un parcours existant. Mesurez temps, défauts et compréhension. Corrigez le modèle de contribution.
4. Étendre
Ajoutez les composants tirés par les besoins, migrez selon les opportunités et retirez les anciennes implémentations. Publiez les changements et suivez l’adoption.
Chaque étape produit quelque chose d’utilisable. Il n’existe pas un jour magique où le design system devient « terminé ».
La checklist du bon investissement
Avant de lancer le chantier :
- les incohérences ont été inventoriées ;
- leur coût est observable ;
- plusieurs équipes ou surfaces réutiliseront le travail ;
- une personne porte design et une autre l’implémentation, même si elles collaborent étroitement ;
- les composants prioritaires viennent des usages ;
- l’accessibilité est incluse ;
- la documentation vise l’action ;
- un parcours pilote est choisi ;
- la migration est progressive ;
- des métriques de succès existent ;
- du temps de maintenance est prévu.
Si le produit n’a pas encore validé son usage central, réduisez l’ambition. Si trente écrans réinventent les mêmes interactions, attendre n’économise rien : vous payez déjà le système, simplement sous forme de répétition et de bugs.
Un accord vivant, pas un musée
Le design system crée un accord entre les personnes qui imaginent, construisent, testent et utilisent le produit. Il rend les choix courants faciles, les changements transversaux possibles et la qualité reproductible.
Son meilleur signe de réussite n’est pas le nombre de composants. C’est la diminution des discussions inutiles et l’amélioration des discussions importantes. On ne débat plus du rayon de la carte ; on débat de l’information qui aide réellement le client.
Votre SaaS possède huit façons d’afficher une erreur et personne ne sait laquelle est la bonne ? Montrons-nous trois écrans, pas votre palette. Trois écrans réels suffisent souvent à voir si vous avez besoin d’un design system, d’un bon ménage ou simplement d’un bouton correctement partagé.
Cet article vous intéresse ? Allons plus loin ensemble.
Faisons évoluer votre SaaS sans le déformer