Autodidacte par essence, je partage ici ce que j'aurais aimé apprendre plus tôt dans le dev pour pouvoir aller plus loin plus rapidement.


Tout mon contenu est disponibles sur mon site : [Anthony Capirchio](https://anthony.capirchio.fr).

Anthony Capirchio


Hier, mon épouse a tenté de créer un compte sur un site pour la retraite de son père. À chaque tentative, elle tombait sur un message générique : “Erreur technique”. Impossible de comprendre ce qui bloquait.

Pressée par le temps et face à une situation urgente, elle a tenté de contacter le support du site. Mais sans succès, personne ne répondait.

Réflexe de développeur, je lui ai demandé d’ouvrir la console du navigateur pour voir si des erreurs apparaissaient lors de la soumission du formulaire. Et là, une erreur 417 s’affichait sur la requête, avec un message détaillé dans le corps de la réponse :

> “Le format de l’email n’est pas conforme.”

Le problème venait de l’utilisation d’un ”+” dans l’adresse e-mail (jdoe+retraite@gmail.com), un format pourtant valide dans la plupart des services.

Fallait-il vraiment ouvrir la console de développement pour comprendre l’erreur ?

Cette situation illustre un problème fréquent dans la conception des interfaces : les messages d’erreur sont souvent trop génériques, inutiles ou mal placés. Ce manque d’information frustre les utilisateurs, complique leur parcours et alourdit la charge des services clients.

## Pourquoi un message d’erreur mal conçu est un problème majeur ?

Lorsqu’un utilisateur tente d’effectuer une action sur un site (comme créer un compte, valider un paiement ou soumettre un formulaire), il s’attend à ce que le système lui indique clairement s’il y a un problème et comment le résoudre.

Un message d’erreur mal conçu peut entraîner plusieurs conséquences négatives :
* **Incompréhension de l’utilisateur** : sans message clair, l’utilisateur ne sait pas quoi corriger et va recommencer plusieurs fois, espérant que cela fonctionne sans savoir pourquoi cela échoue.
* **Augmentation des contacts avec le support client** : les utilisateurs bloqués vont chercher à contacter le service client, ce qui peut entraîner une surcharge inutile.
* **Dégradation de l’expérience utilisateur** : une frustration grandissante qui transforme une action simple en une source de stress.
* **Perte de confiance envers la plateforme** : un site qui génère des erreurs non explicites est perçu comme mal conçu ou peu fiable.

Dans certains cas, une mauvaise gestion des erreurs peut même pousser l’utilisateur à abandonner le service et à chercher une alternative concurrente.

## Les erreurs d’UX ont des répercussions concrètes

Les problèmes liés aux messages d’erreur ne sont pas anodins. Ils ont des impacts réels à plusieurs niveaux :

**Sur l’utilisateur final**
* Sentiment d’impuissance face à un blocage sans explication.
* Multiplication des tentatives infructueuses, ce qui peut l’amener à adopter des comportements contre-productifs.
* Frustration qui peut évoluer vers une perception négative de la plateforme ou du service.

**Sur le support client**
* Augmentation des requêtes d’assistance pour des problèmes qui auraient pu être évités.
* Charge de travail accrue, obligeant les conseillers à gérer des demandes répétitives et inutiles.
* Dégradation de la qualité du support, car l’équipe doit gérer plus d’appels et d’e-mails pour des sujets qui ne devraient pas nécessiter d’intervention humaine.

**Sur l’entreprise**
* Impact sur l’image de marque : un service perçu comme peu intuitif ou difficile à utiliser peut perdre des utilisateurs au profit d’un concurrent mieux optimisé.
* Coût opérationnel accru : plus de requêtes au support client signifie plus de ressources à mobiliser.
* Taux d’abandon plus élevé : un utilisateur frustré est plus susceptible de ne jamais finaliser son inscription ou son achat.

## Comment éviter ces problèmes ?

### Afficher des messages d’erreur explicites et actionnables

Un bon message d’erreur doit répondre aux trois questions suivantes :
* Quel est le problème ? → Expliquer clairement la nature de l’erreur.
* Pourquoi cela ne fonctionne pas ? → Donner un contexte pour aider l’utilisateur à comprendre.
* Comment le corriger ? → Fournir une solution précise pour résoudre le problème immédiatement.

Exemple de mauvais message d’erreur :

> “Erreur technique, veuillez réessayer plus tard.”

Ce message ne donne aucune information exploitable par l’utilisateur.

Exemple de bon message d’erreur :

> “Le format de l’adresse e-mail n’est pas valide. Veuillez utiliser une adresse sans caractères spéciaux comme ’+’.”

Ce message informe l’utilisateur sur la cause du problème et lui indique comment le résoudre.

### Placer les messages d’erreur au bon endroit

L’utilisateur ne devrait pas avoir besoin d’attendre la soumission d’un formulaire pour découvrir une erreur.
* Afficher les erreurs au plus près des champs concernés, en temps réel lorsque c’est possible.
* Ne pas masquer l’erreur dans la console ou dans un retour serveur inaccessible à l’utilisateur.
* Utiliser des icônes ou des couleurs distinctes pour attirer l’attention sur les erreurs (par exemple, une bordure rouge autour du champ concerné).

### Prendre en compte l’expérience utilisateur (UX) dans la gestion des erreurs

Un message d’erreur ne doit pas être conçu uniquement pour le développeur ou l’équipe technique, il doit être pensé pour l’utilisateur final.
* Ne pas utiliser de jargon technique : un utilisateur lambda ne comprend pas ce qu’est une “erreur 417”.
* Éviter les messages vagues : “Une erreur est survenue” ne permet pas de comprendre l’origine du problème.
* Privilégier la clarté et la simplicité : l’utilisateur doit pouvoir comprendre et corriger l’erreur sans avoir besoin d’aide extérieure.

### Tester les messages d’erreur avec des utilisateurs réels

Lors des tests d’interface utilisateur, il est essentiel d’évaluer la compréhension et l’efficacité des messages d’erreur.
* Organiser des sessions de test avec des utilisateurs non techniques pour observer leurs réactions face aux erreurs.
* Vérifier si les messages sont compris immédiatement sans explication supplémentaire.
* Ajuster les formulations en fonction des retours des testeurs.

### Des efforts minimes pour un impact majeur

Un bon message d’erreur peut faire toute la différence entre un utilisateur satisfait et un utilisateur frustré.

En prenant quelques précautions simples :
* Écrire des messages explicites et informatifs.
* Placer les erreurs à des endroits visibles et logiques.
* Adapter la formulation aux utilisateurs et non aux développeurs.
* Tester les messages pour s’assurer de leur compréhension.

On améliore l’expérience utilisateur, on réduit les demandes inutiles au support client, et on renforce la confiance envers le service.

Un message d’erreur bien conçu est plus qu’un simple détail technique : c’est un élément clé d’une bonne expérience numérique.


Un message d’erreur générique comme ‘Incident technique’ peut frustrer vos utilisateurs et surcharger votre support. Découvrez pourquoi des messages clairs et explicites améliorent l’expérience utilisateur, réduisent la frustration et évitent des crises inutiles.

Les erreurs d’UX qui frustrent vos utilisateurs (et comment les éviter)


Je fais des pizzas à la maison de temps en temps, et pour améliorer mes résultats, je me suis offert un four à pizza professionnel. Il monte à plus de 400°C, c’est génial… sauf que son installation a été un cauchemar. J’ai dû refaire mon installation électrique et changer mon contrat d’énergie parce que ça ne tenait plus.

Résultat ? Mes pizzas ne sont toujours pas aussi bonnes qu’au restaurant.

Le problème ne venait pas du four, mais sûrement de la pâte… que j’achète déjà faite.

## Une obsession pour la technologie au lieu des fondamentaux

Cette situation, aussi absurde soit-elle, est une parfaite analogie de ce qu’on voit souvent en entreprise. On investit dans des outils ultra-puissants, on s’équipe comme les GAFAM… et pourtant, nos résultats ne s’améliorent pas.

Pourquoi ?

* **On sous-estime les vrais besoins** : Un four à 400°C, c’est bien, mais sans une bonne pâte, ça ne sert à rien. De même, Kubernetes, Kafka ou un microservice ultra-scalable n’aideront pas une startup si elle n’a pas encore validé son produit.

*  **On oublie l’impact caché** : Comme mon installation électrique qui a explosé, chaque nouvel outil demande de la formation, de la maintenance et un alignement organisationnel. Une infra surdimensionnée devient vite un frein.

* **On copie sans réfléchir** : On adopte les outils des grands sans se demander pourquoi ils en ont besoin. Spoiler : ce qui fonctionne pour une entreprise de 3000 ingénieurs ne s’applique pas forcément à une équipe de 13 devs.

## L’illusion du minibus : besoin vs envie

On a tendance à envier le minibus du voisin, sans se demander pourquoi il en a besoin.

🚌 Lui : Il a 5 enfants, donc il lui faut un véhicule adapté.

🚗 Toi : Tu vis seul et travailles à distance. Un vélo ou une petite voiture ferait largement l’affaire.

En entreprise, c’est pareil :

* Adoptez des solutions adaptées à votre taille et vos besoins.
* Priorisez les fondamentaux avant de vouloir scaler à tout prix.
* Évitez de surcomplexifier votre stack pour des problèmes qui n’existent pas encore.

## Comment éviter le piège ?

* **Posez-vous la bonne question** : Est-ce que cet outil ou cette technologie répond VRAIMENT à un besoin chez nous, ou est-ce juste parce que “les autres le font” ?

* **Adaptez à votre taille** : Une startup de 10 devs n’a pas besoin de la même stack qu’une scale-up de 500 personnes. Simplicité > Complexité inutile.

* **Commencez par maîtriser les bases** : Avant de vouloir scaler, assurez-vous que votre code, vos process et votre équipe sont solides. Un bon produit et une bonne organisation sont plus importants qu’un outil à la mode.

## Faites des pizzas adaptées à votre cuisine !

Acheter un four ultra-performant ne rendra pas votre pizza meilleure si la pâte est industrielle. De même, adopter des technos de pointe sans maîtriser les bases ne fera pas de votre produit un succès.

* Construisez en fonction de VOS besoins.
* Faites simple avant de vouloir faire complexe.
* Et surtout, ne copiez pas aveuglément les GAFAM.

Après tout, ce n’est pas l’outil qui fait la qualité… c’est la façon dont vous l’utilisez.


Faut-il vraiment copier les GAFAM pour réussir ? Trop souvent, on adopte des outils et technologies surdimensionnés sans répondre à un besoin réel. Découvrez pourquoi il est essentiel de choisir des solutions adaptées à votre équipe et à votre projet, et comment éviter le piège de la complexité inutile.

Arrêtez de copier les GAFAM : adoptez des outils adaptés à vos besoins !


Dans la gestion des incidents, le Post Mortem est devenu une pratique incontournable. Lorsqu’un problème survient, on revient sur ses causes, on analyse ce qui aurait pu être évité et on met en place des actions correctives pour l’avenir. C’est un exercice nécessaire, qui permet de capitaliser sur les erreurs pour améliorer la résilience des systèmes.

Mais faut-il vraiment attendre qu’un projet ou un service tombe en panne pour en tirer des leçons ?

Si nous appliquions la même logique que la médecine légale, nous admettrions qu’une autopsie ne sert qu’à analyser ce qui est déjà perdu. Alors, pourquoi se contenter d’intervenir après la catastrophe, alors qu’on pourrait anticiper et éviter les incidents avant qu’ils ne surviennent ?

Il est temps d’adopter une approche proactive : **le Pre Mortem**.

## Le Pre Mortem : mieux vaut prévenir que guérir

Contrairement au Post Mortem, qui intervient après un incident, le Pre Mortem se déroule en amont. Il s’agit d’un exercice de simulation où l’équipe imagine les scénarios les plus probables d’échec d’un projet, d’un service ou d’une fonctionnalité.

🔍 L’objectif ? Identifier les risques majeurs avant qu’ils ne se matérialisent et élaborer des plans de réponse adaptés.

Un bon Pre Mortem repose sur trois axes :

1. **L’anticipation** : Imaginer les pires scénarios possibles et comprendre leurs déclencheurs.
2. **La prévention** : Définir des mesures pour limiter les risques et éviter les erreurs courantes.
3. **La préparation** : Construire des playbooks d’intervention pour réagir rapidement et efficacement si un problème survient malgré tout.

## Pourquoi intégrer le Pre Mortem dans votre workflow ?

Dans un monde où la rapidité de livraison est cruciale, la gestion des risques est souvent reléguée au second plan. Pourtant, un incident majeur peut coûter bien plus cher qu’une session d’anticipation bien menée.

* **Moins d’incidents critiques** : En identifiant en avance les points faibles, on réduit drastiquement les risques de panne.
* **Une meilleure réactivité** : En ayant déjà préparé des scénarios de crise, on sait exactement comment réagir en cas de problème.
* **Une culture de la résilience** : Les équipes ne subissent plus les incidents, elles les anticipent et les contrôlent.

Même si le Pre Mortem est idéalement réalisé dès la conception d’un projet, il peut aussi être utilisé à tout moment pour sécuriser une application déjà en production. L’essentiel est d’intégrer cette démarche dans les pratiques de l’équipe, au même titre que les revues de code ou les tests automatisés.

## Comment mettre en place un Pre Mortem efficace ?

**1. Organiser une session dédiée**

Réunissez l’équipe projet et consacrez du temps à un brainstorming structuré sur les risques.

**2. Simuler les pires scénarios**

Posez la question : “Imaginons que notre projet échoue. Quels pourraient être les facteurs déclencheurs ?” Listez tous les risques potentiels, du plus probable au plus extrême.

**3. Cartographier les vulnérabilités**

Identifiez les points faibles, les dépendances critiques et les angles morts du projet.

**4. Élaborer des stratégies de prévention**

Pour chaque risque identifié, définissez des actions concrètes pour le réduire ou l’éliminer.

**5. Construire des playbooks d’intervention**

Documentez les procédures de gestion des incidents pour garantir une réponse rapide et efficace en cas de problème.

## Pre Mortem : un changement de d'état d'ésprit essentiel

Dans le développement logiciel, comme dans toute gestion de projet, il est plus rentable d’anticiper que de réparer. Trop souvent, nous sommes enfermés dans une logique de réaction, alors que nous devrions être dans une logique de prévention.

Le Pre Mortem est une approche simple, mais puissante, qui permet aux équipes de prendre le contrôle sur l’avenir de leurs projets au lieu de subir les aléas de la production.

Alors, plutôt que d’attendre l’autopsie d’un projet en échec… Pourquoi ne pas prévoir son avenir dès maintenant ?


Pourquoi attendre qu’un projet échoue pour en tirer des leçons ? Le Pre Mortem permet d’anticiper les risques avant qu’ils ne surviennent, en identifiant les scénarios d’échec et en préparant des stratégies de réponse. Découvrez comment cette approche peut transformer la gestion des incidents et renforcer la résilience de vos projets.

N’attendons pas l’autopsie pour comprendre ce qui ne va pas !


Dans le monde du développement logiciel, on entend souvent la métaphore des LEGO pour illustrer la conception d’une architecture technique. Chaque module, chaque librairie, chaque application s’assemble de manière méthodique, construisant un ensemble robuste et cohérent. Avec les bonnes pièces et un peu de méthode, tout semble réalisable.

Mais si on regarde la réalité en face, notre quotidien ressemble bien plus à une partie de Tetris qu’à une construction soignée en LEGO. Et quand le jeu s’accélère trop vite, il devient vite incontrôlable…

## Le développement en mode Tetris : une course contre la montre

Dans un monde idéal, chaque brique d’un projet logiciel s’intègre harmonieusement, avec une réflexion en amont et des ajustements précis. Dans la vraie vie, c’est une tout autre histoire :

* Les exigences changent constamment, imposant des ajustements imprévus.
* Les délais se raccourcissent, obligeant à empiler rapidement les solutions.
* Les contraintes techniques et organisationnelles s’accumulent, rendant l’assemblage plus complexe.

Tout comme dans Tetris, on ne choisit pas toujours les pièces qui arrivent. Il faut s’adapter en temps réel, trouver la meilleure façon d’intégrer une nouvelle fonctionnalité sans perturber l’existant. Et plus la cadence s’accélère, plus la marge d’erreur se réduit.

## Les dangers d’une accumulation mal maîtrisée

Dans Tetris, une mauvaise décision peut rapidement condamner la partie. Il en va de même en architecture logicielle :

* Empiler trop vite sans réfléchir, c’est prendre le risque d’une architecture instable.
* Les dettes techniques s’accumulent comme des lignes incomplètes, bloquant toute évolution future.
* L’absence de vision à long terme transforme chaque nouvelle brique en un casse-tête, où chaque ajout devient plus compliqué que le précédent.

Quand on enchaîne les choix rapides sans cohérence globale, on finit par s’enfermer dans une structure rigide et chaotique, où la moindre modification devient une prise de tête.

## Prendre le temps de bien jouer : l’importance de l’anticipation

Dans Tetris comme dans le développement logiciel, il ne suffit pas d’empiler les briques au plus vite. Il faut anticiper, organiser et optimiser.

* Ralentir pour mieux structurer : mieux vaut prendre le temps de concevoir une base solide plutôt que de devoir tout reconstruire dans l’urgence.
* Éviter la précipitation : accélérer sans réflexion entraîne plus de problèmes qu’elle n’en résout.
* Penser long terme : une bonne architecture n’est pas qu’une solution immédiate, elle doit être évolutive et maintenable.

## Gagner la partie en jouant intelligemment


La tentation est grande d’aller vite, de livrer rapidement, de s’adapter en temps réel aux contraintes du projet. Mais à force d’accumuler des choix à court terme, on finit par se retrouver bloqué, incapable de faire évoluer l’ensemble sans tout casser.

Un bon développeur ou architecte ne se contente pas d’empiler des briques à toute vitesse : il joue avec stratégie, en anticipant les coups suivants, en gardant une vision d’ensemble, et en construisant un système prêt à durer.

Et parfois, la meilleure décision, c’est simplement d’appuyer sur pause, de réfléchir, et d’accepter que certaines choses prennent du temps. Parce que dans le jeu du développement, ce n’est pas celui qui va le plus vite qui gagne, mais celui qui tient le plus longtemps.


Le développement logiciel ressemble-t-il vraiment à un jeu de LEGO ? Pas si sûr… Entre délais serrés, exigences changeantes et empilement rapide des solutions, notre métier s’apparente plutôt à une partie de Tetris sous pression. Découvrez pourquoi anticiper et structurer son architecture est essentiel pour éviter une accumulation chaotique et garantir la pérennité de vos projets.

L’Architecture et le Développement : une partie de Tetris qui tourne mal ?


J’aime coder, et parce que j’aime coder, il peut m’arriver de me convaincre que telle ou telle fonctionnalité pourrait être super utile, simplement parce que la développer serait assez excitant. Mais n’est-ce pas en réalité une forme de pollution du projet ?

Je suis développeur, le code j’aime ça, je dirais même que j’adore. Plus que ça, c’est la résolution de problèmes à l’aide du code qui me fait palpiter. 

Dans mon métier, au quotidien, c’est plutôt un avantage non négligeable, mais assez fréquemment c’est un poison. Un poison pour la simple et bon raison que si mon plaisir est dans la résolution de problèmes, ça veut également dire que j’aime les problèmes… Comme beaucoup de dev, je joue régulièrement le rôle du pompier pyromane en créant moi-même des problèmes. 

Non, pas des bugs ou des dysfonctionnements, ça n’aurait pas beaucoup de sens, mais des fonctionnalités. Après tout, comment pourrais-je me voir reprocher l’ajout de nouvelles fonctionnalités ? C’est toujours bien d’avoir de nouvelles fonctionnalités dans un système non ?

Dans une grande partie des cas, **non**, ça n’est pas forcément une bonne chose d’ajouter de nouvelles fonctionnalités. Ce n’est pas une bonne idée parce qu’une feature, c’est au minimum :

- De la modélisation / conception
- De l’écriture de code
- De l’écriture de tests
- De l’écriture de documentation
- Très potentiellement de la refacto
- Un risque de régression

En gros, ça prend du temps, de l’énergie, et ça risque même de foutre le bazar dans le projet. 

La question qui se pose ici c’est : est-ce que le jeu en vaut la chandelle ? 

Plus exactement, est-ce que cette nouvelle fonctionnalité a un intérêt fondé autre que simplement venir nourrir mon besoin de résoudre des problèmes ? 

C’est une vraie question. Encore aujourd’hui j’ai stoppé un dev en plein milieu simplement parce que j’ai réalisé qu’il avait des conséquences non négligeables sur mon projet alors que sa seule raison d’être était un « ça pourrait être vachement utile cette fonctionnalité ». 

À vrai dire, dès que cette idée fait surface, il y a potentiellement une embrouille à venir. 

Comme assez souvent, pour se remettre sur les rails, il faut retourner à une certaine forme de radicalité. C’est de cette manière que je tente de plus en plus de prendre en compte deux approches majeures :

- YAGNI
- Philosophie UNIX

## YAGNI

> «*You ain’t gonna need it »*
> 

Pourquoi ajouter cette fonctionnalité alors que tu n’en auras pas besoin ?

Globalement l’idée est de se limiter à ajouter des fonctionnalités qui sont véritablement  nécessaires. C’est assez radical, mais il faut voir ça comme une cure de désintoxication, car il est bien question de toxicité. 

Toxicité parce qu’en plus de faire consommer du temps inutilement, le développement pour l’auto satisfaction risque d’introduire des régressions ou encore de la dette technique. Ça apporte plus de galères qu’autre chose. 

L’idée est donc de se poser une question simple : mon projet a-t-il un besoin vital de cette fonctionnalité ?

L’idée d’un besoin « vital » est centrale ici. Il est vaguement question de se demander si le projet peut simplement exister sans la fonctionnalité en question.

Est-ce que le projet peut vivre sans cette feature ? Alors cette fonctionnalité  n’est absolument pas nécessaire, elle peut être mise à l’écart. 

## Philosophie UNIX

> Fais une chose et fais le bien
> 

C’est probablement un des principes les plus importants de la philosophie UNIX. 

C’est l’idée qu’un programme doit se limiter à un domaine bien précis et ne pas déborder sur un autre. 

Par exemple, le programme `ls` se contente de lister le contenu d’un répertoire. Il possède pas mal d’options, mais se contente de rester dans son domaine : lister le contenu d’un répertoire. 

Il existe bien évidemment des programmes plus complexes comme `ssh` mais concrètement, il se limite à établir une connexion SSH. Il est possible de faire de la redirection de port, d’exécuter une commande à distance, mais il reste dans son domaine : établir une connexion SSH. 

Vous voulez copier un fichier via SSH ?

Pas de soucis, le programme `scp` est là pour ça, mais ça n’est pas une fonctionnalité du programme `ssh`. 

## Attendre un besoin signifie-t-il ne plus anticiper ?

C’est exactement à ce moment que nous pouvons être tentés de retomber dans la création de features non sollicités et malheureusement, je ne connais pas d’acronyme faisant référence à une quelconque philosophie.

Ici, pas de règle, simplement se faire confiance à soi-même. Faire confiance à son expérience, à sa connaissance du métier / produit.

Les principes comme YAGNI ne permettent en réalité que d’apprendre à se maîtriser soi-même. Il n’est aucunement question de règles à suivre de manière dogmatique, mais plutôt d’outils pour alimenter son auto discipline.

J’aime coder, et parce que j’aime coder, il peut m’arriver de me convaincre que telle ou telle fonctionnalité pourrait être super utile, simplement parce que la développer serait assez excitant. Mais n’est-ce pas en réalité une forme de pollution du projet ?

L'autodidacte

Methodo

Les erreurs d’UX qui frustrent vos utilisateurs (et comment les éviter)

Arrêtez de copier les GAFAM : adoptez des outils adaptés à vos besoins !

N’attendons pas l’autopsie pour comprendre ce qui ne va pas !

L’Architecture et le Développement : une partie de Tetris qui tourne mal ?

Et si je foutais cette feature la poubelle ?