Réponse directe : un logiciel développé par une seule personne expose votre entreprise à cinq risques : arrêt de la maintenance si cette personne disparaît, qualité sans relecture, failles de sécurité non détectées, propriété du code incertaine et dépendance contractuelle. Le risque se réduit par le code remis, la documentation, la relecture et une équipe restreinte.

Vous avez confié, ou vous envisagez de confier, un outil essentiel à votre activité à un développeur indépendant ou à un salarié seul sur le projet. Ce choix n'a rien de condamnable : beaucoup de logiciels très utiles ont été écrits par une seule personne, et un bon indépendant livre souvent plus vite et moins cher qu'une structure lourde. Ce guide s'adresse aux dirigeants et aux responsables métier de PME qui veulent mesurer le risque réel, décider en connaissance de cause et se protéger par des clauses et des pratiques précises. Nous expliquons les cinq risques, la façon de les mesurer, ce qui les réduit et dans quels cas un indépendant reste le bon choix.

Pourquoi un développeur unique est-il un risque pour l'entreprise ?

Le risque d'un développeur unique tient à une seule idée : toute la connaissance du logiciel réside dans une tête. Les ingénieurs ont un nom pour cela, le « truck factor » ou « bus factor » : le nombre de personnes qu'il faudrait retirer d'un projet, en le supposant frappé par un camion, pour le rendre impossible à maintenir. Un projet dont le truck factor vaut 1 dépend entièrement d'une personne.

Ce risque n'est pas réservé aux petits logiciels d'entreprise. Une équipe de recherche de l'Université fédérale de Minas Gerais (Brésil) a mesuré le truck factor de 133 systèmes populaires hébergés sur GitHub : 65 % d'entre eux ont un truck factor de 2 ou moins (Avelino, Passos, Hora et Valente, ICPC 2016). Si des projets suivis par des centaines de contributeurs dépendent à ce point d'une ou deux personnes, un logiciel interne de PME développé par un seul indépendant se situe presque toujours au niveau 1.

Le « truck factor » : une personne contre une équipe

Développeur unique (truck factor de 1)

A

Une absence de trois mois, un départ ou une maladie suffisent à geler les évolutions et les corrections. Personne d'autre ne connaît le code, les accès ni les choix de conception.

Équipe restreinte avec relecture (truck factor de 2 ou plus)

ABC

Deux personnes au moins ont lu et modifié chaque partie du code. L'absence de l'une ralentit le projet sans l'arrêter, et la documentation se rédige parce que l'autre en a besoin.

Schéma illustratif. Le truck factor d'un projet réel se mesure en comptant, par module, le nombre de personnes qui le comprennent et savent le modifier.

La question à vous poser n'est donc pas « mon développeur est-il compétent ? », mais « que se passe-t-il le jour où il n'est plus là ? ». La compétence ne protège pas de la maladie, d'un changement de vie, d'une réorientation professionnelle ou d'un contrat plus avantageux ailleurs. Un indépendant qui part du jour au lendemain ne commet aucune faute : il exerce sa liberté. Le risque pèse sur vous, parce que vous n'avez rien prévu.

Quels sont les cinq risques d'un logiciel développé par une seule personne ?

Cinq risques se cumulent quand une seule personne écrit et connaît le logiciel. Le tableau ci-dessous les classe selon leur gravité habituelle et la facilité à les réduire. Les sections suivantes détaillent chacun d'eux.

Matrice des cinq risques d'un développeur unique

Risque
Gravité
Fréquence
Facilité à réduire
Continuité
Élevée
Moyenne
Bonne
Qualité sans relecture
Moyenne
Élevée
Moyenne
Sécurité
Élevée
Moyenne
Moyenne
Propriété du code
Élevée
Moyenne
Bonne
Dépendance contractuelle
Moyenne
Élevée
Bonne

Classement qualitatif établi par Nerolia d'après les projets repris ou audités, pas une statistique d'étude.

Risque 1 : la continuité

La continuité est le risque le plus évident. Quand le développeur s'arrête, les corrections de bugs, les évolutions réglementaires et les adaptations à un nouveau navigateur s'arrêtent avec lui. Un logiciel qui n'évolue plus n'est pas immédiatement inutilisable, mais il se dégrade : une mise à jour du système d'exploitation, un certificat qui expire ou une interface externe qui change casse un morceau, et personne ne sait le réparer. Reprendre un code qu'on n'a pas écrit, sans documentation, prend de plusieurs jours à plusieurs semaines selon sa taille, et ce temps se paie.

Risque 2 : la qualité sans relecture

Un développeur seul se relit lui-même, et on repère mal ses propres erreurs. La section suivante détaille ce point, car c'est le risque le plus sous-estimé : il se manifeste tous les jours, alors que la disparition du développeur n'arrive qu'une fois.

Risque 3 : la sécurité

La sécurité souffre de l'absence de regard extérieur. Un développeur seul décide seul de la gestion des mots de passe, de la validation des formulaires, du stockage des sauvegardes et des mises à jour des bibliothèques. Il concentre aussi les accès : serveur, base de données, nom de domaine, comptes de messagerie transactionnelle. Une mauvaise pratique, comme un mot de passe d'administrateur partagé par message ou une sauvegarde stockée sur le même serveur que la base, reste en place tant que personne n'est là pour la contester. Les données personnelles que le logiciel traite relèvent de votre responsabilité de responsable de traitement au sens du RGPD, quel que soit le nombre de personnes qui ont écrit le code.

Risque 4 : la propriété du code

La propriété du code est le risque juridique. Sans clause écrite de cession des droits d'auteur sur le logiciel, le développeur reste titulaire de ses droits sur le code qu'il a écrit, même si vous l'avez payé. Vous disposez alors d'un droit d'usage dont l'étendue dépend de ce que le contrat prévoit, et vous ne pouvez pas toujours faire reprendre le code par un autre prestataire. Un indépendant de bonne foi accepte en général de céder les droits, à condition que la question soit posée avant la signature. Notre guide sur le choix d'un prestataire pour une application métier détaille les clauses à exiger.

Risque 5 : la dépendance contractuelle

La dépendance contractuelle apparaît quand tout passe par une seule relation : le développeur détient les accès, connaît les tarifs de l'hébergeur et fixe seul le calendrier. Il peut augmenter ses tarifs, réduire sa disponibilité ou refuser une évolution, et vous n'avez pas d'alternative immédiate. Ce n'est pas de la malveillance, c'est un rapport de force qui se crée mécaniquement. La parade est contractuelle : prix de maintenance fixé, durée de préavis, remise des accès et du code à la demande.

Ces risques ne se matérialisent pas forcément. Mais leur coût, le jour où l'un d'eux se réalise, dépasse largement celui des précautions. Sur 1 471 projets informatiques étudiés, Bent Flyvbjerg et Alexander Budzier (Université d'Oxford) relèvent un dépassement moyen de budget de 27 %, et plus d'un projet sur six avec un dépassement de 200 % (MIT Technology Review, 2013). Ces dérapages extrêmes viennent de risques qu'on n'a pas vus venir.

Que change la relecture du code par une deuxième personne ?

La relecture par une deuxième personne détecte des erreurs que l'auteur ne voit plus, et elle diffuse la connaissance du code entre au moins deux têtes. C'est la pratique la plus efficace pour faire passer un projet d'un truck factor de 1 à 2. Elle est devenue la norme chez les grands éditeurs : l'étude « Modern Code Review: A Case Study at Google » analyse les journaux de revue de 9 millions de modifications de code au sein de l'entreprise (Sadowski et al., ICSE-SEIP 2018). Chaque modification y passe par un regard extérieur avant d'entrer dans le code commun.

Eric S. Raymond, essayiste et figure du mouvement open source, a formulé le principe dès les années 1990 dans son essai sur le développement du noyau Linux, à la leçon 8 :

« Given a large enough beta-tester and co-developer base, almost every problem will be characterized quickly and the fix obvious to someone. »

Eric S. Raymond, auteur de The Cathedral and the Bazaar (leçon 8, version 3.0, 2002, en anglais)

Raymond parle d'un grand nombre de relecteurs, ce que ni un indépendant ni une PME n'auront. Le principe reste valable à petite échelle : un seul relecteur compétent attrape une part importante des erreurs qu'un auteur seul laisse passer. Un développeur unique n'a personne pour jouer ce rôle, sauf à l'organiser volontairement : demander à un second ingénieur de relire les modifications critiques, faire auditer le code une fois par an, ou travailler avec un prestataire qui fait relire chaque lot en interne.

La relecture a un effet secondaire précieux : elle oblige à écrire du code lisible et des messages clairs, parce que quelqu'un d'autre doit le comprendre. Un logiciel relu se reprend plus facilement qu'un logiciel écrit en solitaire, même quand l'auteur initial a quitté le projet.

Comment mesurer votre dépendance à une seule personne ?

Vous mesurez votre dépendance en posant huit questions que vous pouvez vérifier vous-même, sans compétence technique. Si vous répondez « non » à trois d'entre elles ou plus, votre logiciel est en situation de risque élevé. La liste ci-dessous vaut aussi comme demande à adresser à votre développeur actuel.

Checklist de dépendance : huit questions à vous poser

1
Avez-vous le code source ? Une copie complète, à jour, dans un dépôt dont vous êtes propriétaire, pas seulement sur le poste du développeur.
2
Détenez-vous les accès ? Serveur, base de données, nom de domaine, compte d'hébergeur, services tiers : tous sont à votre nom ou administrables par vous.
3
Le contrat cède-t-il les droits ? Une clause écrite précise les droits cédés sur le logiciel, sa durée et son périmètre.
4
Existe-t-il une documentation ? Installation, architecture, règles de gestion, procédure de déploiement : un ingénieur extérieur doit pouvoir démarrer avec elle.
5
Une deuxième personne a-t-elle déjà lu le code ? Un ingénieur autre que l'auteur sait déployer et corriger le logiciel.
6
Des sauvegardes sont-elles testées ? Une restauration complète a été essayée au moins une fois, sur un autre serveur que celui de production.
7
Des tests automatiques existent-ils ? Ils vérifient qu'une modification ne casse pas ce qui fonctionnait.
8
Le préavis de départ est-il écrit ? Une durée, une remise des livrables et un temps de transmission sont prévus au contrat.

Trois « non » ou plus : le logiciel dépend d'une seule personne au sens pratique, même si elle est irréprochable.

Le point 2, les accès, mérite une insistance. Dans les logiciels que nous reprenons, c'est le plus fréquent des blocages : le nom de domaine est enregistré au nom personnel du développeur, le serveur est facturé sur son compte, et le service d'envoi d'e-mails est rattaché à son adresse. Rien n'est volé, tout est simplement à sa place plutôt qu'à la vôtre. Le transfert d'un nom de domaine ou d'un compte d'hébergeur prend des jours, parfois des semaines, et exige la coopération de la personne qui détient l'accès.

Un logiciel qui dépend d'une seule personne ? Découvrez notre offre de développement de logiciel sur mesure : lots livrés en 10 jours, code et accès remis, devis fixe sous 48 h.

Comment réduire le risque sans changer de prestataire ?

Vous réduisez le risque en ajoutant, autour du développeur actuel, cinq pratiques qui coûtent peu et s'installent en quelques semaines. Aucune ne demande de changer de prestataire, et un bon indépendant les accepte volontiers parce qu'elles le protègent aussi : elles prouvent que le travail est livré proprement.

Mettre le code et les accès chez vous

Créez un dépôt de code sous le nom de votre entreprise et demandez au développeur d'y publier le code à chaque livraison. Mettez le nom de domaine, l'hébergement et les services tiers sous un compte administré par votre entreprise, avec le développeur comme utilisateur invité. Cette seule mesure transforme une dépendance totale en simple collaboration : si le développeur part, vous gardez tout.

Exiger une documentation vivante

Une documentation utile tient en peu de pages : comment installer le logiciel, comment le déployer, quelles sont ses parties, quelles règles de gestion il applique et quels services externes il appelle. Elle se met à jour à chaque lot. Demandez au développeur de la relire avec un tiers : si un ingénieur extérieur la suit sans aide, elle est suffisante.

Faire relire et auditer le code

Un audit de code par un second ingénieur coûte quelques jours et produit un rapport qui liste les points faibles : dépendances obsolètes, absence de tests, failles courantes. Il tient lieu de relecture ponctuelle quand une relecture continue n'est pas envisageable. Répétez-le tous les ans ou après chaque évolution majeure.

Installer des tests automatiques

Des tests automatiques vérifient à chaque modification que les fonctions essentielles marchent encore. Ils servent de filet de sécurité à tout futur repreneur : il peut modifier le code sans craindre de casser une règle qu'il ignore. Un logiciel sans tests ne se reprend qu'avec une extrême prudence.

Identifier un second ingénieur dès maintenant

Choisissez dès aujourd'hui la personne ou la société qui reprendrait le logiciel en cas d'urgence, et faites-lui faire une prise en main : lecture du code, déploiement sur un environnement de test, restauration d'une sauvegarde. Une prise en main prévue se déroule en quelques jours. Une reprise en urgence, avec un logiciel qui s'est arrêté, se déroule sous pression et coûte plus cher.

Quelles clauses de contrat protègent votre logiciel ?

Six clauses protègent votre logiciel quand le développeur est seul, et un contrat qui les contient réduit déjà l'essentiel du risque juridique et contractuel. Si vous travaillez déjà avec un indépendant sans contrat détaillé, ajoutez-les par avenant. Notre guide sur les critères de choix d'un prestataire les replace dans un contrat complet.

ClauseCe qu'elle prévoitRisque couvert
Cession des droitsCession écrite des droits d'exploitation sur le logiciel, avec périmètre et duréePropriété du code
Remise du codeLivraison du code source, des scripts de déploiement et de la base à chaque lotContinuité, dépendance
RéversibilitéObligation d'aider à la reprise par un tiers, pendant une durée fixéeContinuité
PréavisDurée minimale de préavis et temps de transmission en cas de départContinuité
AccèsComptes, serveurs et noms de domaine enregistrés au nom du clientDépendance, sécurité
MaintenancePérimètre, délai de réponse et tarif de la maintenance fixés d'avanceDépendance contractuelle

Ces clauses relèvent du contrat entre vous et votre prestataire. Faites-les valider par un juriste pour votre situation.

La clause de réversibilité est la plus sous-estimée. Elle oblige le prestataire, quand le contrat s'arrête, à fournir ce qui permet à un autre de reprendre : code, documentation, jeu de données et quelques jours d'accompagnement. Sans elle, un départ conflictuel peut transformer le logiciel en boîte noire. Un indépendant sérieux n'y voit aucun obstacle, parce que son travail respecte déjà ces points.

Indépendant ou équipe : que choisir selon votre projet ?

Le choix entre un indépendant et une équipe dépend de la criticité du logiciel et de sa durée de vie, pas d'un principe. Un indépendant reste le bon choix dans plusieurs cas, et le dire fait partie d'un conseil honnête. Pour un outil peu critique, que vous pouvez remplacer en quelques semaines, un bon développeur seul livre vite, à coût de structure faible, avec un interlocuteur unique.

CritèreDéveloppeur indépendantÉquipe restreinte et dédiée
InterlocuteurUnique et directUn référent, plusieurs ingénieurs qui connaissent le code
Continuité si absenceArrêt totalRalentissement, pas d'arrêt
Relecture du codeÀ organiser volontairementIntégrée au fonctionnement
Couverture des compétencesCelles d'une personneWeb, base de données, sécurité, interface
Coût de structureFaiblePlus élevé, compensé par la continuité
Adapté àOutil peu critique, projet court, prototypeLogiciel de production, projet long, données sensibles

La règle pratique : plus votre activité dépend du logiciel et plus il doit durer, plus l'équipe se justifie. Un outil qui gère vos commandes, vos factures ou vos données de santé ne se confie pas à une personne sans filet. Un script qui met en forme un export mensuel s'y confie sans difficulté.

La taille de l'équipe ne suffit pas pour autant. Une équipe de dix personnes où chaque module appartient à un seul ingénieur reproduit le risque du développeur unique, en multiple. Ce qui compte, c'est que deux personnes au moins comprennent chaque partie. C'est pourquoi nous travaillons à Nerolia avec des équipes restreintes et dédiées à chaque lot, où le même ingénieur ne reste pas seul sur un module : le lot est relu avant livraison, et le dossier est transmis à un second ingénieur du cabinet.

Que faire quand le développeur est déjà parti ?

Quand le développeur est déjà parti, la priorité est de récupérer le contrôle avant de rien modifier. Procédez dans cet ordre : récupérez les accès, sécurisez une copie du code et des données, faites réaliser un audit, puis décidez entre reprise et reconstruction. Chaque étape protège la suivante.

  1. Récupérez les accès. Contactez l'hébergeur, le registrar du nom de domaine et les services tiers, preuves d'identité de l'entreprise à l'appui. Changez les mots de passe administrateur dès que vous en avez le contrôle.
  2. Copiez le code et la base. Faites une sauvegarde complète hors du serveur de production, et vérifiez qu'elle se restaure sur un autre serveur.
  3. Faites auditer le logiciel. Un ingénieur extérieur évalue la lisibilité du code, l'état des dépendances, la présence de tests et les failles visibles. L'audit tranche entre reprise et reconstruction.
  4. Reprenez ou reconstruisez, par lots. Un code propre se reprend. Un code illisible se remplace module par module, sur le modèle de la bascule progressive décrite dans notre guide sur la migration d'une base Access ou FileMaker vers une application web.

Une reprise bien menée prend généralement un à trois lots, de l'audit à la remise en état. L'enjeu de la première semaine est de ne rien casser : le logiciel tourne, des utilisateurs s'en servent, et la priorité est de le stabiliser avant de l'améliorer.

Pourquoi Nerolia pour votre logiciel sur mesure

Nerolia est une agence de développement française dont l'équipe d'ingénieurs est issue de Polytechnique, CentraleSupélec, l'ENSAE, HEC et l'ESSEC, avec des expériences chez McKinsey et BCG. Chaque lot est confié à une équipe restreinte et dédiée, relu en interne avant livraison, et livré avec le code, la documentation et les accès.

  • Un devis fixe sous 48 h, découpé en lots.
  • 90 % des projets livrés en moins de 10 jours, avec 30 jours de support inclus.
  • Deux ingénieurs au moins sur chaque lot : relecture avant livraison, connaissance partagée du code.
  • Un code qui vous appartient : code source, base de données et documentation remis, sans abonnement obligatoire.
  • Une conformité RGPD native : hébergement OVH en France, modèles Mistral pour les fonctions d'IA.
  • Des références exigeantes : AXA, Stanley Black & Decker, le Collège National d'Occlusodontologie et l'Union européenne nous ont confié des projets.

Sécuriser mon logiciel sur mesure

Décrivez votre situation. Nerolia vous répond avec un devis fixe sous 48 h.

Devis fixe sous 48 h · Lots livrés en 10 jours · Hébergement OVH en France

Parlez-nous de votre projet →

Questions fréquentes sur les risques d'un logiciel développé par une seule personne

Quels sont les risques d'un logiciel développé par un seul développeur ?

Cinq : arrêt de la maintenance si le développeur disparaît, qualité sans relecture, failles de sécurité non détectées, propriété du code incertaine sans cession écrite, et dépendance contractuelle quand il détient les accès.

Qu'est-ce que le « truck factor » d'un logiciel ?

C'est le nombre de personnes qu'il faudrait retirer d'un projet pour le rendre impossible à maintenir. Sur 133 systèmes GitHub populaires, 65 % ont un truck factor de 2 ou moins (Avelino et al., ICPC 2016).

À qui appartient le code écrit par un développeur indépendant ?

Au développeur, sauf cession écrite des droits d'auteur à votre entreprise. Exigez dans le contrat une clause de cession qui précise les droits cédés, leur durée et leur périmètre, et la remise du code source à chaque livraison.

Comment réduire la dépendance à mon développeur actuel ?

Mettez le code et les accès à votre nom, exigez une documentation à jour, faites relire ou auditer le code, ajoutez des tests automatiques et identifiez un second ingénieur capable de reprendre le logiciel.

Un développeur indépendant reste-t-il un bon choix ?

Oui pour un outil peu critique, un prototype ou un projet court. Pour un logiciel de production qui doit durer, une équipe restreinte où au moins deux personnes connaissent chaque module protège la continuité.

À lire aussi