Il y a un moment que tous les développeurs finissent par vivre.
Celui où ton projet fonctionne parfaitement.
Les routes répondent.
La base de données est connectée.
Les features font exactement ce que tu as prévu.
Et pourtant… tu n’as aucune envie d’y retourner.
“Ça marche” n’est pas une victoire
Je me souviens très bien de ce projet.
Une API Node.js avec Express, PostgreSQL derrière, un peu de Sequelize pour faire propre.
Rien de compliqué.
Au début, tout était fluide.
Tu codes, ça marche, tu avances.
Tu as cette sensation agréable de progression rapide.
Et puis un jour, tu reviens dessus.
Juste pour ajouter une petite fonctionnalité.
Et là… quelque chose change.
Tu ouvres le projet.
Tu regardes une route.
Puis une autre.
Et sans trop comprendre pourquoi, tu sens une forme de blocage.
Pas technique.
Mental.
Le vrai problème n’était pas le code
Sur le moment, je me disais que ça allait.
“C’est normal, c’est un petit projet.”
Mais en réalité, le problème était déjà là.
Mes routes faisaient tout.
Un peu de logique métier ici.
Un appel base de données là.
Une gestion d’erreur bricolée dans un coin.
Rien n’était vraiment structuré.
Mais comme tout fonctionnait… je ne voyais pas le problème.
Jusqu’au jour où j’ai voulu modifier un truc simple
Je voulais juste ajouter une fonctionnalité.
Rien de fou.
Un champ en plus, une petite logique.
Et pourtant, j’ai commencé à hésiter.
“Si je change ça… qu’est-ce que je vais casser ?”
Et c’est là que j’ai compris un truc assez dérangeant.
Mon code fonctionnait… mais je ne lui faisais plus confiance.
Le moment un peu bizarre où tu réalises que tu subis ton propre code
C’est difficile à expliquer.
Tu n’as pas d’erreur.
Pas de bug bloquant.
Mais tu avances avec prudence.
Comme si chaque modification pouvait déclencher une réaction en chaîne.
Et ça, pour un développeur, c’est un signal très clair.
Quelque chose ne va pas dans la structure.
Le premier déclic : arrêter de tout mettre au même endroit
Je n’ai pas tout refactorisé d’un coup.
Personne ne fait ça proprement.
J’ai commencé petit.
Une seule chose : arrêter de mettre toute la logique dans les routes.
Avant, j’avais un truc comme ça :
router.post('/events', async (req, res) => {
const event = await Event.create(req.body);
res.json(event);
});
Et dès que ça grossit un peu, ça devient vite ingérable.
Validation, règles métier, permissions… tout finit empilé.
Le changement n’était pas spectaculaire
J’ai juste déplacé la logique.
Un service.
Un contrôleur.
Rien de magique.
// controller
const createEvent = async (req, res) => {
const event = await eventService.createEvent(req.body);
res.json(event);
};
// service
const createEvent = async (data) => {
return Event.create(data);
};
Et honnêtement ?
À ce moment-là, je n’ai pas eu de révélation.
Pas de “wow”.
Juste un truc très simple :
“ok… c’est plus clair.”
Mais le vrai changement est venu après
Le vrai test, ce n’est pas quand tu refactorises.
C’est deux semaines après.
Quand tu reviens dans ton projet.
Et que tu comprends ce que tu as fait sans relire 15 fichiers.
Là, j’ai senti la différence.
Moins de stress.
Moins d’hésitation.
Moins de “je touche ou pas ?”
Ce que j’ai compris à ce moment-là
Ce n’est pas la complexité du code qui pose problème.
C’est le chaos invisible.
Quand tout est mélangé, ton cerveau doit tout retenir en même temps :
- logique métier
- requêtes SQL
- gestion HTTP
- erreurs
- règles implicites
Et ça fatigue.
Sans que tu t’en rendes compte.
Et pourtant… ce projet fonctionnait parfaitement
C’est ça le piège.
Le code peut être “bon” techniquement.
Mais mauvais à vivre.
Et à un moment, en tant que développeur, tu fais la différence entre :
- un projet qui marche
- et un projet avec lequel tu peux travailler sereinement
La suite a changé ma façon de coder
Ce petit refactor m’a ouvert une porte.
Après ça, je ne regardais plus mes projets de la même façon.
Je ne cherchais plus juste à “faire fonctionner”.
Je commençais à me demander :
- “est-ce que je vais comprendre ça dans 2 semaines ?”
- “est-ce que quelqu’un d’autre peut lire ça facilement ?”
- “est-ce que je suis en train de créer du chaos sans m’en rendre compte ?”
Et c’est là que tout commence vraiment
Pas quand tu sais coder une API.
Pas quand tu sais utiliser un ORM.
Mais quand tu commences à ressentir ton propre code.
Quand tu sais, instinctivement, qu’un projet va devenir lourd… avant même qu’il le devienne.
👉 Dans le prochain article, on parlera d’un truc encore plus vicieux :
les routes Express qui deviennent illisibles sans qu’on s’en rende compte.
