Yury Pukhov, YuSMP Group
Yury Pukhov CEO & Mobile Engineering Lead, YuSMP Group
Ajouter YuSMP comme source préférée sur Google
TL;DR : Le support de développement logiciel maintient une application en production fonctionnelle, sécurisée et utile : incidents, correction des défauts, mises à jour des dépendances, nouvelles plateformes et petites évolutions. Planifiez-le avant le lancement, formalisez les rôles L1 à L3 et le SLA, et prévoyez 15 à 25 % du coût initial par an.

Le support de développement logiciel désigne le travail d'ingénierie et de service continu qui maintient une application sur mesure fonctionnelle, sécurisée et utile après sa mise en production. Il couvre le traitement des demandes des utilisateurs, la correction des défauts, l'application des correctifs de sécurité, l'adaptation aux nouveaux systèmes d'exploitation, navigateurs et API, ainsi que la livraison de petites améliorations. Le lancement marque le début de ce travail, pas la fin du projet.

L'essentiel de la vie d'un produit se déroule après sa sortie, et l'essentiel de son coût aussi. Les équipes qui planifient le support tôt gardent des incidents courts et des mises à niveau routinières. Celles qui le traitent après coup le découvrent généralement sous forme de crise : un certificat expiré, un framework qui ne reçoit plus de correctifs de sécurité ou un développeur clé parti avec la connaissance du système. Lorsque les correctifs coûtent plus qu'ils ne rapportent, le support devient une question de modernisation, et les services de modernisation logicielle deviennent l'étape suivante plutôt qu'une nouvelle série de corrections.

Ce guide explique ce que comprend le support, en quoi il diffère de la maintenance, quels niveaux de support et quelles clauses de SLA formaliser par écrit, comment les prestataires le facturent et à quoi ressemble un budget réaliste en 2026.

Qu'est-ce que le support de développement logiciel ?

Le support de développement logiciel est un service, contractualisé ou interne, qui maintient un logiciel en production disponible et correct pour ses utilisateurs, et qui modifie le code lorsque c'est nécessaire. En pratique, il combine un volet opérationnel (supervision, réponse aux incidents, aide aux utilisateurs) et un volet ingénierie (corrections de bugs, mises à jour et petites fonctionnalités).

Un périmètre de support type comprend :

  • Supervision et alertes sur la disponibilité, les erreurs, les performances et les événements de sécurité.
  • Gestion des incidents avec des niveaux de gravité, des délais de réponse et des circuits d'escalade convenus.
  • Correction des défauts signalés par les utilisateurs ou détectés par la supervision.
  • Mises à jour de sécurité et des dépendances, y compris les correctifs des bibliothèques, frameworks, runtimes et systèmes d'exploitation.
  • Travaux de compatibilité lorsque les navigateurs, les versions des OS mobiles, les services cloud ou les API tierces évoluent.
  • Petites évolutions demandées par les utilisateurs ou le métier, livrées dans des versions régulières.
  • Mise à jour de la documentation et de la base de connaissances, pour que le prochain ingénieur ne parte pas de zéro.

Maintenance logicielle et support logiciel : quelle différence ?

La maintenance logicielle modifie le code, tandis que le support logiciel assure le bon fonctionnement quotidien du système et de ses utilisateurs. La maintenance relève surtout d'un travail d'ingénierie planifié. Le support relève surtout d'un service réactif assorti d'engagements de délais de réponse. La plupart des contrats regroupent les deux, mais les distinguer aide à chiffrer et à staffer chaque volet correctement.

AspectSupport logicielMaintenance logicielle
Objectif principalGarder le système disponible et les utilisateurs opérationnelsGarder le code correct, sécurisé et à jour
Travail typeSupervision, tri des incidents, aide aux utilisateurs, solutions de contournementCorrections de bugs, mises à niveau, refactoring, petites fonctionnalités
DéclencheurTickets, alertes, pannesBacklog, plan de versions, dates de fin de vie
Mesuré parDélais de réponse et de résolution, disponibilitéCadence de livraison, taux de défauts, ancienneté des dépendances
Qui s'en chargeHelp desk, ingénieurs support, développeurs d'astreinteDéveloppeurs, ingénieurs QA, ingénieurs DevOps
Mode de tarificationForfait selon les heures de couverture ou au ticketForfait horaire, régie ou équipe dédiée

Quels sont les types de maintenance logicielle ?

La norme internationale ISO/IEC/IEEE 14764:2022 classe la maintenance logicielle en cinq types : corrective, préventive, adaptative, perfective et additive. Les maintenances corrective et préventive sont des corrections ; les maintenances adaptative, perfective et additive sont des améliorations. Nommer le type de chaque ticket rend le budget visible et empêche les correctifs urgents d'absorber discrètement tout le travail planifié.

TypeCe qu'il faitExemples types
CorrectiveCorrige les problèmes découverts après la livraisonUne erreur au paiement, un rapport cassé, un plantage sur un modèle d'appareil
PréventiveDétecte et élimine les défauts latents avant qu'ils ne provoquent des pannesCorriger une fuite mémoire repérée par la supervision, ajouter une validation des saisies manquante
AdaptativeMaintient le produit fonctionnel lorsque son environnement changeMises à niveau du runtime, nouvelles versions d'iOS ou d'Android, changement de version d'une API de paiement
PerfectiveAméliore les performances, l'ergonomie ou la maintenabilitéRequêtes plus rapides, écrans plus clairs, refactoring d'un module fragile
AdditiveAjoute de nouvelles fonctions au produit en productionUn nouveau format d'export, un rôle utilisateur supplémentaire, une nouvelle intégration

Un budget de support sain ne passe pas tout en maintenance corrective. Si presque chaque heure sert à réparer ce qui a cassé, le système accumule de la dette technique et le travail préventif et adaptatif est sacrifié. Une règle utile consiste à réserver une part fixe de chaque mois, souvent un cinquième à un tiers des heures, aux tâches préventives et adaptatives, et à la protéger des demandes ponctuelles.

Pourquoi un logiciel a-t-il besoin de support quand rien n'est cassé ?

Un logiciel a besoin de support même lorsqu'il fonctionne, car tout ce qui l'entoure continue d'évoluer : les runtimes arrivent en fin de vie, les bibliothèques publient des correctifs de sécurité, les plateformes changent leurs règles et les régulateurs relèvent leurs exigences. Un code que l'on ne touche pas ne reste pas sûr ; il devient lentement non supporté.

Les dates de fin de vie de 2026 montrent à quelle vitesse cela arrive. Chacune de ces plateformes était un choix courant pour des applications développées il y a seulement quelques années :

PlateformeFin du support communautaire ou éditeurConséquence pour une application en production
Node.js 2030 avril 2026Plus aucune version de sécurité publiée par le projet Node.js
Python 3.10Octobre 2026Plus aucun correctif de sécurité de l'équipe principale de Python
.NET 8 (LTS) et .NET 910 novembre 2026Plus aucun correctif de Microsoft ; migrer vers .NET 10 LTS

Le code tiers représente l'exposition la plus importante. Le rapport Open Source Security and Risk Analysis 2025 de Black Duck a constaté que 86 % des bases de code commerciales auditées contenaient des composants open source vulnérables, 91 % des composants obsolètes et 90 % des composants en retard de plus de quatre ans. L'essentiel du code d'une application moderne est open source : les mises à jour des dépendances sont donc une tâche centrale du support, et non une option.

La réglementation va dans le même sens. Le Cyber Resilience Act de l'UE (Regulation (EU) 2024/2847) attend des fabricants de produits comportant des éléments numériques qu'ils gèrent les vulnérabilités et livrent des mises à jour de sécurité pendant une période de support définie, en général d'au moins cinq ans, et ses obligations de signalement des vulnérabilités s'appliquent à partir du 11 septembre 2026. Si vous vendez des logiciels dans l'UE, un processus de support devient une obligation légale autant qu'une bonne pratique.

Ingénieur portant des gants de travail remplaçant un module matériel dans une baie de serveurs ouverte d'un centre de données

Que sont les niveaux de support L1, L2 et L3 ?

L1, L2 et L3 sont des niveaux d'escalade qui orientent chaque problème vers la personne la moins coûteuse capable de le résoudre. Le L1 traite les questions des utilisateurs et les problèmes connus, le L2 analyse les problèmes applicatifs et de configuration, et le L3 modifie le code. Une règle empirique répandue dans le secteur veut qu'un L1 bien organisé, doté d'une bonne base de connaissances, clôture la plupart des tickets, que le L2 en traite une part plus réduite et que seule une petite fraction parvienne aux développeurs.

NiveauQuiTraiteRésultat type
L1Spécialistes du help desk ou du service deskAccès, questions d'utilisation, problèmes connus, réception et tri des ticketsRéponse, solution de contournement ou escalade avec tous les détails
L2Ingénieurs support applicatifLogs, corrections de données, configuration, reproduction des défautsCause racine identifiée, données ou configuration corrigées, rapport de bug pour le L3
L3Développeurs, ingénieurs DevOps et QADéfauts de code, performances, infrastructure, correctifs de sécuritéCorrectif testé et livré, revue post-incident

Les petits produits se passent souvent d'un L1 distinct et laissent le product owner ou un administrateur interne répondre aux utilisateurs, le partenaire de développement couvrant le L2 et le L3. Les systèmes plus importants ou orientés clients ont généralement besoin des trois niveaux, et souvent d'une couverture 24/7 réservée aux incidents les plus critiques.

Que doit contenir un SLA de support logiciel ?

Un SLA de support logiciel doit définir les niveaux de gravité, les heures de couverture, les objectifs de réponse et de résolution par niveau de gravité, les contacts d'escalade et la manière dont la performance est rapportée. Sans ces clauses, chaque incident devient une négociation sur l'urgence. Les objectifs ci-dessous constituent un point de départ type pour une application métier, et non une norme universelle.

GravitéDéfinitionPremière réponseObjectif de rétablissement du service
P1 CritiqueSystème indisponible ou données menacées pour tous les utilisateurs, sans contournementSous 1 heure, 24/7 si prévu au contratContournement en quelques heures, correctif définitif dès que possible
P2 ÉlevéeFonction clé cassée pour de nombreux utilisateurs, contournement difficileSous 4 heures ouvréesSous 1 à 2 jours ouvrés
P3 MoyenneFonction dégradée, un contournement existeLe jour ouvré suivantDans la prochaine version planifiée
P4 FaibleProblème cosmétique, question ou idée d'améliorationSous quelques jours ouvrésPlanifié par priorité dans le backlog

Au-delà du tableau des niveaux de gravité, un SLA opérationnel couvre généralement :

  1. Le périmètre. Quelles applications, quels environnements, intégrations et groupes d'utilisateurs sont couverts, et ce qui est explicitement exclu.
  2. Les heures de couverture. Heures ouvrées dans un fuseau horaire nommé, horaires étendus ou 24/7, et les niveaux de gravité concernés par chacun.
  3. Les canaux. Comment signaler les problèmes (outil de ticketing, e-mail, téléphone pour les P1) et quelles informations un signalement doit contenir.
  4. L'objectif de disponibilité. Si le prestataire gère aussi l'hébergement, l'engagement de disponibilité et la manière dont les fenêtres de maintenance planifiée sont exclues.
  5. Les heures et les demandes de changement. Heures mensuelles incluses, traitement des heures non consommées et validation du travail au-delà du forfait.
  6. Le reporting. Un rapport mensuel avec le nombre de tickets par gravité et par type, le respect du SLA et les problèmes récurrents.
  7. Les obligations de sécurité. Délais de correction des vulnérabilités critiques et modalités de notification des incidents de sécurité.
  8. La sortie et la passation. Accès au code, aux identifiants et à la documentation à la fin du contrat.

La plupart de ces clauses ont aussi leur place dans le contrat-cadre ; notre guide du contrat de développement logiciel traite de la propriété intellectuelle, des garanties et des conditions de résiliation qui accompagnent le SLA.

Comment le support logiciel est-il facturé ?

Le support logiciel est généralement facturé sous forme de forfait mensuel, en régie, via une équipe dédiée ou au ticket. Le bon modèle dépend de la prévisibilité de votre charge de travail et de l'ampleur des évolutions du produit que vous prévoyez après le lancement.

ModèleFonctionnementIdéal pourPoints de vigilance
Forfait mensuelMontant fixe pour les heures de couverture, le SLA et un volume d'heures d'ingénierieProduits stables avec des évolutions régulières et modéréesHeures non consommées, règles floues en cas de dépassement
RégiePaiement des heures réellement passées à un taux convenuCharges irrégulières, première période après le lancementAucun délai de réponse garanti sauf s'il est ajouté
Équipe dédiéeIngénieurs nommés travaillant sur votre produit à temps plein ou partielProduits qui évoluent encore vite, avec une roadmapPayer de la capacité pendant les mois calmes
Au ticketPrix fixe par ticket résolu, généralement selon le niveauTravail de help desk L1 et L2 à fort volumeRarement adapté aux modifications de code ; incitation à clôturer vite
HybridePetit forfait pour le SLA et la supervision, le développement étant facturé à partLa plupart des applications métier sur mesureExige des frontières claires entre les deux volets

Les arbitrages reflètent ceux des contrats de développement en général, que nous comparons en détail dans régie, forfait ou équipe dédiée.

Combien coûte le support de développement logiciel en 2026 ?

Le support de développement logiciel coûte généralement 15 à 25 % du coût de développement initial par an, une fourchette citée par de nombreux guides de prix d'agences. Les outils internes simples se situent en bas de la fourchette, tandis que les systèmes fortement intégrés, réglementés ou en évolution rapide se situent souvent en haut de la fourchette ou au-delà.

Les principaux facteurs de coût sont :

  • La couverture. Un support aux heures ouvrées coûte bien moins cher qu'une astreinte 24/7 pour les incidents P1.
  • La taille et l'âge de la base de code. Les systèmes plus grands et plus anciens comportent plus de dépendances et plus de dette technique.
  • Les intégrations. Chaque prestataire de paiement, ERP, CRM ou API publique est une source de changements cassants.
  • Les plateformes. Les applications mobiles exigent des mises à jour annuelles liées aux OS ; une application web plus iOS et Android triple le travail de compatibilité.
  • La conformité. HIPAA, PCI DSS, SOC 2 ou les règles de l'UE ajoutent des délais de correction, des journaux d'audit et la collecte de preuves.
  • L'automatisation des tests. De bons tests automatisés rendent chaque version moins chère ; sans eux, chaque correctif exige une régression manuelle.
  • La qualité de la documentation et de la passation. Une nouvelle équipe sans documentation passe des semaines à apprendre avant de pouvoir corriger quoi que ce soit.

Exemple chiffré : budget de support pour une application à $120,000

Un exemple chiffré simple : une application métier sur mesure dont le développement a coûté $120,000 nécessiterait, à 15 à 25 %, environ $18,000 à $30,000 par an, soit environ $1,500 à $2,500 par mois. À un taux horaire de $100, cela représente environ 15 à 25 heures d'ingénierie par mois, ce qui suffit pour la supervision, les correctifs, quelques corrections et une petite version. Un produit qui évolue encore rapidement a besoin de davantage, généralement d'un ingénieur dédié à temps partiel ou à temps plein.

À titre de référence pour nos propres tarifs : le support et l'évolution continue d'un produit SaaS en production commencent à $1,400 par mois sur notre page développement SaaS, et les ingénieurs en renfort d'équipe commencent à $100 de l'heure. Les produits mobiles ont leur propre profil de coûts en raison des versions annuelles des OS et des règles des stores ; consultez notre guide sur le coût de maintenance d'une application mobile.

Faut-il garder le support logiciel en interne ou l'externaliser ?

Gardez le support en interne lorsque le logiciel est un élément différenciant clé et que vous disposez déjà d'ingénieurs qui le connaissent ; externalisez-le lorsque vous avez besoin d'une couverture, de compétences ou d'une capacité qu'une petite équipe interne ne peut pas fournir. Beaucoup d'entreprises optent pour un modèle hybride, avec un product owner et un L1 internes, et un partenaire externe pour le L2, le L3 et la couverture hors heures ouvrées.

CritèreL'interne convientL'externalisation convientL'hybride convient
Connaissance du produitL'équipe d'origine est toujours en posteLe produit a été développé par une agence, aucune équipe interne n'a existéUne partie de la connaissance en interne, des lacunes en profondeur
Couverture nécessaireHeures ouvrées uniquementHoraires étendus ou 24/724/7 pour les P1 uniquement
Charge de travailStable et suffisante pour des postes à temps pleinIrrégulière ou trop faible pour des recrutements à temps pleinSocle stable avec des pics
CompétencesUne seule stack, bien couvertePlusieurs stacks, besoin de DevOps, de sécurité et de QAStack principale en interne, spécialistes en externe
Maîtrise des coûtsSalaires fixes quel que soit le nombre de ticketsPaiement de la couverture et des heures consomméesSocle interne fixe, part externe variable

Si vous externalisez, le partenaire qui a développé le logiciel est généralement le choix le moins coûteux pour le supporter, car il n'a pas de courbe d'apprentissage. Un nouveau partenaire devrait commencer par un audit payant du code et de l'infrastructure avant de s'engager sur un SLA.

Comment mettre en place le support logiciel après le lancement ?

Mettez en place le support avant le jour du lancement, pas après la première panne. Les étapes ci-dessous transforment un projet terminé en produit supporté en quelques semaines.

  1. Définir le périmètre. Listez les applications, environnements, intégrations, groupes d'utilisateurs et les heures ouvrées qui comptent.
  2. Convenir des niveaux de gravité et des objectifs de SLA. Utilisez le tableau ci-dessus comme ébauche et ajustez-le à votre impact métier réel.
  3. Mettre en place la supervision et les alertes. Contrôles de disponibilité, suivi des erreurs, métriques de performance et alertes de sécurité qui préviennent la bonne personne.
  4. Choisir un processus de ticketing. Un canal d'entrée unique, des champs obligatoires, des étiquettes pour le type de maintenance et la gravité.
  5. Transférer la connaissance. Vue d'ensemble de l'architecture, runbooks pour les incidents courants, identifiants dans un coffre-fort de mots de passe et accès pour l'équipe de support.
  6. Inventorier les dépendances. Une nomenclature logicielle (SBOM) avec les versions et les dates de fin de vie, pour que les mises à niveau soient planifiées et non découvertes.
  7. Planifier le rythme des versions. Des versions de maintenance régulières, par exemple toutes les deux ou quatre semaines, plus un circuit de hotfix pour les problèmes P1.
  8. Faire une revue mensuelle. Tendances des tickets, respect du SLA, problèmes récurrents et équilibre entre travail correctif et préventif.

La supervision, la CI/CD et les rollbacks sécurisés font ici une grande partie du travail ; notre guide sur le DevOps dans le développement logiciel présente les pratiques qui rendent les versions de support peu risquées.

Liste des services de développement logiciel : où se situe le support ?

Le support est l'étape de la liste des services de développement logiciel qui commence au lancement et dure tout le reste de la vie du produit. Une liste complète des services sur l'ensemble du cycle de vie ressemble généralement à ceci :

  1. Cadrage et conseil : objectifs, exigences, architecture et estimations.
  2. Design UI/UX : recherche, prototypes et design systems.
  3. Développement : web, mobile, backend, intégrations et données.
  4. Assurance qualité : tests manuels et automatisés, tests de performance et de sécurité.
  5. DevOps et cloud : infrastructure, CI/CD, supervision et maîtrise des coûts.
  6. Support et maintenance : incidents, corrections, mises à jour et petites améliorations après le lancement.
  7. Modernisation : changement de plateforme, refactoring ou reconstruction lorsque le système ne répond plus aux besoins.

Les deux dernières étapes sont liées. Un bon support garde un système en bonne santé pendant des années ; un support médiocre ou absent raccourcit sa durée de vie et avance la modernisation.

Comment réduire le coût du support logiciel sans augmenter les risques ?

Le moyen le plus fiable de réduire le coût du support consiste à rendre chaque correction et chaque version moins chères, et non à répondre à moins de tickets. Ces mesures sont généralement rentabilisées en moins d'un an :

  • Automatiser les tests de régression des principaux parcours utilisateurs, pour que chaque version ne demande pas des jours de vérification manuelle.
  • Mettre à jour les dépendances peu à la fois et souvent plutôt qu'en un seul saut douloureux après plusieurs années.
  • Investir dans l'observabilité pour que les ingénieurs trouvent la cause d'un problème à partir des logs et des traces, et non par tâtonnement.
  • Construire une base de connaissances L1 à partir des tickets résolus pour écarter les questions répétitives.
  • Supprimer les fonctionnalités et intégrations inutilisées qui demandent encore des correctifs mais n'apportent plus de valeur.
  • Suivre les types de tickets et traiter chaque trimestre les causes racines des problèmes récurrents les plus fréquents.

Quand le support ne suffit-il plus ?

Le support ne suffit plus lorsque maintenir le système en vie coûte chaque année plus cher que de le transformer. À ce stade, multiplier les correctifs ne fait que retarder une décision. Les signes typiques sont :

  • Le runtime ou le framework principal a dépassé sa fin de vie et la voie de mise à niveau ressemble davantage à une réécriture qu'à une mise à jour.
  • De petites modifications prennent des semaines, car personne ne peut prévoir leurs effets de bord.
  • Seules une ou deux personnes comprennent le système, et recruter sur sa stack est difficile.
  • Les failles de sécurité détectées ne peuvent pas être corrigées sans changements structurels importants.
  • La facture annuelle de support ne cesse d'augmenter alors que la valeur métier du système stagne.

Lorsque ces signes apparaissent, une évaluation de modernisation compare des options comme le refactoring, le changement de plateforme ou une reconstruction progressive. Notre article sur la modernisation des systèmes hérités en 2026 détaille ces stratégies, leurs coûts et les échecs à éviter.

Quelles sont les erreurs de support logiciel les plus fréquentes ?

La plupart des problèmes de support viennent d'accords manquants et de travail préventif négligé plutôt que de difficultés techniques complexes. Surveillez ces schémas :

  • Pas de responsable. Personne ne répond du système en production, si bien que les problèmes rebondissent d'une équipe à l'autre.
  • Pas de SLA écrit. Chaque incident devient un débat sur l'urgence et la responsabilité.
  • Mises à niveau repoussées. Les dépendances dérivent pendant des années jusqu'à ce qu'une date de fin de vie impose un projet d'urgence.
  • Connaissance perdue. L'équipe qui a développé le produit part sans documentation, sans runbooks ni passation.
  • Toutes les heures vont au correctif. Il ne reste aucun temps pour les tâches préventives et adaptatives, et les mêmes problèmes reviennent.
  • Pas d'accès à vos propres actifs. Le code, les comptes cloud ou les domaines sont au nom du prestataire.

Comment choisir un partenaire de support logiciel ?

Choisissez un partenaire de support logiciel capable de présenter un processus d'onboarding clair, un SLA réaliste et des ingénieurs qui maîtrisent votre stack, et qui fait de vous le propriétaire du code, des données et des comptes. Utilisez cette checklist pour comparer les prestataires :

  • Commencent-ils par un audit du code et de l'infrastructure avant de proposer des conditions de SLA fermes ?
  • Peuvent-ils couvrir les trois niveaux dont vous avez besoin, ou seulement une partie de la chaîne d'escalade ?
  • Proposent-ils les heures de couverture et les fuseaux horaires dont vos utilisateurs ont besoin ?
  • Fournissent-ils un rapport mensuel avec le respect du SLA et les problèmes récurrents ?
  • Comment planifient-ils les mises à niveau des dépendances et les migrations de fin de vie ?
  • Que deviennent le code, les identifiants et la documentation si le contrat prend fin ?
  • Peuvent-ils passer du support à la modernisation ou à un nouveau développement avec la même équipe le moment venu ?

Un partenaire qui s'intéresse à votre supervision, à votre processus de livraison et aux versions de vos dépendances dès le premier échange est généralement un choix plus sûr que celui qui annonce un prix avant d'avoir regardé le code.

Support de développement logiciel : FAQ

Qu'est-ce que le support de développement logiciel ?

Le support de développement logiciel est le travail continu qui maintient une application en production fonctionnelle, sécurisée et utile après son lancement. Il comprend la supervision, la gestion des incidents, les corrections de bugs, les mises à jour de sécurité et des dépendances, les adaptations aux nouvelles plateformes et les petites améliorations, généralement fournis dans le cadre d'un SLA convenu.

Quelle est la différence entre la maintenance logicielle et le support logiciel ?

La maintenance logicielle modifie le code : corrections de bugs, mises à niveau, refactoring et petites fonctionnalités. Le support logiciel assure le bon fonctionnement quotidien du système et de ses utilisateurs : supervision, tri, aide aux utilisateurs et solutions de contournement avec des objectifs de délai de réponse. La plupart des contrats combinent les deux, mais ils sont staffés et mesurés différemment.

Combien coûtent le support et la maintenance d'un logiciel par an ?

Une fourchette de planification courante est de 15 à 25 % du coût de développement initial par an. Les outils internes simples peuvent coûter moins ; les systèmes intégrés, réglementés ou en évolution rapide coûtent souvent plus. Chez YuSMP, le support et l'évolution d'un produit SaaS en production commencent à $1,400 par mois, et les ingénieurs à $100 de l'heure.

Quels sont les cinq types de maintenance logicielle ?

La norme ISO/IEC/IEEE 14764:2022 définit cinq types : corrective (corriger les problèmes découverts), préventive (éliminer les défauts latents avant qu'ils ne provoquent des pannes), adaptative (maintenir le logiciel fonctionnel lorsque son environnement change), perfective (améliorer les performances ou la maintenabilité) et additive (ajouter de nouvelles fonctions au produit en production).

Que signifient les niveaux de support L1, L2 et L3 ?

Ce sont des niveaux d'escalade. Le L1 traite les questions des utilisateurs, les accès et les problèmes connus. Le L2 analyse les problèmes applicatifs, les logs, les données et la configuration. Le L3 est le niveau d'ingénierie qui modifie le code, l'infrastructure ou les paramètres de sécurité et livre des correctifs testés.

Quels délais de réponse un SLA de support logiciel doit-il prévoir ?

Un point de départ type est une première réponse sous une heure pour les pannes critiques, sous quatre heures ouvrées pour les problèmes de gravité élevée, le jour ouvré suivant pour les problèmes moyens et sous quelques jours ouvrés pour les demandes de faible priorité. Les bons objectifs dépendent de l'impact métier et des heures de couverture.

L'entreprise qui a développé le logiciel doit-elle aussi en assurer le support ?

En général oui, car l'équipe d'origine connaît déjà le code et peut démarrer sans courbe d'apprentissage. Si vous changez de partenaire, demandez d'abord un audit payant du code et de l'infrastructure, et assurez-vous d'être propriétaire du code, de la documentation et de tous les comptes.

Sources