Gérer les versions de design sans être développeur
Les développeurs ont Git. Les designers ont « Homepage_FINAL_v4_revised_APPROVED.png ». Comment mettre de l’ordre dans vos versions, sans ligne de commande.

Le cimetière des noms de fichiers
Le disque dur de chaque designer raconte la même histoire :
Homepage_v1.png
Homepage_v2.png
Homepage_v2_revised.png
Homepage_FINAL.png
Homepage_FINAL_v2.png
Homepage_FINAL_FINAL_USE_THIS_ONE.png
C’est drôle, jusqu’au jour où un client valide la mauvaise version alors que vous avez déjà envoyé les fichiers à l’impression.
Pourquoi la gestion des versions de design est difficile
Les développeurs ont résolu ce problème il y a des décennies avec Git. Chaque modification est suivie, on peut revenir en arrière à tout moment, et tout le monde travaille à partir de la même source de vérité. Mais la plupart des outils de gestion de versions pour le design exigent soit des connaissances techniques, soit de s’enfermer dans une application de design précise.
La réalité de la plupart des freelances et des petites agences :
- Les fichiers vivent dans des dossiers aux conventions de nommage créatives.
- Les clients voient ce que vous leur envoyez. Rien ne garantit qu’ils regardent la dernière version.
- Les retours se retrouvent orphelins. Les commentaires laissés par un client sur la v2 ne suivent pas quand vous envoyez la v3.
- Il n’y a pas de journal des modifications. Si quelqu’un demande « qu’est-ce qui a changé entre le tour 2 et le tour 3 ? », vous reconstituez l’historique de mémoire.
Cet article explique pourquoi cela arrive et ce que cela vous coûte quand ça tourne mal. Il montre ensuite comment prendre une habitude de versionnage qui ne demande pas d’apprendre la ligne de commande.
Emprunter les concepts des développeurs, sans la ligne de commande
Pas besoin de Git pour profiter des idées qui le sous-tendent. Trois concepts se transposent sans difficulté, et aucun ne demande de taper la moindre commande.
Une version est un instantané, pas un remplacement. Dans Git, un commit n’efface pas le code qui le précède. Il ajoute un nouveau point dans l’historique, auquel on peut toujours revenir. L’équivalent en design est simple : chaque tour de travail envoyé à un client doit être son propre instantané, conservé à côté des précédents, et non enregistré par-dessus. Si vous écrasez Homepage_FINAL.png avec vos dernières modifications, vous vous privez de la possibilité de répondre à « à quoi ressemblait vraiment le tour 2 ? ».
Un diff montre ce qui a changé. Les développeurs relisent les pull requests à partir d’un diff, c’est-à-dire les lignes précises qui ont changé d’un commit à l’autre. Les designers en disposent rarement d’office, il faut donc le fabriquer. Cela peut être aussi simple qu’une vue côte à côte de deux versions, ou une courte note sous chaque envoi expliquant ce qui a bougé. L’idée est la même : ne faites pas chercher au client ce qui est différent. Montrez-le-lui.
Une branche est un tour d’exploration qui n’a pas encore été accepté. Quand un développeur ouvre une branche, il dit : « ceci est une proposition, pas encore fusionnée dans la ligne principale. » Un tour de design en cours, c’est exactement la même chose. Il ne doit pas être présenté au client comme le nouveau défaut tant qu’il ne l’a pas réellement examiné et accepté. Mélanger « voici une idée que j’essaie » et « voici le design validé actuel » est l’une des façons les plus courantes dont les équipes perdent de vue ce qui fait foi.
Rien de tout cela n’exige un client Git, un terminal ou une formation en informatique. Il faut traiter les versions comme un historique qui s’enrichit plutôt que comme un fichier unique qu’on modifie, et disposer d’un moyen de faire apparaître ce qui a changé de l’une à l’autre.
Quand la gestion des versions déraille
Ce ne sont pas des hypothèses. C’est un mardi comme un autre.
Le client valide la mauvaise version. Vous envoyez un lien de relecture le lundi. Le mercredi, vous avez mis en ligne une correction, mais le client ouvre l’ancien lien qu’il avait mis en favori, celui qui pointe encore vers la v1. Il répond « Validé ! » et vous passez en production. Deux semaines plus tard, en réunion de lancement, quelqu’un demande pourquoi la section d’en-tête affiche toujours l’ancien titre. Vous voilà en train de faire des corrections d’urgence sur un projet « terminé », et le client jure qu’il n’a jamais validé cette version.
Le designer écrase le fichier validé. Vous rangez le dossier du projet et enregistrez le dernier tour de retouches directement par-dessus le fichier validé précédemment. Problème : la version validée était celle que le client avait approuvée, et vous ne l’avez plus. Quand le client conteste plus tard une modification (« je n’ai jamais validé cette couleur »), vous n’avez aucune preuve. La validation a disparu, parce que le fichier auquel elle se rattachait n’existe plus sous sa forme d’origine.
Les retours se perdent entre les versions. Un client laisse des commentaires détaillés sur la v2 : « remonter le CTA », « changer la photo de fond », « raccourcir le sous-titre ». Vous reprenez ces notes, produisez la v3 et l’envoyez en nouvelle pièce jointe dans un nouveau fil d’e-mails. Le client ouvre la v3 mais ne se souvient plus de ce qu’il avait demandé. Il redemande des modifications déjà faites, ou pense que vous avez ignoré ses remarques. Pendant ce temps, les retours d’origine sont enfouis dix-sept messages plus bas dans un fil que personne n’a envie de faire défiler.
Deux personnes modifient en même temps sans que personne ne s’en aperçoive. Dans une petite équipe, il arrive souvent qu’un designer et un collaborateur junior, ou un designer et un marketeur qui retouche un texte, ouvrent tous deux le même fichier source à moins d’une heure d’intervalle. Le dernier à enregistrer l’emporte, en silence, et les modifications de l’autre disparaissent sans le moindre avertissement de conflit. Les développeurs voient leurs conflits de fusion signalés explicitement. Les designers, eux, perdent généralement leur travail, tout simplement.
Tous ces problèmes ont la même cause : les versions existent, mais rien ne les relie. Les fichiers flottent d’un côté, les retours et les décisions de l’autre. C’est ce que résout une vraie gestion des versions. Elle ne se contente pas de suivre des fichiers : elle garde toute la conversation ancrée au bon instantané.
Pourquoi l’historique de versions de votre outil de design ne suffit pas
Si vous travaillez dans Figma, Adobe XD ou simplement Google Drive, vous disposez sans doute déjà d’une forme d’historique de versions. Il est tentant de croire que cela suffit. En général, ce n’est pas le cas, et l’écart compte précisément pour le travail client.
Il est conçu pour la personne qui édite, pas pour le client. L’historique de versions de Figma est une liste de points de restauration à faire défiler, pensée pour vous, la personne qui modifie le fichier. Il suppose que l’on sait déjà naviguer dans l’outil. Demander à un client qui ouvre un fichier Figma pour la première fois de retrouver « la version de mardi dernier » n’est pas réaliste, surtout s’il n’a jamais utilisé Figma et ne l’utilisera jamais.
Il n’enregistre aucune décision. L’historique natif enregistre qu’un fichier a changé. Il n’enregistre pas qu’un client l’a regardé et a dit oui ou non. Restaurer une ancienne version vous dit ce que contenait le fichier. Il ne vous dit rien sur le fait que quelqu’un l’ait validé, ni quand, ni dans quelles conditions.
Il ne couvre pas tous les types de fichiers. Un même projet mêle souvent une maquette de page d’accueil, une proposition en PDF, une courte vidéo de présentation et une URL de préproduction dans laquelle le client peut naviguer. L’historique de Figma couvre le fichier Figma. Celui de Drive couvre ce qui se trouve dans Drive. Aucun ne vous offre un endroit unique où le client peut relire les quatre, avec un historique cohérent de ce qui a été validé et quand.
Il disparaît quand le client n’est pas collaborateur. La plupart des outils de design n’affichent l’historique complet qu’aux personnes disposant de droits de modification. Les clients ont en général un simple accès en lecture, quand ils ont accès à quoi que ce soit ; l’historique que vous invoqueriez en cas de litige est donc souvent quelque chose qu’ils ne peuvent ni voir ni exporter eux-mêmes.
L’historique natif reste un bon filet de sécurité pour votre propre travail d’édition. Il répond simplement à un autre problème que celui de cet article : s’assurer que le client et le designer regardent toujours le même instantané.
Une gestion des versions pratique, sans complexité
1. Ajouter, ne pas remplacer
Au lieu d’écraser un fichier, mettez la nouvelle version en ligne à côté de l’ancienne. L’historique est préservé et chacun peut comparer les itérations.
2. Rattacher les retours aux versions
Le plus pénible dans la gestion des versions, ce ne sont pas les fichiers. Ce sont les retours. Quand les commentaires vivent dans un e-mail ou dans Slack, ils se détachent de la version précise à laquelle ils font référence.
Aligno règle ce problème en rattachant les commentaires à des versions précises. Quand vous mettez en ligne une nouvelle version, les commentaires précédents restent attachés à la version sur laquelle ils ont été laissés. Le client voit toujours la plus récente, mais l’historique complet est à un clic.
3. Rendre « actuelle » sans ambiguïté
Quel que soit l’outil, une version doit être clairement marquée comme « actuelle ». Pas de devinettes, pas de « c’est bien la dernière ? ».
4. Faire toujours arriver le client sur la dernière version
Les liens de partage doivent toujours ouvrir la version la plus récente par défaut. Si le client a mis le lien de relecture en favori il y a trois semaines, il doit quand même afficher la version actuelle, et non celle qui l’était quand vous l’avez partagé pour la première fois.
5. Clore chaque version par une décision
Gérer des versions, ce n’est pas seulement suivre des fichiers. C’est aussi suivre des décisions. Chaque version envoyée à un client doit se conclure par une action explicite : validée, ou modifications demandées. Sans cela, vous en êtes réduit aux suppositions. Le silence voulait-il dire que ça lui plaisait ? A-t-il seulement ouvert le lien ?
Quand chaque version se clôt sur une décision enregistrée, vous obtenez une piste d’audit qui protège les deux parties. Le client ne peut pas prétendre n’avoir jamais validé quelque chose. Vous ne pouvez pas continuer par erreur à itérer sur une version déjà acceptée. Et si un projet change de designer en cours de route, le nouvel arrivant voit exactement où en sont les choses sans avoir à demander à qui que ce soit.
Choisissez un outil qui intègre la validation client au processus de relecture. Le client doit valider d’un clic sur un bouton, directement sur le design, plutôt que par un e-mail de suivi que personne ne retrouve ensuite. Ainsi, la validation se trouve juste à côté de la version qu’elle concerne.
À chaque type de fichier ses habitudes de versionnage
On parle souvent de « gestion des versions en design » comme si chaque projet se résumait à une seule image statique. En pratique, un projet de design ou d’agence couvre généralement plusieurs types de fichiers, chacun avec ses particularités de versionnage.
Images statiques et maquettes
C’est le cas le plus simple, et celui d’où vient l’essentiel du chaos des noms de fichiers. L’habitude à prendre est modeste : chaque export est mis en ligne comme nouvelle version du même fichier, et non comme nouveau fichier dans un nouveau dossier. Les commentaires épinglés à un endroit précis de la version 2 (par exemple une remarque sur l’emplacement du logo) doivent rester sur la version 2 même une fois la version 3 disponible, pour que quiconque revient en arrière voie exactement à quoi la remarque faisait référence.
PDF de plusieurs pages
Les PDF ajoutent une subtilité : les retours portent généralement sur une page précise. Un commentaire sur le tableau de prix de la page 4 doit rester rattaché à la page 4 de cette version précise, et non au document dans son ensemble. Si votre outil de relecture traite une proposition de 12 pages comme un fichier plat unique, vous vous retrouverez avec des commentaires qui n’ont de sens que si vous vous souvenez de la page que le relecteur avait sous les yeux en les écrivant.
Montages vidéo
La vidéo ajoute une dimension temporelle au versionnage. « Corriger la transition » ne veut rien dire tant qu’on ne sait pas à quelle seconde de quel montage cela renvoie. Les commentaires sur une vidéo doivent être épinglés à un horodatage, et cet horodatage doit suivre la bonne version, car un nouveau montage peut facilement décaler l’endroit où tombe un moment donné. Un outil qui prend en charge les commentaires épinglés à un horodatage sur la vidéo résout un vrai problème, distinct de l’épinglage d’un commentaire sur une image statique.
Pages web en ligne
Relire une page web en préproduction, c’est encore autre chose, car le « fichier » est une URL en ligne qui peut changer sous les yeux du relecteur à tout moment. Un client qui ouvre un lien de préproduction le lundi et revient le jeudi peut voir une page totalement différente si vous avez continué à pousser des modifications sur la même URL, sans aucun moyen de savoir sur quoi il avait commenté au départ. La solution suit le même principe que partout ailleurs : chaque tour de modifications sur cette URL doit être capturé comme une version relisible à part entière, pour qu’un commentaire fait sur la mise en page du lundi ait encore du sens le jeudi, même après que la page en ligne a évolué.
Un exemple concret : trois tours pour la refonte d’une page d’accueil
Les concepts s’appliquent plus facilement avec un cas concret. Imaginons que vous êtes freelance et que vous refondez la page d’accueil d’un client en trois tours.
Tour 1. Vous mettez en ligne le concept initial en version 1 et partagez le lien de relecture. Le client épingle trois commentaires : l’image d’en-tête fait trop générique, le bouton d’appel à l’action est trop petit, et le pied de page doit contenir les bons liens vers les réseaux sociaux. Il ne valide pas. C’est normal, le tour 1 sert à ça.
Tour 2. Vous traitez les trois remarques et mettez en ligne la version 2. Comme les commentaires de la version 1 restent attachés à la version 1, vous (et le client) pouvez revenir en arrière et cocher chacun d’eux au regard de ce qui a changé, au lieu de vous fier à votre mémoire. Le client examine la version 2, aime la direction, mais demande une dernière retouche : la nouvelle image d’en-tête est bonne, mais le cadrage ne va pas sur mobile. Toujours pas de validation, ce qui est attendu et normal.
Tour 3. Vous corrigez le cadrage et mettez en ligne la version 3. Cette fois, le client clique sur valider. Cette décision est enregistrée spécifiquement pour la version 3, avec un horodatage. Deux mois plus tard, si quelqu’un côté client demande qui a validé la section d’en-tête, la réponse est directe : cette version, cette date, cette décision, sans faire appel à la mémoire de personne.
Remarquez ce qui a rendu cela possible : rien n’a été écrasé, chaque tour de retours est resté attaché à la version qu’il concernait, et la validation finale pointait vers un instantané exact et toujours existant plutôt que vers « ce qui est en ligne en ce moment ».
Vous n’avez pas besoin de Git
Il vous faut un système qui suit les versions et garde les retours attachés, pour que tout le monde sache quelle version fait foi. Restez simple et visuel, et votre futur vous vous remerciera.
Si votre outil de relecture actuel ne vous suffit plus, découvrez comment Aligno se compare à GoVisually pour une revue de design qui tient compte des versions, ou consultez la liste complète des fonctionnalités pour voir comment versions, commentaires et validation s’articulent au même endroit.