Les projets d’application qui dérapent trébuchent rarement sur le code. Ils trébuchent sur des décisions prises trop vite, trop tard ou par la mauvaise personne : un besoin mal cadré, une UX laissée au hasard, un design repoussé, un MVP trop gros, des tests sacrifiés, un budget sous-estimé. Voici les 7 erreurs que nous croisons le plus souvent quand une organisation veut créer une application, comment les éviter, et les repères de délais et de coûts à avoir en tête avant de se lancer.
Vous pensez qu’il suffit d’une bonne idée pour lancer une application ? J’ai vu trop de projets prometteurs s’effondrer parce qu’on a foncé tête baissée, sans poser les bonnes bases. Ce que vous ne décidez pas avant de coder, vous le paierez plus tard — parfois très cher.
Avec les outils no-code et l’IA, on peut avoir une maquette cliquable avant la fin de la journée. C’est une excellente nouvelle pour tester une idée, et c’est aussi ce qui rend la suite trompeuse : entre un prototype qui fait illusion et une application que vos équipes ou vos clients utilisent tous les jours, il y a des données à structurer, des cas limites, des comptes et des droits d’accès, de la sécurité, de la maintenance.
Quand on cherche comment créer une appli, on trouve surtout des listes d’étapes. Elles sont connues : cadrer, concevoir, designer, développer, tester, lancer, faire évoluer. Ce qui distingue un projet qui aboutit d’un projet qui s’enlise, ce sont les erreurs commises à chacune de ces étapes, et elles sont rarement techniques. Ce sont des décisions repoussées, prises par la mauvaise personne ou au mauvais moment.
Voici les sept que nous voyons le plus souvent en accompagnant des projets d’application web, dans l’ordre où elles apparaissent au fil d’un projet.
Erreur n°1 : sauter le cadrage et foncer dans le développement
Le scénario est classique. L’idée est claire dans la tête de la personne qui la porte, le budget est validé, l’envie d’avancer est forte. On transmet quelques écrans et une liste de fonctionnalités à une équipe de développement, et le chantier démarre.
Trois semaines plus tard, les questions arrivent. Qui a le droit de modifier une réservation ? Que se passe-t-il si un utilisateur a deux comptes ? Faut-il synchroniser avec le CRM ou l’ERP existant, et dans quel sens ? Chaque réponse arrive au fil de l’eau, et chacune oblige à reprendre quelque chose qui était déjà construit.
Cadrer ne demande pas un cahier des charges de 80 pages. Il s’agit de répondre, avant de développer une application, à un petit nombre de questions dont les réponses coûtent cher à changer ensuite :
Quel problème l’application résout-elle, et pour qui en priorité ?
Comment saura-t-on qu’elle fonctionne ? Quel indicateur doit bouger ?
Avec quels systèmes doit-elle échanger des données (CRM, ERP, outils métier, paiement) ?
Quelles règles métier sont non négociables (droits d’accès, circuits de validation, données sensibles) ?
Qui tranche quand deux besoins se contredisent ?
Un bon cadrage réunit les métiers, le design et le développement dans la même pièce, parce que chacun repère des problèmes différents. La personne qui va construire voit souvent qu’une donnée n’existe pas encore, qu’une API existante fait déjà la moitié du travail, ou qu’une fonctionnalité « simple » cache un vrai chantier. Pour visualiser ce qui se passe en coulisses du parcours (qui fait quoi, quand, avec quel outil), un service blueprint est un bon support de discussion.
Une question posée pendant le cadrage coûte une réunion. La même question posée en plein développement coûte un sprint.
Le cadrage n’a pas besoin d’être long. Pour la plupart des projets, quelques ateliers bien préparés suffisent à produire l’essentiel : une description du problème, les profils d’utilisateurs prioritaires, les parcours clés, les contraintes techniques et une première liste de fonctionnalités classées. Ce document court sert ensuite de référence à chaque arbitrage.
Erreur n°2 : laisser le développeur décider de l’UX
Quand personne n’est explicitement responsable de l’expérience utilisateur, les décisions se prennent quand même, par défaut, au moment où l’on code l’écran.
Le développeur doit alors choisir l’ordre des champs d’un formulaire, ce qui s’affiche après une erreur, ce que montre un tableau vide, comment on annule une action. Il le fera avec logique, souvent en suivant la structure de la base de données. Le résultat est cohérent pour le système, beaucoup moins pour la personne qui utilise l’application entre deux rendez-vous, sur son téléphone, avec une connexion moyenne.
L’inverse ne marche pas mieux. Une UX conçue sans regard technique produit des parcours impossibles à tenir dans le budget, ou qui ignorent des contraintes bien réelles : le temps de réponse d’un service externe, les données réellement disponibles, les règles de sécurité.
Qui décide quoi
Le designer UX décide de ce que vit l’utilisateur : les parcours, la hiérarchie des écrans, les messages, les états vides et les erreurs. Il valide ses choix avec de vrais utilisateurs.
Le développeur décide de la façon de le construire : architecture, performance, sécurité. Il signale les cas limites et alerte quand un parcours coûte plus qu’il ne rapporte.
Le plus efficace est un binôme qui travaille ensemble dès les premiers wireframes. Le designer propose, le développeur vérifie la faisabilité et suggère des alternatives moins coûteuses, le designer ajuste. Chacun garde la responsabilité de son domaine, et les compromis se font en connaissance de cause. Pour aller plus loin sur les méthodes, nous avons détaillé le sujet dans notre article UX design : méthodes, process et métiers.
Erreur n°3 : négliger le design au profit du « on verra plus tard »
« On fait marcher d’abord, on fera joli ensuite. » La phrase part d’une bonne intention : ne pas dépenser en finitions avant d’avoir validé l’essentiel. Elle confond pourtant design et décoration.
Le design d’interface, c’est la hiérarchie de l’information, la lisibilité, les différents états d’un bouton, la manière dont l’application guide l’utilisateur sans mode d’emploi. Le reporter, c’est livrer une première version jugée difficile à utiliser, et donc mal évaluer l’idée elle-même : si un test utilisateur échoue parce que personne ne comprend où cliquer, il ne dit rien de la valeur du produit.
Il y a aussi un coût technique. Ajouter le design après coup, c’est retoucher chaque écran un par un. Le prévoir dès le départ, c’est construire une bibliothèque de composants (boutons, champs, tableaux, fenêtres modales) réutilisés partout. Chaque nouvel écran se monte alors plus vite, et l’application reste cohérente à mesure qu’elle grandit.
Tout ne doit pas être prêt pour la V1. Les illustrations, les animations et les finitions de marque peuvent attendre. En revanche, trois choses ne peuvent pas être repoussées :
la structure des écrans principaux et la navigation ;
les composants de base et tous leurs états (chargement, erreur, désactivé, vide) ;
les règles de lisibilité et d’accessibilité : contrastes, tailles de texte, navigation au clavier.
Erreur n°4 : développer sans architecture ni priorisation (le fameux « tout, tout de suite »)
Chaque partie prenante arrive avec sa liste. La direction veut des tableaux de bord, le marketing un module de notifications, les équipes terrain un mode hors ligne, la comptabilité un export. Tout est légitime. Tout mis ensemble dans la première version, c’est un projet qui double de taille et une date de lancement qui recule de trimestre en trimestre.
Prioriser, c’est accepter de livrer moins pour apprendre plus vite. Le MVP (produit minimum viable) est le plus petit périmètre qui permet à de vrais utilisateurs d’accomplir la tâche principale, et à vous de mesurer si ça marche. Une méthode simple consiste à classer chaque fonctionnalité dans l’une de ces trois colonnes : indispensable au lancement, utile mais peut attendre, à valider d’abord avec les utilisateurs.
≈90%
des petits projets logiciels réussissent (délai, budget et périmètre tenus), contre moins de 10 % des grands projets.
Source : Standish Group, CHAOS Report 2020
Pour un grand projet, la conséquence est simple : le découper en étapes courtes, chacune livrable et utilisable.
L’architecture se voit peu, mais elle conditionne la suite. La structure des données, la gestion des droits d’accès, la façon dont l’application communique avec les autres outils : ces choix sont difficiles à défaire. Les poser tôt ne veut pas dire tout surdimensionner. Une application bien découpée peut démarrer petite et accueillir la V2 sans être réécrite. Une application montée fonctionnalité après fonctionnalité, sans plan d’ensemble, finit par coûter plus cher à faire évoluer qu’à refaire.
Le bon réflexe : faire estimer chaque fonctionnalité par l’équipe technique avant de la prioriser. Une demande jugée « petite » cache parfois plusieurs semaines de travail (une synchronisation dans les deux sens, un moteur de règles, un mode hors ligne), quand une autre jugée ambitieuse s’avère rapide.
Contact. Un projet d’application en tête ?
Nous vous aidons à cadrer le besoin, prioriser le MVP et estimer un budget réaliste avant la première ligne de code.
Erreur n°5 : zapper les tests pour tenir le délai
Quand le planning glisse, la phase de test est la première sacrifiée. Elle arrive en fin de projet, elle ne produit rien de visible, et tout le monde est pressé de lancer. C’est un mauvais calcul : un bug trouvé avant la mise en ligne se corrige au sein de l’équipe. Le même bug trouvé par vos utilisateurs coûte en plus leur confiance, du temps de support, et parfois des données à réparer.
Tester demande plus que de « cliquer partout la veille du lancement ». Il existe trois niveaux complémentaires :
Les tests automatisés, écrits par les développeurs au fil du projet, qui vérifient que ce qui fonctionnait hier fonctionne encore aujourd’hui.
La recette, où le client et l’équipe vérifient chaque fonctionnalité par rapport à ce qui avait été décidé, sur les vrais appareils et navigateurs.
Les tests utilisateurs, où des personnes réelles essaient d’accomplir une tâche pendant que l’on observe où elles bloquent.
Le dernier est le plus souvent oublié, et c’est pourtant le moins cher. Le Nielsen Norman Group a montré qu’une session avec cinq utilisateurs suffit à faire apparaître la majorité des problèmes d’utilisabilité d’un parcours. Mieux vaut trois petites sessions réparties dans le projet qu’un grand test à la fin, quand il est trop tard pour corriger.
Le plus efficace : réserver le temps de test dans le planning dès le départ, et écrire les critères d’acceptation de chaque fonctionnalité au moment où on la conçoit. Quand le critère existe avant le code, on sait exactement quoi vérifier.
Erreur n°6 : lancer sans plan de suite (pas de V2, pas de retours utilisateurs)
Le lancement donne l’impression d’une ligne d’arrivée. Pour une application, c’est plutôt le début de la période où l’on apprend vraiment : comment les gens l’utilisent, où ils abandonnent, ce qu’ils réclament.
Sans plan pour la suite, deux scénarios guettent. Soit l’application se fige : plus de budget, plus d’équipe, les retours s’accumulent sans réponse et l’usage s’érode. Soit elle évolue au gré des demandes les plus insistantes, sans données pour arbitrer, et perd peu à peu sa cohérence.
L’après-lancement se prépare avant le lancement :
Mesurer : choisir deux ou trois indicateurs liés à l’objectif de départ (taux de réalisation d’une tâche, utilisateurs actifs, temps gagné) et les intégrer dès la V1.
Écouter : prévoir un canal simple pour les retours, comme un formulaire intégré ou des entretiens réguliers avec quelques utilisateurs.
Maintenir : mises à jour de sécurité, compatibilité avec les nouveaux navigateurs et systèmes, corrections. Une application non maintenue se dégrade, même si personne n’y touche.
Planifier la V2 : conserver la liste de ce qui a été écarté du MVP, et la reprioriser à la lumière des premiers usages.
Côté budget, il est raisonnable de prévoir chaque année 10 à 20 % du coût initial pour la maintenance et les petites évolutions, hors nouvelles fonctionnalités majeures. Mieux vaut l’intégrer dès la décision de lancer le projet que le découvrir un an plus tard.
Erreur n°7 : sous-estimer les délais et les coûts réels
Une estimation trop optimiste a rarement une seule cause. Le périmètre est flou (erreur n°1), la liste des fonctionnalités grossit en route (erreur n°4), le design et les tests sont comprimés (erreurs n°3 et n°5), et l’après-lancement n’est pas budgété (erreur n°6). L’erreur n°7 est souvent la somme des six autres.
S’y ajoutent des coûts qui n’apparaissent pas dans le devis initial :
le temps des équipes internes : ateliers, validations, recette, rédaction des contenus ;
les intégrations avec les outils existants, souvent sous-estimées faute de documentation à jour ;
l’hébergement et les services tiers (envoi d’e-mails, cartes, paiement), avec leurs abonnements ;
la mise en conformité : protection des données, accessibilité ;
la maintenance et les évolutions des années suivantes.
+45 %
de dépassement de budget en moyenne pour les grands projets informatiques, qui livrent en plus 56 % de valeur en moins que prévu.
Source : McKinsey et Université d’Oxford, étude sur plus de 5 400 projets IT (2012)
Ces chiffres portent sur de très gros projets, mais le mécanisme est le même à plus petite échelle. Pour s’en protéger : estimer fonctionnalité par fonctionnalité plutôt qu’au forfait global, garder une réserve de 15 à 20 % pour les imprévus, et livrer par étapes, pour que chaque étape confirme (ou corrige) l’estimation de la suivante.
Ce qu’il faut retenir : délais pour créer une application
Il n’existe pas de prix unique pour une application. Tout dépend du périmètre, du nombre de rôles utilisateurs, des intégrations et du niveau d’exigence (sécurité, accessibilité, volumes). Voici les ordres de grandeur constatés sur le marché suisse pour une application web sur mesure réalisée par une agence :
Prototype ou preuve de concept (tester une idée auprès de quelques utilisateurs) en 2 à 6 semaines;
MVP (un parcours principal, quelques rôles, une ou deux intégrations) en 3 à 6 mois;
Application métier complète (plusieurs rôles, règles métier, connexions au CRM ou à l’ERP) sur 6 mois et plus;
Maintenance et évolutions (sécurité, mises à jour, petites évolutions) : 10 à 20 % du temps initial par an.
Ces fourchettes sont des repères. Elles se resserrent nettement après le cadrage, quand le périmètre est clair et que chaque fonctionnalité a été estimée.
Et pour garder le cap sur l’ensemble du projet, les sept réflexes à retenir :
Cadrer avant de coder : problème, utilisateurs, intégrations, règles métier, qui tranche.
Confier l’UX à quelqu’un, en binôme avec le développement.
Designer la structure dès la V1, et garder les finitions pour plus tard.
Estimer, puis prioriser un MVP sur une architecture qui peut grandir.
Réserver le temps de test et écrire les critères d’acceptation pendant la conception.
Budgéter le coût réel : temps interne, intégrations, services tiers, réserve et maintenance.
Conclusion. Une application réussie se joue avant le code
Ces sept erreurs sont des décisions à prendre au bon moment, avec les bonnes personnes autour de la table : métiers, design et développement. Si vous envisagez de créer une application, commencez par là. Et si vous voulez un regard extérieur pour cadrer votre idée, prioriser votre MVP ou estimer un budget réaliste, parlons-en.
Vous sentez que votre site ne suit plus, mais vous hésitez à lancer une refonte. Selon nous, voici les 8 signaux précis qui trahissent les vrais problèmes. Ignorer ces alertes, c’est risquer de creuser un écart avec vos utilisateurs et vos ambitions.
Vous pensez qu’il suffit d’une bonne idée pour lancer une application ? J’ai vu trop de projets prometteurs s’effondrer parce qu’on a foncé tête baissée, sans poser les bonnes bases. Ce que vous ne décidez pas avant de coder, vous le paierez plus tard — parfois très cher.