L'application que personne ne voulait toucher

  • Onboarding : de 12 à 3 min
  • Réécriture complète approuvée le même trimestre
  • Plus de cycles de régression de 3 semaines
  • 12 à 3 min Durée de l'onboarding patient
  • 90% Réduction des erreurs de facturation liées à l'onboarding
  • 4 semaines Délai entre la mission et le module de preuve fonctionnel

La situation

Une entreprise australienne d'administration de santé comptant 120 employés faisait tourner ses opérations centrales sur un outil interne construit cinq ans plus tôt par un développeur depuis parti. L'application gérait l'onboarding des patients, la prise de rendez-vous, la facturation et le traitement des demandes d'assurance pour un réseau de 14 cliniques. Personne ne comprenait pleinement le code. Ajouter la moindre fonctionnalité prenait des semaines de tests minutieux, car les changements dans un module en cassaient souvent d'autres, et aucun test ne détectait ces ruptures avant qu'elles n'atteignent la production. L'équipe avait cessé de tenter d'améliorer l'application et avait appris à la contourner, et chaque contournement creusait en silence l'écart entre ce que le système enregistrait et ce qui se passait réellement dans la clinique. Des notes autocollantes et des feuilles de calcul partagées comblaient cet écart, et le personnel qui les tenait à jour était devenu, sans que personne ne l'ait décidé, la véritable source de vérité.

Avec leurs mots

J'ai cessé d'essayer d'expliquer pourquoi il nous fallait un nouveau système. Je le leur ai simplement montré. Quatre semaines de logiciel fonctionnel ont accompli ce que deux ans de propositions n'avaient pas pu.
FatimaCTO, administration de santé australienne

Ce qui était vraiment cassé

L'application était un monolithe PHP sans tests automatisés, sans documentation, et avec un schéma de base de données modifié tant de fois que plusieurs tables portaient des noms de colonnes contradictoires pour un même champ. Le développeur d'origine avait tout écrit sur un framework maison non documenté, qui ne ressemblait ni à Laravel, ni à Symfony, ni à aucune convention qu'un nouvel arrivant reconnaîtrait, si bien qu'aucun des repères habituels ne s'appliquait. Les nouveaux développeurs passaient leurs trois premiers mois rien qu'à apprendre comment l'application fonctionnait avant de pouvoir modifier une seule ligne en toute sécurité, et intégrer un ingénieur expérimenté à un système aussi sur mesure prend couramment des mois plutôt que des semaines. Deux développeurs avaient démissionné durant leur première année, citant le code comme raison principale. Le savoir existant vivait dans les personnes, pas dans le dépôt, et il franchissait la porte chaque fois que quelqu'un partait.

La CTO plaidait depuis deux ans pour une réécriture complète. Elle avait produit trois propositions distinctes, chacune avec estimations de coûts, calendriers et évaluations de risques. La direction les rejeta toutes les trois. La première fut rejetée parce que le coût estimé était trop élevé. La deuxième, parce que le calendrier estimé était trop long. La troisième, parce que deux tentatives de réécriture antérieures, toutes deux avant l'arrivée de la CTO, avaient déjà échoué. Cette histoire n'a rien d'inhabituel : les réécritures en big bang figurent parmi les façons les plus courantes dont échouent les efforts de modernisation, car elles exigent de reconstruire tout le système avant que l'entreprise n'en tire la moindre valeur, et elles dépassent fréquemment leurs estimations. Le mot "réécriture" était devenu politiquement toxique. La direction l'entendait et pensait budget englouti, dates manquées et promesses non tenues, et aucune feuille de calcul n'allait changer cette association.

Pendant ce temps, le coût opérationnel ne cessait de s'accumuler. L'onboarding patient, le flux le plus utilisé, obligeait le personnel à saisir des données dans sept écrans différents, à attendre trois vérifications de validation distinctes et à déclencher manuellement deux appels d'API vers des services externes de vérification d'assurance. Le processus prenait en moyenne 12 minutes par patient, contre une norme du secteur où la saisie et la transcription manuelles prennent en général de 10 à 20 minutes et comportent un taux d'erreur réel à chaque frappe. Aux heures de pointe, des patients attendaient en salle sans place dans le système où les inscrire. Le personnel improvisait : il sautait les champs facultatifs, regroupait les vérifications d'assurance en fin de journée et notait toute personne laissée dans les limbes sur une feuille de calcul partagée de patients "partiellement inscrits". Chaque raccourci échangeait quelques secondes au comptoir contre un problème de qualité des données en aval, et ces problèmes se répercutaient directement sur la facturation. Les erreurs de saisie démographiques et techniques sont, dans tout le secteur, une cause majeure de refus de demandes, et ici elles apparaissaient sous forme de reprise : l'équipe de facturation passait 15 heures par semaine à corriger des erreurs nées dans l'onboarding.

Étape par étape

Audit des flux et sélection du module

Nous avons passé quatre jours à cartographier chaque flux de l'application : onboarding, planification, facturation, demandes d'assurance et reporting. Pour chacun, nous avons mesuré la fréquence d'utilisation, le temps par tâche et le taux d'erreur, afin que le choix du point de départ soit un chiffre, et non une opinion. La bonne première tranche d'une modernisation est celle à fort volume, forte douleur et nettement isolable, et l'onboarding arrivait en tête sur les trois : la plus forte fréquence (plus de 200 par jour sur 14 cliniques), le plus long temps par tâche (12 minutes) et le plus fort taux d'erreur (18 % des dossiers exigeaient une correction manuelle). C'était aussi une couture nette, suffisamment découplée de la planification et des demandes d'assurance pour être reconstruite seule. Nous avons choisi l'onboarding comme module de preuve précisément parce que le corriger serait le plus visible et le moins risqué.

Module de preuve en parallèle

Plutôt que de toucher à l'application existante, nous avons construit un module d'onboarding autonome en React et Supabase tournant aux côtés du système hérité, une version délibérément réduite de l'approche strangler fig : faire croître le nouveau système à côté de l'ancien et le laisser reprendre un flux à la fois plutôt que de tout remplacer d'un coup. Le nouveau module lisait et écrivait dans la même base de données, restant ainsi pleinement compatible avec le reste de l'application sans jamais dédoubler les données. Le personnel basculait entre l'ancienne et la nouvelle interface d'un seul interrupteur, ce qui nous donnait un retour arrière intégré : si le nouveau flux se comportait mal, n'importe qui pouvait revenir instantanément à l'écran hérité, sans déploiement ni perte de données. Cela voulait dire que nous pouvions mettre un vrai logiciel devant de vraies cliniques sans jouer les opérations. Si cela ne fonctionnait pas, le personnel cesserait simplement de l'utiliser, et rien ne casserait.

Refonte du flux de travail

Le flux de sept écrans s'est réduit à un formulaire d'une seule page à divulgation progressive, de sorte que le personnel ne voyait que les champs pertinents à chaque étape au lieu de parcourir des écrans à la recherche de la prochaine case obligatoire. La vérification d'assurance se déclenchait automatiquement dès la saisie d'un identifiant d'assurance, remplaçant l'appel d'API manuel que le personnel reportait en fin de journée. La validation est passée en ligne, attrapant les champs manquants et les mauvais numéros d'assurance au point de saisie plutôt que dans trois vérifications par lots après coup, c'est-à-dire là où les données du secteur disent que les erreurs sont les moins coûteuses à corriger. La feuille de calcul des "partiellement inscrits" a été remplacée par un véritable champ de statut sur le dossier lui-même, si bien que le contournement a cessé d'être un système parallèle. Le flux repensé prenait en moyenne 2 minutes et 40 secondes, contre 12 minutes.

Déploiement et dossier d'affaires

Nous avons déployé le module de preuve d'abord dans deux cliniques, puis l'avons étendu aux 14 sur deux semaines. L'adoption n'a exigé aucune contrainte : la nouvelle interface était visiblement plus rapide, alors le personnel y est passé de lui-même. Dès la première semaine, les deux cliniques pilotes ont signalé zéro embouteillage d'onboarding et une réduction de 90 % des erreurs de facturation nées de l'onboarding. Comme nous avions capté la base de référence avant le lancement, l'amélioration était une tendance mesurée et non une affirmation. La CTO a présenté ces chiffres à la direction avec une démonstration en direct du logiciel en fonctionnement, la seule chose que deux ans de propositions écrites n'avaient jamais pu montrer. La réécriture complète a été approuvée ce même trimestre, budgétée sur le coût réel du module de preuve plutôt que sur une estimation théorique, et c'est précisément pour cela que le budget a tenu face à l'examen.

Ce qui a changé

Durée de l'onboarding patient
12 à 3 min
Réduction des erreurs de facturation liées à l'onboarding
90%
Délai entre la mission et le module de preuve fonctionnel
4 semaines
Embouteillages d'onboarding dans les cliniques pilotes
0
Réécriture complète approuvée
Même trimestre
Temps de correction de facturation éliminé
15 h/semaine

12 à 3 min Durée de l'onboarding patient

Contactez-nous

Dites-nous ce que vous voulez construire. Nous vous disons par où commencer et ce qu’il faut.

Questions fréquentes, réponses simples

Pourquoi construire un module en parallèle plutôt qu'une réécriture complète dès le départ ?

Un module en parallèle prouve la viabilité avec un risque minimal. S'il échoue, le système existant continue inchangé et vous avez perdu quelques semaines, pas un trimestre. S'il réussit, il produit ce qu'une proposition ne peut jamais offrir : de vrais chiffres avant-après issus de la production, si bien que le dossier d'affaires de la réécriture complète s'écrit tout seul. Cette approche fonctionne particulièrement bien lorsque la direction a été échaudée par des tentatives de réécriture antérieures, car elle lui permet de financer une seule tranche réduite et réversible et de juger le résultat avant de s'engager sur le reste. C'est l'idée du strangler fig appliquée à l'approbation du budget, pas seulement au code.

Comment garantissez-vous que le nouveau module reste compatible avec la base de données héritée ?

Le nouveau module lit et écrit dans la même base de données en utilisant le même schéma que l'application héritée. Nous ajoutons de nouvelles colonnes là où c'est nécessaire, mais ne renommons ni ne modifions jamais les existantes, de sorte que l'ancien code retrouve ses données exactement là où il les attend. La compatibilité est vérifiée à chaque déploiement, et comme les deux systèmes partagent une source de vérité unique, il n'y a aucun travail de synchronisation susceptible de dériver ni de seconde copie des données à réconcilier. L'application héritée continue de fonctionner exactement comme avant, ce qui rend l'interrupteur et le retour arrière instantané sûrs.

Et si le schéma de la base de données héritée est trop désordonné pour travailler avec ?

Dans ce cas, le schéma était désordonné mais fonctionnel, nous avons donc travaillé directement avec lui. Lorsqu'un schéma est réellement inutilisable, nous construisons une couche d'adaptation, une couche anticorruption, qui traduit entre la structure héritée et un modèle de données interne propre, de sorte que le nouveau code raisonne sur des entités bien nommées et cohérentes tout en lisant et écrivant en dessous dans les tables héritées. Cela ajoute une couture de traduction à entretenir, mais cela préserve la compatibilité totale et empêche le schéma désordonné de s'infiltrer dans le nouveau système.

Combien de temps a pris la réécriture complète après le module de preuve ?

La réécriture complète a été cadrée comme une série de sprints successifs, chacun retirant un seul module hérité, exactement comme l'onboarding. La planification est venue ensuite, puis la facturation, puis les demandes d'assurance, chaque module étant prouvé en parallèle et basculé seulement une fois ses chiffres confirmés. Le délai total a été d'environ six mois, livré par incréments de 30 jours se terminant chacun par un logiciel fonctionnel et déployé plutôt que par un rapport d'avancement. Cette mise en séquence faisait que le système hérité restait toujours pleinement opérationnel, que de la valeur arrivait chaque mois, et qu'il n'y a jamais eu une seule bascule à haut risque à redouter.

ParFondateur et Imaginator

Publié