<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>We IT — Blog</title><description>Création d&apos;applications web métier : méthode, délais, architecture et cas concrets.</description><link>https://we-it.co</link><language>fr-FR</language><item><title>Mettre un modèle de langage en production : tout ce qui change</title><link>https://we-it.co/blog/mettre-un-modele-en-production</link><guid isPermaLink="true">https://we-it.co/blog/mettre-un-modele-en-production</guid><description>À peu près tout, sauf le modèle. Une fonctionnalité IA en production est non déterministe, son coût est variable et proportionnel à l&apos;usage, ses pannes sont silencieuses — elle répond à côté au lieu de renvoyer une erreur — et ses tests unitaires ne servent à rien. Ce qui fait tenir une telle fonctionnalité dans la durée, ce sont un jeu de cas d&apos;évaluation, une stratégie de repli entre fournisseurs, et des prompts traités comme du code : versionnés, relus, testés.</description><pubDate>Mon, 10 Aug 2026 00:00:00 GMT</pubDate><category>IA</category><category>méthode</category><category>qualité</category><category>architecture</category></item><item><title>Rester libre de son opérateur téléphonique : le SIP comme point de découplage</title><link>https://we-it.co/blog/discall-telephonie-interchangeable</link><guid isPermaLink="true">https://we-it.co/blog/discall-telephonie-interchangeable</guid><description>En faisant entrer les appels par un trunk SIP plutôt que par l&apos;API propriétaire de l&apos;opérateur. Le SIP est un standard : changer d&apos;opérateur revient à repointer un trunk, sans toucher au code de l&apos;agent. Le piège se déplace alors ailleurs — vers la gestion des numéros, qui reste propre à chaque opérateur et qui est le vrai endroit où l&apos;on se retrouve attaché.</description><pubDate>Thu, 06 Aug 2026 00:00:00 GMT</pubDate><category>architecture</category><category>réversibilité</category><category>cas concret</category></item><item><title>Tester une application mobile : sur quels appareils, et comment</title><link>https://we-it.co/blog/tester-une-application-mobile-parc-appareils</link><guid isPermaLink="true">https://we-it.co/blog/tester-une-application-mobile-parc-appareils</guid><description>Sur trois appareils physiques bien choisis plutôt que sur vingt simulateurs : le modèle le plus répandu chez vos utilisateurs, un appareil ancien de milieu de gamme, et le plus récent. Les simulateurs conviennent au développement mais ne reproduisent ni les performances réelles, ni la caméra, ni le comportement du réseau, ni les stratégies d&apos;économie d&apos;énergie propres à chaque constructeur — qui sont la première cause d&apos;incidents inexplicables sur Android.</description><pubDate>Mon, 03 Aug 2026 00:00:00 GMT</pubDate><category>mobile</category><category>qualité</category><category>méthode</category></item><item><title>« On voudrait de l&apos;IA » : ce qu&apos;il y a derrière la demande</title><link>https://we-it.co/blog/ia-ce-que-les-clients-demandent</link><guid isPermaLink="true">https://we-it.co/blog/ia-ce-que-les-clients-demandent</guid><description>Trois choses très différentes, qu&apos;il faut séparer avant de chiffrer : réduire un coût de traitement, ne pas paraître en retard face à un concurrent, ou répondre à une injonction interne. Seule la première se cadre comme un projet. Les deux autres se traitent d&apos;abord par une conversation, sinon on livre une fonctionnalité que personne n&apos;utilise mais que tout le monde a validée.</description><pubDate>Wed, 29 Jul 2026 00:00:00 GMT</pubDate><category>IA</category><category>arbitrage</category><category>stratégie</category></item><item><title>Vos données sont-elles prêtes pour l&apos;IA ? La question avant toutes les autres</title><link>https://we-it.co/blog/ia-vos-donnees-sont-elles-pretes</link><guid isPermaLink="true">https://we-it.co/blog/ia-vos-donnees-sont-elles-pretes</guid><description>Quatre choses, dans cet ordre : que la donnée soit accessible par un programme, qu&apos;elle soit fraîche, qu&apos;on sache ce que chaque champ signifie, et qu&apos;on ait le droit de l&apos;utiliser pour cet usage. Un modèle n&apos;invente pas ce qui manque et ne corrige pas ce qui est faux — il donne à des données médiocres l&apos;apparence de la fiabilité, ce qui est pire que de ne rien faire.</description><pubDate>Sat, 25 Jul 2026 00:00:00 GMT</pubDate><category>IA</category><category>data</category><category>méthode</category></item><item><title>Pourquoi les agents vocaux génériques déçoivent en français</title><link>https://we-it.co/blog/discall-agents-vocaux-en-francais</link><guid isPermaLink="true">https://we-it.co/blog/discall-agents-vocaux-en-francais</guid><description>Non, et l&apos;écart ne vient pas du modèle de langage mais de tout ce qui l&apos;entoure : la transcription bute sur les liaisons et les chiffres, la synthèse se trompe sur les nombres et les noms propres, et les tours de parole français comportent plus d&apos;hésitations. Un agent démontré en anglais peut perdre l&apos;essentiel de sa fiabilité en français sans qu&apos;aucune ligne de code ne change.</description><pubDate>Mon, 20 Jul 2026 00:00:00 GMT</pubDate><category>IA</category><category>qualité</category><category>cas concret</category></item><item><title>Spécifier une fonctionnalité IA : les critères d&apos;acceptation ne marchent plus</title><link>https://we-it.co/blog/ia-specifier-et-recetter</link><guid isPermaLink="true">https://we-it.co/blog/ia-specifier-et-recetter</guid><description>En remplaçant « le système affiche X » par des propriétés vérifiables et un taux attendu, mesurés sur un échantillon de cas réels. Un critère d&apos;acceptation classique suppose une sortie unique et reproductible ; une fonctionnalité IA n&apos;en a pas. La recette se fait alors sur un jeu de cas construit avec le métier, et l&apos;essentiel du travail de spécification porte sur ce qui doit arriver quand le système se trompe.</description><pubDate>Fri, 17 Jul 2026 00:00:00 GMT</pubDate><category>IA</category><category>produit</category><category>qualité</category></item><item><title>Le coût d&apos;une fonctionnalité IA ne se calcule pas comme les autres</title><link>https://we-it.co/blog/ia-combien-coute-une-fonctionnalite</link><guid isPermaLink="true">https://we-it.co/blog/ia-combien-coute-une-fonctionnalite</guid><description>En séparant le coût de construction, qui ressemble à n&apos;importe quel développement, et le coût d&apos;usage, qui n&apos;existe pas ailleurs : chaque utilisation se paie. Une fonctionnalité classique amortie devient gratuite ; une fonctionnalité IA coûte d&apos;autant plus qu&apos;elle réussit. Le budget doit donc comporter une ligne récurrente, un plafond, et une décision écrite sur ce qui se passe quand ce plafond est atteint.</description><pubDate>Mon, 13 Jul 2026 00:00:00 GMT</pubDate><category>IA</category><category>budget</category><category>produit</category></item><item><title>Agent vocal au téléphone : où passent réellement les millisecondes</title><link>https://we-it.co/blog/discall-latence-agent-vocal</link><guid isPermaLink="true">https://we-it.co/blog/discall-latence-agent-vocal</guid><description>Parce que la latence perçue n&apos;est pas celle du modèle de langage mais celle de la chaîne entière : détection de fin de parole, transcription, génération, synthèse, transport téléphonique. Sur notre chaîne, c&apos;est la transcription qui domine — 700 à 1500 ms avant que le résultat soit déclaré définitif — loin devant le modèle. Le levier le plus rentable n&apos;est donc pas de changer de modèle mais de diffuser la réponse au fil de l&apos;eau plutôt qu&apos;une fois complète.</description><pubDate>Wed, 08 Jul 2026 00:00:00 GMT</pubDate><category>architecture</category><category>IA</category><category>cas concret</category></item><item><title>Une application mobile posée sur une API qu&apos;on ne maîtrise pas</title><link>https://we-it.co/blog/linkosport-modeliser-profils-heterogenes</link><guid isPermaLink="true">https://we-it.co/blog/linkosport-modeliser-profils-heterogenes</guid><description>En traduisant les réponses de l&apos;API en entités propres à l&apos;application dès la frontière, plutôt qu&apos;en laissant sa structure remonter dans les écrans. Le découpage domaine / données / présentation coûte quelques fichiers de plus et rend l&apos;application insensible aux changements de format côté serveur. Sans cette traduction, une évolution de l&apos;API devient une reprise de tous les écrans qui l&apos;utilisaient.</description><pubDate>Sun, 05 Jul 2026 00:00:00 GMT</pubDate><category>architecture</category><category>produit</category><category>cas concret</category></item><item><title>Une marketplace a deux faces : par laquelle commencer</title><link>https://we-it.co/blog/linkosport-marketplace-deux-faces</link><guid isPermaLink="true">https://we-it.co/blog/linkosport-marketplace-deux-faces</guid><description>En renonçant à lancer les deux côtés en même temps. On choisit la face la plus difficile à recruter — presque toujours celle qui doit publier — et on lui rend un service qui a de la valeur même si l&apos;autre côté est vide. La plateforme n&apos;est utile aux deux qu&apos;ensuite, et ce décalage doit être assumé dans le produit comme dans le budget.</description><pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate><category>produit</category><category>stratégie</category><category>cas concret</category></item><item><title>Analyser des données personnelles sans se mettre en faute</title><link>https://we-it.co/blog/analyser-des-donnees-personnelles-sans-se-mettre-en-faute</link><guid isPermaLink="true">https://we-it.co/blog/analyser-des-donnees-personnelles-sans-se-mettre-en-faute</guid><description>Quatre principes couvrent l&apos;essentiel : n&apos;utiliser une donnée que pour une finalité définie et compatible avec celle de sa collecte, ne conserver que ce qui est nécessaire et pas plus longtemps qu&apos;il ne faut, travailler sur des données pseudonymisées dès que l&apos;identité n&apos;est pas indispensable à l&apos;analyse, et tracer qui accède à quoi. L&apos;anonymisation réelle est plus difficile qu&apos;il n&apos;y paraît : retirer le nom ne suffit pas, car un croisement de quelques attributs suffit souvent à réidentifier une personne.</description><pubDate>Sat, 27 Jun 2026 00:00:00 GMT</pubDate><category>data</category><category>gouvernance</category><category>sécurité</category></item><item><title>Relire du code écrit par une IA : ce que je regarde en premier</title><link>https://we-it.co/blog/relire-du-code-ecrit-par-une-ia</link><guid isPermaLink="true">https://we-it.co/blog/relire-du-code-ecrit-par-une-ia</guid><description>En inversant l&apos;ordre habituel de la revue. Le code généré est presque toujours correct en surface — syntaxe propre, nommage cohérent, tests qui passent — et ses défauts se logent ailleurs : gestion d&apos;erreur optimiste, réinvention de ce qui existe déjà dans le projet, et cas limites traités par omission. Je commence donc par ce que le code ne fait pas, avant de lire ce qu&apos;il fait.</description><pubDate>Wed, 24 Jun 2026 00:00:00 GMT</pubDate><category>IA</category><category>qualité</category><category>méthode</category></item><item><title>Le tiers payant expliqué à une équipe technique</title><link>https://we-it.co/blog/optibot-tiers-payant-pour-equipe-technique</link><guid isPermaLink="true">https://we-it.co/blog/optibot-tiers-payant-pour-equipe-technique</guid><description>Qu&apos;un dossier n&apos;est pas une transaction unique mais une chaîne à deux payeurs — l&apos;assurance maladie et la complémentaire — chacun avec ses règles, ses délais et ses motifs de rejet. L&apos;essentiel de la complexité n&apos;est pas dans le cas nominal mais dans le rejet : il arrive des semaines plus tard, il faut savoir à quel dossier le rattacher, et le corriger sans perdre l&apos;historique.</description><pubDate>Fri, 19 Jun 2026 00:00:00 GMT</pubDate><category>cas concret</category><category>produit</category><category>qualité</category></item><item><title>Encaisser pour une association : ce que le paiement en ligne change vraiment</title><link>https://we-it.co/blog/moove-it-paiement-en-ligne-association</link><guid isPermaLink="true">https://we-it.co/blog/moove-it-paiement-en-ligne-association</guid><description>Il supprime le travail de relance et de rapprochement, qui coûte bien plus de temps aux bénévoles que l&apos;encaissement lui-même. Le gain n&apos;est pas dans l&apos;acte de payer mais dans ce qui l&apos;entoure : plus de chèques à déposer, plus de tableau de suivi, un état des impayés à jour en permanence. En contrepartie, il faut traiter des cas que le chèque masquait — paiement en plusieurs fois, aides, remboursements.</description><pubDate>Mon, 15 Jun 2026 00:00:00 GMT</pubDate><category>produit</category><category>budget</category><category>cas concret</category></item><item><title>Choisir sa base de données : relationnel, document, ou les deux</title><link>https://we-it.co/blog/choisir-sa-base-de-donnees</link><guid isPermaLink="true">https://we-it.co/blog/choisir-sa-base-de-donnees</guid><description>Une base relationnelle par défaut, dans la quasi-totalité des applications métier. Dès que les données ont des relations et que l&apos;intégrité compte — une commande référence un client, un paiement une facture — le moteur relationnel fait respecter ces règles à votre place, ce qu&apos;aucune couche applicative ne garantit durablement. Une base documentaire se justifie pour des documents autonomes sans relations fortes, ou pour des volumes que le relationnel ne tient plus. Dans les faits, la combinaison la plus courante est une base relationnelle qui stocke aussi du document quand c&apos;est utile.</description><pubDate>Wed, 10 Jun 2026 00:00:00 GMT</pubDate><category>architecture</category><category>arbitrage</category><category>durabilité</category></item><item><title>L&apos;IA sur mobile : ce qui tourne sur l&apos;appareil, ce qui part au serveur</title><link>https://we-it.co/blog/ia-sur-mobile-appareil-ou-serveur</link><guid isPermaLink="true">https://we-it.co/blog/ia-sur-mobile-appareil-ou-serveur</guid><description>Côté serveur par défaut, sur l&apos;appareil pour les cas où la latence, le hors-ligne ou la confidentialité l&apos;imposent. Un traitement local évite l&apos;aller-retour réseau et ne coûte rien à l&apos;usage, mais il alourdit l&apos;application, consomme la batterie et fige le modèle dans une version publiée. Le choix se fait tâche par tâche, pas une fois pour toute l&apos;application.</description><pubDate>Sun, 07 Jun 2026 00:00:00 GMT</pubDate><category>IA</category><category>mobile</category><category>arbitrage</category></item><item><title>Suivre un budget de projet en cours de route sans se faire surprendre</title><link>https://we-it.co/blog/suivre-un-budget-projet-en-cours</link><guid isPermaLink="true">https://we-it.co/blog/suivre-un-budget-projet-en-cours</guid><description>En suivant le reste à faire plutôt que le consommé. Un budget consommé à 60 % ne dit rien : ce qui compte est ce qu&apos;il reste à produire, réestimé à intervalles réguliers par ceux qui font le travail. Trois indicateurs suffisent — le reste à faire en jours, le périmètre encore ouvert, et le nombre de demandes ajoutées depuis le début. Un dépassement se voit toujours plusieurs semaines avant qu&apos;il ne se produise, à condition de regarder le bon chiffre.</description><pubDate>Wed, 03 Jun 2026 00:00:00 GMT</pubDate><category>budget</category><category>méthode</category><category>achat</category></item><item><title>Mesurer le gain réel d&apos;une automatisation documentaire</title><link>https://we-it.co/blog/optibot-mesurer-gain-automatisation</link><guid isPermaLink="true">https://we-it.co/blog/optibot-mesurer-gain-automatisation</guid><description>En mesurant avant, sur le processus manuel, et en comptant le temps de bout en bout plutôt que celui de l&apos;étape automatisée. Le piège classique est de comparer la durée de saisie avant et après, en oubliant le temps de vérification, de correction et de reprise des cas rejetés — qui absorbe souvent une grande part du gain annoncé.</description><pubDate>Fri, 29 May 2026 00:00:00 GMT</pubDate><category>productivité</category><category>IA</category><category>cas concret</category></item><item><title>Le planning d&apos;un club : le problème le plus sous-estimé</title><link>https://we-it.co/blog/moove-it-planning-club-sportif</link><guid isPermaLink="true">https://we-it.co/blog/moove-it-planning-club-sportif</guid><description>Parce qu&apos;un planning de club n&apos;est pas un agenda mais une allocation sous contraintes : des créneaux, des installations, des encadrants et des groupes, dont la disponibilité change en permanence. L&apos;erreur habituelle est de partir d&apos;un calendrier ; il faut partir des contraintes, et concevoir l&apos;outil autour de l&apos;exception plutôt qu&apos;autour du cas nominal.</description><pubDate>Tue, 26 May 2026 00:00:00 GMT</pubDate><category>produit</category><category>architecture</category><category>cas concret</category></item><item><title>Les décisions que nous ne confions pas à un modèle</title><link>https://we-it.co/blog/ia-ce-qu-on-ne-lui-confie-pas</link><guid isPermaLink="true">https://we-it.co/blog/ia-ce-qu-on-ne-lui-confie-pas</guid><description>Celles dont l&apos;erreur n&apos;est pas rattrapable, celles qui doivent être justifiées à un tiers, et celles qui engagent juridiquement. Une IA excelle à préparer une décision — trier, extraire, résumer, proposer. Elle ne convient pas à la prendre quand personne ne pourra expliquer pourquoi, ni revenir en arrière.</description><pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate><category>IA</category><category>arbitrage</category><category>gouvernance</category></item><item><title>Reprendre les données d&apos;une structure qui vivait sous tableur</title><link>https://we-it.co/blog/vibe-it-reprise-donnees-tableur</link><guid isPermaLink="true">https://we-it.co/blog/vibe-it-reprise-donnees-tableur</guid><description>En traitant le tableur comme une source de vérité partielle et non comme une base de données. La reprise ne consiste pas à importer des colonnes mais à reconstituer des règles qui n&apos;ont jamais été écrites : ce qu&apos;est un adhérent actif, à quoi correspond une case colorée, pourquoi deux lignes portent le même nom. Le travail est d&apos;archéologie autant que de technique, et il se fait avec la personne qui tenait le fichier.</description><pubDate>Mon, 18 May 2026 00:00:00 GMT</pubDate><category>cas concret</category><category>méthode</category><category>run</category></item><item><title>Emballer ou réécrire : comment nous choisissons une techno mobile</title><link>https://we-it.co/blog/dance-it-application-mobile-adherents</link><guid isPermaLink="true">https://we-it.co/blog/dance-it-application-mobile-adherents</guid><description>Cela dépend de ce qui existe déjà. Si vous avez une application web moderne, emballez-la : Capacitor la met dans une coque native en réutilisant l&apos;essentiel du code, et réécrire l&apos;interface en React Native ou Flutter ne rapporterait rien sur un outil de gestion. Si l&apos;existant est un site serveur classique, il n&apos;y a rien à emballer et le natif multiplateforme est justifié. La technologie se choisit après avoir regardé l&apos;existant, pas avant.</description><pubDate>Fri, 15 May 2026 00:00:00 GMT</pubDate><category>produit</category><category>arbitrage</category><category>cas concret</category></item><item><title>Quand un agent vocal n&apos;est pas la bonne réponse</title><link>https://we-it.co/blog/discall-agent-vocal-quand-ne-pas-le-faire</link><guid isPermaLink="true">https://we-it.co/blog/discall-agent-vocal-quand-ne-pas-le-faire</guid><description>Quand l&apos;appel porte un enjeu émotionnel, quand l&apos;information demandée n&apos;existe pas dans un système accessible, ou quand le volume est trop faible pour rentabiliser l&apos;exploitation. Un agent vocal traite bien les demandes fréquentes, factuelles et vérifiables ; il dégrade tout le reste, et il le dégrade auprès de gens qui avaient choisi le téléphone parce que le libre-service n&apos;avait pas suffi.</description><pubDate>Sun, 10 May 2026 00:00:00 GMT</pubDate><category>IA</category><category>arbitrage</category><category>cas concret</category></item><item><title>Qualité des données : les contrôles qui valent la peine d&apos;être automatisés</title><link>https://we-it.co/blog/qualite-des-donnees-controles-automatiques</link><guid isPermaLink="true">https://we-it.co/blog/qualite-des-donnees-controles-automatiques</guid><description>Cinq familles suffisent à couvrir l&apos;essentiel : la fraîcheur (les données sont-elles arrivées ?), la volumétrie (en quantité attendue ?), la complétude (les champs obligatoires sont-ils remplis ?), la validité (les valeurs respectent-elles leur format et leur domaine ?) et la cohérence entre sources (les totaux se recoupent-ils ?). Ces contrôles tournent à chaque rafraîchissement et alertent avant les utilisateurs. Ce qui change la perception de fiabilité n&apos;est pas l&apos;absence d&apos;erreur — c&apos;est le fait d&apos;être prévenu avant celui qui consulte le tableau de bord.</description><pubDate>Wed, 06 May 2026 00:00:00 GMT</pubDate><category>data</category><category>qualité</category><category>gouvernance</category></item><item><title>Diagnostiquer un bug en production : la méthode que je suis</title><link>https://we-it.co/blog/diagnostiquer-un-bug-en-production</link><guid isPermaLink="true">https://we-it.co/blog/diagnostiquer-un-bug-en-production</guid><description>En reconstituant les faits avant de formuler la moindre hypothèse. La séquence qui fonctionne : établir précisément ce qui s&apos;est passé et quand, vérifier ce qui a changé récemment, isoler une reproduction fiable même partielle, puis seulement chercher la cause. L&apos;erreur la plus coûteuse est de commencer par une intuition et de chercher à la confirmer — on trouve alors une explication plausible qui n&apos;est pas la bonne, et le bug revient.</description><pubDate>Fri, 01 May 2026 00:00:00 GMT</pubDate><category>qualité</category><category>run</category><category>méthode</category></item><item><title>Écrire une feuille de route qui survit à trois mois</title><link>https://we-it.co/blog/feuille-de-route-produit-qui-tient</link><guid isPermaLink="true">https://we-it.co/blog/feuille-de-route-produit-qui-tient</guid><description>En la structurant par horizons plutôt que par dates. Le trimestre en cours est engageant et détaillé ; le suivant est une intention par thème ; au-delà, ce sont des problèmes à résoudre, sans solution ni date. Une feuille de route qui promet des fonctionnalités datées à douze mois est fausse le jour où elle est publiée, et son principal effet est de détruire la confiance quand la réalité s&apos;en écarte. Ce qui doit rester stable, ce sont les objectifs ; ce qui doit bouger, ce sont les moyens de les atteindre.</description><pubDate>Tue, 28 Apr 2026 00:00:00 GMT</pubDate><category>produit</category><category>méthode</category><category>stratégie</category></item><item><title>Reprise de données : le chantier que tout le monde sous-estime</title><link>https://we-it.co/blog/reprise-de-donnees-le-chantier-sous-estime</link><guid isPermaLink="true">https://we-it.co/blog/reprise-de-donnees-le-chantier-sous-estime</guid><description>En la traitant comme un projet à part entière, avec son propre planning et ses propres critères de réussite. La difficulté n&apos;est jamais technique : elle vient de ce que les données existantes ne respectent pas les règles que le nouveau système impose. La méthode qui fonctionne consiste à faire une reprise à blanc très tôt, à mesurer le taux de rejet, à décider avec le métier quoi faire des cas non conformes, et à répéter l&apos;opération jusqu&apos;à ce qu&apos;elle soit fiable et chronométrée.</description><pubDate>Fri, 24 Apr 2026 00:00:00 GMT</pubDate><category>architecture</category><category>méthode</category><category>cas concret</category></item><item><title>Notifications push : ce qui marche, et ce qui fait désinstaller</title><link>https://we-it.co/blog/notifications-push-ce-qui-marche</link><guid isPermaLink="true">https://we-it.co/blog/notifications-push-ce-qui-marche</guid><description>En n&apos;envoyant que ce qui concerne personnellement l&apos;utilisateur et appelle une action de sa part. Trois règles gouvernent le reste : ne demander l&apos;autorisation qu&apos;après avoir montré à quoi elle sert, laisser un réglage fin par type de notification plutôt qu&apos;un interrupteur unique, et respecter le fuseau horaire ainsi que les heures de repos. Une autorisation refusée est très difficile à récupérer — la demander au premier lancement est l&apos;erreur la plus coûteuse et la plus fréquente.</description><pubDate>Sun, 19 Apr 2026 00:00:00 GMT</pubDate><category>mobile</category><category>produit</category><category>qualité</category></item><item><title>Forfait, régie ou centre de services : quel modèle de contrat choisir</title><link>https://we-it.co/blog/forfait-regie-ou-centre-de-services</link><guid isPermaLink="true">https://we-it.co/blog/forfait-regie-ou-centre-de-services</guid><description>Le forfait convient quand le périmètre est stable et documenté : le prestataire porte le risque de dérive, et vous payez cette assurance dans le prix. La régie convient quand le besoin évoluera en cours de route : vous payez des jours et vous portez le risque, ce qui suppose d&apos;avoir quelqu&apos;un pour piloter. Le centre de services est un compromis pour une relation durable : une capacité récurrente avec des engagements de résultat sur le service rendu. Le mauvais choix n&apos;est jamais le modèle en soi, c&apos;est le décalage entre le modèle et la maturité du besoin.</description><pubDate>Thu, 16 Apr 2026 00:00:00 GMT</pubDate><category>contrat</category><category>achat</category><category>prestataire</category></item><item><title>Tableur, entrepôt ou lac de données : de quoi avez-vous vraiment besoin ?</title><link>https://we-it.co/blog/tableur-entrepot-ou-lac-de-donnees</link><guid isPermaLink="true">https://we-it.co/blog/tableur-entrepot-ou-lac-de-donnees</guid><description>Un tableur suffit tant que les données tiennent dans un fichier, qu&apos;une seule personne les met à jour et qu&apos;aucune décision engageante n&apos;en dépend. Un entrepôt de données devient utile dès qu&apos;il faut croiser plusieurs sources, garder l&apos;historique et que plusieurs personnes consomment les mêmes chiffres. Un lac de données ne se justifie que pour de gros volumes de données brutes hétérogènes — c&apos;est rarement le besoin d&apos;une PME ou d&apos;une ETI, et c&apos;est souvent une réponse surdimensionnée.</description><pubDate>Sun, 12 Apr 2026 00:00:00 GMT</pubDate><category>data</category><category>architecture</category><category>arbitrage</category></item><item><title>Files d&apos;attente et traitements de fond : les règles que je ne négocie pas</title><link>https://we-it.co/blog/traitements-asynchrones-files-et-idempotence</link><guid isPermaLink="true">https://we-it.co/blog/traitements-asynchrones-files-et-idempotence</guid><description>Trois règles suffisent à éviter la quasi-totalité des incidents : toute tâche doit être rejouable sans effet de bord (idempotence), toute tâche qui échoue définitivement doit atterrir quelque part où quelqu&apos;un la voit (file d&apos;échec), et l&apos;ordre d&apos;exécution ne doit jamais être supposé. Une file d&apos;attente ne garantit pas qu&apos;un message est traité une seule fois — elle garantit qu&apos;il est traité au moins une fois, ce qui n&apos;est pas la même chose et change la façon d&apos;écrire le code.</description><pubDate>Wed, 08 Apr 2026 00:00:00 GMT</pubDate><category>architecture</category><category>qualité</category><category>run</category></item><item><title>Faire adopter un outil qui remplace des habitudes</title><link>https://we-it.co/blog/faire-adopter-un-nouvel-outil</link><guid isPermaLink="true">https://we-it.co/blog/faire-adopter-un-nouvel-outil</guid><description>En traitant l&apos;adoption comme une partie du projet, pas comme une formation de fin de parcours. Ce qui fonctionne : associer quelques utilisateurs dès le cadrage, livrer d&apos;abord à un petit groupe volontaire, accepter de modifier l&apos;outil après les premiers retours, et fixer une date de bascule ferme. Une application refusée l&apos;est presque toujours parce qu&apos;elle demande plus d&apos;efforts qu&apos;elle n&apos;en fait gagner à celui qui la saisit — et ce déséquilibre se corrige dans la conception, pas dans la conduite du changement.</description><pubDate>Sun, 05 Apr 2026 00:00:00 GMT</pubDate><category>produit</category><category>méthode</category><category>cas concret</category></item><item><title>Sur-mesure ou no-code : où passe la frontière, vraiment</title><link>https://we-it.co/blog/sur-mesure-ou-no-code</link><guid isPermaLink="true">https://we-it.co/blog/sur-mesure-ou-no-code</guid><description>Le no-code convient tant que l&apos;application reste dans les rails de la plateforme : peu d&apos;utilisateurs simultanés, logique métier simple, peu d&apos;intégrations, aucune contrainte forte de performance ou de conformité. La frontière ne se situe pas au niveau de la complexité apparente mais du modèle de données : dès qu&apos;il devient relationnel et contraint, le no-code coûte plus cher qu&apos;un développement classique. Le bon usage est de valider vite un besoin en no-code, puis de reconstruire ce qui a trouvé son public.</description><pubDate>Tue, 31 Mar 2026 00:00:00 GMT</pubDate><category>architecture</category><category>no-code</category><category>arbitrage</category></item><item><title>Maintenir une application mobile : le budget qu&apos;on oublie toujours</title><link>https://we-it.co/blog/maintenir-une-application-mobile-dans-la-duree</link><guid isPermaLink="true">https://we-it.co/blog/maintenir-une-application-mobile-dans-la-duree</guid><description>Entre quelques jours et quelques semaines par an et par plateforme, même sans ajouter la moindre fonctionnalité. Ce budget couvre trois obligations subies : les versions annuelles d&apos;iOS et d&apos;Android à tester, les exigences des magasins qui évoluent avec des échéances fermes, et les dépendances techniques qu&apos;il faut suivre pour rester à jour. Une application mobile laissée sans entretien pendant deux ans ne dégrade pas progressivement — elle devient impubliable d&apos;un coup, et la remise à niveau coûte alors bien plus cher que l&apos;entretien évité.</description><pubDate>Fri, 27 Mar 2026 00:00:00 GMT</pubDate><category>mobile</category><category>run</category><category>budget</category></item><item><title>Développer en interne, externaliser, ou acheter un logiciel du marché ?</title><link>https://we-it.co/blog/interne-externaliser-ou-acheter</link><guid isPermaLink="true">https://we-it.co/blog/interne-externaliser-ou-acheter</guid><description>Achetez un logiciel du marché si votre besoin est standard — c&apos;est presque toujours moins cher, même en s&apos;adaptant un peu. Développez sur mesure quand le processus concerné vous différencie de vos concurrents. Externalisez quand vous avez besoin de la compétence sans vouloir la recruter durablement. La question à trancher d&apos;abord n&apos;est pas « qui code ? » mais « ce processus fait-il partie de ce qui nous distingue ? ».</description><pubDate>Sun, 22 Mar 2026 00:00:00 GMT</pubDate><category>achat</category><category>stratégie</category><category>cadrage</category></item><item><title>Construire un tableau de bord que les gens utilisent vraiment</title><link>https://we-it.co/blog/tableau-de-bord-vraiment-utilise</link><guid isPermaLink="true">https://we-it.co/blog/tableau-de-bord-vraiment-utilise</guid><description>Parce qu&apos;ils répondent à la question « que peut-on afficher ? » au lieu de « quelle décision faut-il prendre ? ». Un tableau de bord utilisé tient sur un écran, comporte cinq à sept indicateurs maximum, affiche systématiquement une référence de comparaison, et se rattache à une réunion existante. S&apos;il ne change aucune décision, il ne sera pas consulté — quelle que soit sa qualité graphique.</description><pubDate>Thu, 19 Mar 2026 00:00:00 GMT</pubDate><category>data</category><category>restitution</category><category>méthode</category></item><item><title>Reprendre un projet dont personne ne veut : ma première semaine</title><link>https://we-it.co/blog/reprendre-un-projet-la-premiere-semaine</link><guid isPermaLink="true">https://we-it.co/blog/reprendre-un-projet-la-premiere-semaine</guid><description>En cinq étapes, dans l&apos;ordre : faire tourner l&apos;application en local sans aide, suivre un parcours utilisateur complet dans le code, lire l&apos;historique des six derniers mois pour voir où ça bouge, corriger un bug minuscule et le mettre en production, puis écrire ce qui manquait à la documentation. La compréhension vient de l&apos;exécution et de la première livraison, pas de la lecture exhaustive du code.</description><pubDate>Sun, 15 Mar 2026 00:00:00 GMT</pubDate><category>méthode</category><category>RUN</category><category>qualité</category></item><item><title>Écrire une demande qui ne se transforme pas en malentendu</title><link>https://we-it.co/blog/user-story-sans-malentendu</link><guid isPermaLink="true">https://we-it.co/blog/user-story-sans-malentendu</guid><description>En décrivant le problème et les critères d&apos;acceptation observables, jamais la solution technique. Une demande exploitable tient en une page : qui, quel problème, ce qui doit être vrai à la fin, les cas particuliers connus, et ce qui est explicitement hors périmètre. La section « hors périmètre » est celle qui évite le plus de malentendus, et c&apos;est celle qu&apos;on oublie systématiquement.</description><pubDate>Tue, 10 Mar 2026 00:00:00 GMT</pubDate><category>méthode</category><category>cadrage</category><category>produit</category></item><item><title>Sécurité d&apos;une application métier : les huit points que nous vérifions systématiquement</title><link>https://we-it.co/blog/securite-application-metier</link><guid isPermaLink="true">https://we-it.co/blog/securite-application-metier</guid><description>Huit points, avant toute mise en production : l&apos;authentification déléguée à un composant éprouvé, un contrôle d&apos;accès vérifié côté serveur sur chaque requête, le cloisonnement des données entre organisations, le chiffrement en transit et au repos, la journalisation des accès sensibles, la gestion des secrets hors du code, les mises à jour de dépendances automatisées, et une procédure de restauration testée. Aucun de ces points n&apos;est exotique : ce sont les mêmes failles que l&apos;on retrouve année après année.</description><pubDate>Sat, 07 Mar 2026 00:00:00 GMT</pubDate><category>sécurité</category><category>RUN</category><category>méthode</category></item><item><title>Performance et batterie : ce qui fait désinstaller une application</title><link>https://we-it.co/blog/performance-et-batterie-mobile</link><guid isPermaLink="true">https://we-it.co/blog/performance-et-batterie-mobile</guid><description>Trois causes dominent : un démarrage trop long, une interface qui saccade, et une consommation de batterie perçue comme anormale. Les deux premières se corrigent en déplaçant le travail hors du démarrage et hors du fil d&apos;affichage. La troisième vient presque toujours de la position en continu, de la synchronisation trop fréquente ou d&apos;un travail en arrière-plan mal borné. Ces trois causes se mesurent avec l&apos;outillage fourni par les plateformes, sur un appareil ancien plutôt que sur le téléphone du développeur.</description><pubDate>Tue, 03 Mar 2026 00:00:00 GMT</pubDate><category>mobile</category><category>qualité</category><category>run</category></item><item><title>ESN, agence, éditeur, freelance : qui fait quoi, et lequel vous faut-il ?</title><link>https://we-it.co/blog/esn-agence-editeur-freelance</link><guid isPermaLink="true">https://we-it.co/blog/esn-agence-editeur-freelance</guid><description>Une ESN met des consultants à disposition dans vos équipes et vous pilotez. Une agence ou un studio livre un projet complet et porte l&apos;engagement de résultat. Un éditeur vend son logiciel, que vous adaptez à la marge. Un freelance apporte une compétence pointue sans continuité garantie. Le bon choix dépend d&apos;une seule chose : qui, chez vous, va piloter — et pendant combien de temps.</description><pubDate>Fri, 27 Feb 2026 00:00:00 GMT</pubDate><category>achat</category><category>prestataire</category><category>stratégie</category></item><item><title>Quand personne ne fait confiance aux chiffres : par où commencer</title><link>https://we-it.co/blog/personne-ne-fait-confiance-aux-chiffres</link><guid isPermaLink="true">https://we-it.co/blog/personne-ne-fait-confiance-aux-chiffres</guid><description>En arrêtant de chercher le bon chiffre pour chercher la bonne définition. Dans la quasi-totalité des cas, deux services qui affichent un résultat différent calculent en réalité deux choses différentes : périmètre, date de référence ou statut retenu ne sont pas les mêmes. La première étape n&apos;est donc pas technique mais lexicale — écrire, indicateur par indicateur, ce que chaque terme recouvre exactement, et qui en est responsable.</description><pubDate>Tue, 24 Feb 2026 00:00:00 GMT</pubDate><category>data</category><category>gouvernance</category><category>méthode</category></item><item><title>Quels tests écrire quand on n&apos;a pas le temps de tout tester</title><link>https://we-it.co/blog/quels-tests-ecrire-quand-on-na-pas-le-temps</link><guid isPermaLink="true">https://we-it.co/blog/quels-tests-ecrire-quand-on-na-pas-le-temps</guid><description>Trois familles, dans cet ordre : les tests des règles de gestion — celles qui coûtent de l&apos;argent si elles se trompent ; les tests des parcours critiques de bout en bout, deux ou trois maximum ; et un test de non-régression pour chaque bug corrigé. Chercher un taux de couverture élevé est une mauvaise cible : une couverture de 40 % concentrée sur les règles métier protège mieux qu&apos;une couverture de 80 % répartie uniformément.</description><pubDate>Thu, 19 Feb 2026 00:00:00 GMT</pubDate><category>qualité</category><category>tests</category><category>méthode</category></item><item><title>Prioriser quand tout est urgent</title><link>https://we-it.co/blog/prioriser-quand-tout-est-urgent</link><guid isPermaLink="true">https://we-it.co/blog/prioriser-quand-tout-est-urgent</guid><description>En remplaçant la question « est-ce urgent ? » par « que se passe-t-il si on ne le fait pas ce trimestre ? ». Cette reformulation fait apparaître le coût réel de l&apos;attente, qui est souvent nul. Ensuite, imposez une contrainte de rareté : une liste ordonnée sans ex æquo, et une capacité affichée. Tant que plusieurs demandes peuvent être « prioritaires » simultanément, aucune priorisation n&apos;a lieu.</description><pubDate>Sun, 15 Feb 2026 00:00:00 GMT</pubDate><category>méthode</category><category>cadrage</category><category>produit</category></item><item><title>Reprendre le RUN d&apos;une application qu&apos;on n&apos;a pas écrite</title><link>https://we-it.co/blog/reprendre-le-run-application-heritee</link><guid isPermaLink="true">https://we-it.co/blog/reprendre-le-run-application-heritee</guid><description>Par un audit de deux à trois semaines avant tout engagement : capacité à reconstruire l&apos;application depuis zéro, état des dépendances et des failles connues, couverture de tests, accès aux environnements, et qualité de la reprise de données. Le critère décisif n&apos;est pas la propreté du code mais la capacité à déployer une correction en production en moins d&apos;une journée. Tant qu&apos;on ne sait pas faire ça, on ne peut pas s&apos;engager sur des délais de rétablissement.</description><pubDate>Tue, 10 Feb 2026 00:00:00 GMT</pubDate><category>RUN</category><category>audit</category><category>méthode</category></item><item><title>Une application mobile qui marche sans réseau : ce que ça change</title><link>https://we-it.co/blog/application-mobile-hors-ligne</link><guid isPermaLink="true">https://we-it.co/blog/application-mobile-hors-ligne</guid><description>En considérant l&apos;appareil comme la source de vérité temporaire et le serveur comme un point de synchronisation, pas l&apos;inverse. Concrètement : une base locale sur le téléphone, une file d&apos;opérations en attente rejouées à la reconnexion, un identifiant généré côté appareil pour ne pas dépendre du serveur, et une règle de résolution de conflits décidée avec le métier. Le hors ligne n&apos;est pas une option qu&apos;on ajoute — c&apos;est une décision d&apos;architecture qui doit être prise au début du projet.</description><pubDate>Sat, 07 Feb 2026 00:00:00 GMT</pubDate><category>mobile</category><category>architecture</category><category>cas concret</category></item><item><title>Contrat de développement : les sept clauses que je vous conseille de relire</title><link>https://we-it.co/blog/contrat-developpement-ce-qu-il-faut-verifier</link><guid isPermaLink="true">https://we-it.co/blog/contrat-developpement-ce-qu-il-faut-verifier</guid><description>Sept points : la cession des droits sur le code (intégrale et sans condition), la documentation comme livrable contractuel, les conditions de réversibilité, la définition précise de la recette et de ses délais, le traitement des demandes de changement, les engagements de service après mise en production, et la propriété des données. L&apos;absence d&apos;une seule de ces clauses peut vous coûter plus cher que l&apos;écart de prix entre deux prestataires.</description><pubDate>Tue, 03 Feb 2026 00:00:00 GMT</pubDate><category>achat</category><category>contrat</category><category>réversibilité</category></item><item><title>Les erreurs de conception de base de données que je vois le plus souvent</title><link>https://we-it.co/blog/erreurs-conception-base-de-donnees</link><guid isPermaLink="true">https://we-it.co/blog/erreurs-conception-base-de-donnees</guid><description>Six reviennent constamment : absence de contraintes d&apos;intégrité déléguées au code applicatif, suppression physique des enregistrements au lieu d&apos;un archivage, stockage des dates sans fuseau horaire, montants en nombres flottants, statuts en texte libre sans référentiel, et absence d&apos;index sur les colonnes de filtrage. Toutes se corrigent facilement au début du projet et deviennent très coûteuses une fois la base remplie.</description><pubDate>Thu, 29 Jan 2026 00:00:00 GMT</pubDate><category>architecture</category><category>qualité</category><category>data</category></item><item><title>La recette : comment la préparer pour qu&apos;elle serve à quelque chose</title><link>https://we-it.co/blog/preparer-une-recette-utile</link><guid isPermaLink="true">https://we-it.co/blog/preparer-une-recette-utile</guid><description>En la préparant avant le début du développement, pas à la fin. Il faut trois choses : des personnes nommées avec du temps réellement bloqué dans leur agenda, des scénarios écrits à partir de situations réelles plutôt qu&apos;une liste de fonctionnalités, et un jeu de données représentatif incluant les cas tordus. Une recette improvisée en fin de projet ne trouve que les erreurs évidentes et laisse passer celles qui coûtent cher.</description><pubDate>Mon, 26 Jan 2026 00:00:00 GMT</pubDate><category>méthode</category><category>recette</category><category>qualité</category></item><item><title>Un même logiciel, quatre marchés : comment nous déclinons une plateforme par verticale</title><link>https://we-it.co/blog/plateforme-multi-marques-clubs</link><guid isPermaLink="true">https://we-it.co/blog/plateforme-multi-marques-clubs</guid><description>Oui, à condition de séparer dès le départ le socle technique du vocabulaire métier. Nous exploitons une même plateforme de gestion d&apos;association sous quatre marques — Vibe-it pour les écoles de danse, Moove-IT pour les clubs sportifs, et deux autres verticales — avec un socle commun et des parcours propres à chaque univers. Ouvrir un nouveau marché coûte alors une fraction du coût initial.</description><pubDate>Thu, 22 Jan 2026 00:00:00 GMT</pubDate><category>architecture</category><category>produit</category><category>cas concret</category></item><item><title>Publier sur l&apos;App Store et Google Play : ce que personne ne dit avant</title><link>https://we-it.co/blog/publier-sur-app-store-et-google-play</link><guid isPermaLink="true">https://we-it.co/blog/publier-sur-app-store-et-google-play</guid><description>Comptez deux à quatre semaines entre l&apos;application finie et sa disponibilité publique, dont la moitié en préparation administrative. Apple relit chaque version manuellement — de quelques heures à plusieurs jours — et refuse pour des motifs souvent non fonctionnels : formulaire de confidentialité incomplet, connexion imposée sans justification, mécanisme de paiement hors du sien. Google publie plus vite mais impose une validation d&apos;identité et des phases de déploiement progressif. Les comptes développeur, les certificats et les fiches produit doivent être créés au nom de l&apos;entreprise, jamais d&apos;une personne.</description><pubDate>Sun, 18 Jan 2026 00:00:00 GMT</pubDate><category>mobile</category><category>méthode</category><category>run</category></item><item><title>Ce que coûte de ne rien faire</title><link>https://we-it.co/blog/ce-que-coute-de-ne-rien-faire</link><guid isPermaLink="true">https://we-it.co/blog/ce-que-coute-de-ne-rien-faire</guid><description>En additionnant quatre postes rarement mesurés : le temps passé sur des tâches manuelles évitables, le coût des erreurs et de leur rattrapage, les occasions perdues faute de réactivité, et le risque de dépendance à une personne ou à un fichier unique. Ce coût est invisible parce qu&apos;il est réparti et n&apos;apparaît sur aucune ligne budgétaire — mais il se reconduit chaque année et augmente avec l&apos;activité.</description><pubDate>Thu, 15 Jan 2026 00:00:00 GMT</pubDate><category>budget</category><category>stratégie</category><category>achat</category></item><item><title>Découper une fonctionnalité en tâches livrables</title><link>https://we-it.co/blog/decouper-une-fonctionnalite-en-taches</link><guid isPermaLink="true">https://we-it.co/blog/decouper-une-fonctionnalite-en-taches</guid><description>En tranches verticales qui traversent toutes les couches et produisent chacune quelque chose de démontrable, plutôt qu&apos;en couches horizontales — base, puis service, puis interface. Chaque tranche doit être livrable en un à trois jours et apporter une valeur observable, même minime. Un découpage horizontal donne l&apos;illusion d&apos;avancer pendant des semaines sans que rien ne soit vérifiable.</description><pubDate>Sat, 10 Jan 2026 00:00:00 GMT</pubDate><category>méthode</category><category>qualité</category></item><item><title>MVP : ce que ça veut dire, et surtout ce que ça ne veut pas dire</title><link>https://we-it.co/blog/mvp-ce-que-ca-veut-dire</link><guid isPermaLink="true">https://we-it.co/blog/mvp-ce-que-ca-veut-dire</guid><description>Un MVP est la plus petite version qui résout un problème réel de bout en bout pour un utilisateur, et dont on peut tirer un apprentissage. Ce n&apos;est pas une version incomplète, ni une maquette, ni un prototype jetable : ce qu&apos;il fait, il le fait correctement, en production. Le bon critère de découpage n&apos;est pas « quelles fonctionnalités enlever » mais « quel utilisateur, sur quel cas, peut aller au bout sans nous ».</description><pubDate>Tue, 06 Jan 2026 00:00:00 GMT</pubDate><category>produit</category><category>cadrage</category><category>méthode</category></item><item><title>Monolithe ou micro-services pour une application métier ? Notre choix par défaut</title><link>https://we-it.co/blog/monolithe-ou-microservices</link><guid isPermaLink="true">https://we-it.co/blog/monolithe-ou-microservices</guid><description>Partez sur un monolithe modulaire, sauf raison explicite de faire autrement. Les micro-services résolvent des problèmes d&apos;organisation — plusieurs équipes qui doivent déployer indépendamment — et de mise à l&apos;échelle différenciée. Une application métier avec une seule équipe n&apos;a ni l&apos;un ni l&apos;autre : elle hérite alors de toute la complexité distribuée sans aucun des bénéfices. Le bon découpage se découvre en construisant, pas en dessinant.</description><pubDate>Thu, 01 Jan 2026 00:00:00 GMT</pubDate><category>architecture</category><category>arbitrage</category></item><item><title>Application mobile : natif, multiplateforme ou web ?</title><link>https://we-it.co/blog/natif-cross-platform-ou-web-mobile</link><guid isPermaLink="true">https://we-it.co/blog/natif-cross-platform-ou-web-mobile</guid><description>Un site web responsive suffit si l&apos;usage est occasionnel et ne demande ni fonctionnement hors ligne, ni notifications, ni accès au matériel. Le multiplateforme est le meilleur compromis pour une application métier : une seule base de code pour iOS et Android, avec 80 à 90 % du code partagé. Le natif se justifie quand la performance graphique, l&apos;accès fin au matériel ou l&apos;intégration système sont au cœur du produit — sinon il double le coût de développement et de maintenance.</description><pubDate>Mon, 29 Dec 2025 00:00:00 GMT</pubDate><category>mobile</category><category>architecture</category><category>arbitrage</category></item><item><title>Combien coûte une application web métier ? Ce que je réponds vraiment</title><link>https://we-it.co/blog/combien-coute-application-web</link><guid isPermaLink="true">https://we-it.co/blog/combien-coute-application-web</guid><description>Une application métier sur mesure se situe le plus souvent entre 50 000 € et 400 000 € pour une première version en production, selon le nombre d&apos;interfaces avec l&apos;existant, de profils utilisateurs et de contraintes réglementaires. Le budget de départ n&apos;est pas le vrai sujet : il faut compter 15 à 25 % du coût initial par an pour l&apos;exploitation et les évolutions, sans quoi l&apos;application se dégrade en quelques mois.</description><pubDate>Thu, 25 Dec 2025 00:00:00 GMT</pubDate><category>budget</category><category>achat</category><category>cadrage</category></item><item><title>Ce que je regarde vraiment dans une revue de code</title><link>https://we-it.co/blog/ce-que-je-regarde-en-revue-de-code</link><guid isPermaLink="true">https://we-it.co/blog/ce-que-je-regarde-en-revue-de-code</guid><description>Sur quatre choses, dans cet ordre : la gestion des cas d&apos;erreur, les frontières entre modules, la lisibilité pour quelqu&apos;un qui découvre le code, et la testabilité. Le style, le nommage et la mise en forme ne doivent pas être discutés en revue — ils relèvent de l&apos;outillage automatique. Une revue qui parle surtout de style est une revue qui n&apos;a pas regardé la conception.</description><pubDate>Sat, 20 Dec 2025 00:00:00 GMT</pubDate><category>qualité</category><category>méthode</category></item><item><title>Combien de temps faut-il pour créer une application web métier ?</title><link>https://we-it.co/blog/duree-creation-application-web</link><guid isPermaLink="true">https://we-it.co/blog/duree-creation-application-web</guid><description>Comptez 1 à 3 mois entre le premier atelier et la mise en production d&apos;une première version utilisable. Le cadrage prend 1 à 2 semaines, la conception 1 à 3 semaines, la construction 2 à 6 semaines par sprints de 2 semaines, et la mise en production 1 à 2 semaines. L&apos;IA a divisé la durée de construction ; elle n&apos;a rien changé au cadrage, à la décision ni à la reprise de données — qui occupent désormais la moitié du calendrier.</description><pubDate>Wed, 17 Dec 2025 00:00:00 GMT</pubDate><category>méthode</category><category>délais</category><category>cadrage</category><category>ia</category></item><item><title>Faire monter une équipe technique : ce qui marche, ce qui coûte cher</title><link>https://we-it.co/blog/faire-monter-une-equipe-technique</link><guid isPermaLink="true">https://we-it.co/blog/faire-monter-une-equipe-technique</guid><description>En recrutant sur la capacité à apprendre et à travailler avec d&apos;autres plutôt que sur la maîtrise d&apos;une technologie précise, et en organisant la montée en compétence dans le travail réel : revue de code systématique, binômes sur les sujets difficiles, et rotation sur les parties du système. Les formations ponctuelles sans mise en pratique immédiate ne laissent presque rien. Le vrai facteur de progression est le temps d&apos;exposition à du code relu par quelqu&apos;un de plus expérimenté.</description><pubDate>Sat, 13 Dec 2025 00:00:00 GMT</pubDate><category>équipe</category><category>recrutement</category><category>méthode</category></item><item><title>Convaincre sa direction d&apos;investir dans une application métier</title><link>https://we-it.co/blog/convaincre-sa-direction-investir-application</link><guid isPermaLink="true">https://we-it.co/blog/convaincre-sa-direction-investir-application</guid><description>En chiffrant le coût de la situation actuelle avant de parler du coût du projet. Une direction ne compare pas un devis à zéro : elle compare deux coûts. Le dossier tient en une page — ce que la situation actuelle coûte chaque année, ce que le projet coûte en investissement et en fonctionnement, à partir de quand l&apos;un compense l&apos;autre, et ce qui se passe si l&apos;on ne fait rien pendant deux ans.</description><pubDate>Tue, 09 Dec 2025 00:00:00 GMT</pubDate><category>achat</category><category>budget</category><category>stratégie</category></item><item><title>Automatiser la saisie d&apos;un document métier : ce que le cas OptiBot nous a appris</title><link>https://we-it.co/blog/automatiser-saisie-document-metier</link><guid isPermaLink="true">https://we-it.co/blog/automatiser-saisie-document-metier</guid><description>En traitant l&apos;extraction comme une aide à la saisie, pas comme un remplacement. OptiBot lit les documents de tiers payant et pré-remplit les dossiers : l&apos;opérateur valide au lieu de ressaisir. Le point déterminant n&apos;est pas la qualité du modèle d&apos;extraction, mais la conception de l&apos;écran de validation et le traitement des cas où la lecture échoue.</description><pubDate>Sat, 06 Dec 2025 00:00:00 GMT</pubDate><category>IA</category><category>cas concret</category><category>productivité</category></item><item><title>Comment nous utilisons l&apos;IA pour développer — et ce que nous ne lui confions pas</title><link>https://we-it.co/blog/ia-dans-notre-chaine-de-production</link><guid isPermaLink="true">https://we-it.co/blog/ia-dans-notre-chaine-de-production</guid><description>Nous l&apos;utilisons sur quatre tâches où le résultat est vérifiable : générer du code à partir d&apos;une spécification écrite, écrire des tests, produire de la documentation, et faire une première passe de revue. Nous ne lui confions ni les décisions d&apos;architecture, ni la modélisation des données, ni l&apos;arbitrage de périmètre. La règle est simple : l&apos;IA écrit ce qu&apos;un humain peut vérifier en moins de temps qu&apos;il n&apos;en aurait mis à l&apos;écrire.</description><pubDate>Mon, 01 Dec 2025 00:00:00 GMT</pubDate><category>IA</category><category>méthode</category><category>qualité</category></item><item><title>Comment on décide d&apos;arrêter une fonctionnalité</title><link>https://we-it.co/blog/decider-arreter-une-fonctionnalite</link><guid isPermaLink="true">https://we-it.co/blog/decider-arreter-une-fonctionnalite</guid><description>En regardant trois chiffres : le nombre d&apos;utilisateurs distincts sur les trois derniers mois, la part qu&apos;elle représente dans les demandes de support, et le coût qu&apos;elle impose aux évolutions voisines. Une fonctionnalité utilisée par moins de 2 % des utilisateurs et qui complique chaque livraison doit être retirée. Le vrai obstacle n&apos;est jamais technique : c&apos;est qu&apos;aucune organisation ne récompense la suppression.</description><pubDate>Thu, 27 Nov 2025 00:00:00 GMT</pubDate><category>produit</category><category>méthode</category><category>qualité</category></item><item><title>Environnements et déploiements : le minimum qui change tout</title><link>https://we-it.co/blog/environnements-et-deploiements</link><guid isPermaLink="true">https://we-it.co/blog/environnements-et-deploiements</guid><description>Trois environnements suffisent : développement local, préproduction identique à la production, et production. Le déploiement doit être automatisé, reproductible et déclenché par une seule commande, avec un retour arrière possible en quelques minutes. Le critère qui résume tout : combien de temps faut-il pour mettre une correction d&apos;une ligne en production ? Tant que la réponse dépasse une journée, tous les engagements de délai sont théoriques.</description><pubDate>Sat, 22 Nov 2025 00:00:00 GMT</pubDate><category>RUN</category><category>méthode</category><category>qualité</category></item><item><title>Faut-il lancer un appel d&apos;offres pour un projet applicatif ?</title><link>https://we-it.co/blog/faut-il-un-appel-d-offres</link><guid isPermaLink="true">https://we-it.co/blog/faut-il-un-appel-d-offres</guid><description>Rarement, sauf obligation réglementaire. Un appel d&apos;offres classique suppose un besoin figé et comparable, ce qui est presque jamais le cas d&apos;un projet applicatif : il pousse les candidats à chiffrer un document plutôt qu&apos;à comprendre un problème, et favorise celui qui a le plus exclu de son devis. Une consultation restreinte à trois prestataires, précédée d&apos;un cadrage payant, donne de meilleurs résultats pour un effort bien moindre.</description><pubDate>Wed, 19 Nov 2025 00:00:00 GMT</pubDate><category>achat</category><category>prestataire</category><category>méthode</category></item><item><title>Une application qui rame : où chercher, dans quel ordre</title><link>https://we-it.co/blog/application-lente-ou-chercher</link><guid isPermaLink="true">https://we-it.co/blog/application-lente-ou-chercher</guid><description>Dans neuf cas sur dix, la cause est l&apos;accès aux données : requêtes multipliées dans une boucle, index manquant, ou chargement de bien plus de données que nécessaire. Il faut mesurer avant de toucher quoi que ce soit — identifier la page lente, puis le temps passé côté base, côté application et côté navigateur. Optimiser sans mesure conduit à améliorer ce qui n&apos;était pas le problème.</description><pubDate>Sat, 15 Nov 2025 00:00:00 GMT</pubDate><category>qualité</category><category>RUN</category><category>architecture</category></item><item><title>Nos ateliers de cadrage : le déroulé, heure par heure</title><link>https://we-it.co/blog/atelier-de-cadrage-le-deroule</link><guid isPermaLink="true">https://we-it.co/blog/atelier-de-cadrage-le-deroule</guid><description>Sur deux à quatre semaines, en quatre ateliers de deux à trois heures : cartographier le processus actuel tel qu&apos;il se passe réellement, identifier les irritants et les chiffrer, arbitrer le périmètre de la première version, puis valider les critères de succès et les risques. Les participants doivent inclure ceux qui font le travail, pas seulement ceux qui le dirigent — c&apos;est la condition qui détermine la qualité du résultat.</description><pubDate>Mon, 10 Nov 2025 00:00:00 GMT</pubDate><category>cadrage</category><category>méthode</category><category>produit</category></item><item><title>Concevoir une API dont le contrat tient dans le temps</title><link>https://we-it.co/blog/concevoir-une-api-qui-dure</link><guid isPermaLink="true">https://we-it.co/blog/concevoir-une-api-qui-dure</guid><description>En traitant le contrat comme une promesse : on n&apos;enlève jamais un champ, on ne change jamais le sens d&apos;un champ existant, et on n&apos;ajoute jamais de champ obligatoire. Toute évolution se fait par ajout de champs optionnels. Le versionnage n&apos;est nécessaire que pour les ruptures qu&apos;on n&apos;a pas su éviter — et chaque version supplémentaire est une dette permanente, puisqu&apos;il faut la maintenir aussi longtemps que quelqu&apos;un l&apos;utilise.</description><pubDate>Fri, 07 Nov 2025 00:00:00 GMT</pubDate><category>architecture</category><category>qualité</category></item><item><title>Négocier un contrat de maintenance applicative</title><link>https://we-it.co/blog/negocier-un-contrat-de-maintenance</link><guid isPermaLink="true">https://we-it.co/blog/negocier-un-contrat-de-maintenance</guid><description>Cinq éléments : la distinction claire entre correctif et évolutif avec deux budgets séparés, des délais de prise en compte et de rétablissement par niveau de gravité, un volume d&apos;évolutions garanti par période, les conditions de réversibilité, et un point de pilotage régulier. Un contrat qui ne sépare pas le correctif de l&apos;évolutif produit toujours le même effet : les corrections consomment le budget et rien n&apos;évolue.</description><pubDate>Mon, 03 Nov 2025 00:00:00 GMT</pubDate><category>achat</category><category>contrat</category><category>RUN</category></item><item><title>Cloud ou serveur dédié : comment nous choisissons</title><link>https://we-it.co/blog/cloud-ou-serveur-dedie</link><guid isPermaLink="true">https://we-it.co/blog/cloud-ou-serveur-dedie</guid><description>Un serveur dédié ou un VPS suffit à la grande majorité des applications métier : charge prévisible, quelques centaines d&apos;utilisateurs, coût trois à cinq fois inférieur à un équivalent cloud managé. Le cloud se justifie sur trois critères précis — charge très variable, besoin de redondance géographique, ou volonté d&apos;externaliser l&apos;exploitation faute d&apos;équipe. La question n&apos;est pas technique mais économique : qui exploite, et combien de temps cela coûte-t-il ?</description><pubDate>Thu, 30 Oct 2025 00:00:00 GMT</pubDate><category>architecture</category><category>RUN</category><category>arbitrage</category></item><item><title>Les signaux qu&apos;un projet informatique est en train de déraper</title><link>https://we-it.co/blog/signaux-alerte-projet-qui-derape</link><guid isPermaLink="true">https://we-it.co/blog/signaux-alerte-projet-qui-derape</guid><description>Quatre signaux précoces, avant tout retard visible : vous n&apos;avez rien vu fonctionner depuis plus de trois semaines, les réponses à vos questions deviennent vagues, l&apos;équipe qui travaille change sans explication, et les comptes rendus parlent d&apos;avancement en pourcentage plutôt qu&apos;en fonctionnalités livrées. Chacun est détectable un à deux mois avant que le retard n&apos;apparaisse au planning.</description><pubDate>Mon, 27 Oct 2025 00:00:00 GMT</pubDate><category>achat</category><category>pilotage</category><category>prestataire</category></item><item><title>La dette technique : comment on la mesure, et comment on la finance</title><link>https://we-it.co/blog/dette-technique-mesurer-financer</link><guid isPermaLink="true">https://we-it.co/blog/dette-technique-mesurer-financer</guid><description>Mesurez-la par ses effets, pas par des métriques de code : temps moyen pour livrer une correction, proportion de modifications qui causent une régression, temps de reconstruction et de déploiement, et nombre de dépendances non maintenues. Financez-la par une allocation permanente — nous réservons 15 à 20 % de la capacité de chaque itération — plutôt que par des chantiers exceptionnels, qui sont toujours reportés.</description><pubDate>Wed, 22 Oct 2025 00:00:00 GMT</pubDate><category>qualité</category><category>RUN</category><category>méthode</category></item><item><title>Comment choisir son prestataire pour développer une application web ?</title><link>https://we-it.co/blog/choisir-prestataire-application-web</link><guid isPermaLink="true">https://we-it.co/blog/choisir-prestataire-application-web</guid><description>Jugez sur trois choses vérifiables : des réalisations comparables encore en production, la qualité des questions posées lors du premier rendez-vous, et ce que prévoit le contrat en cas de séparation — propriété du code, documentation, réversibilité. Le prix et la taille de l&apos;entreprise sont de mauvais critères de tri : ils ne prédisent ni la qualité de la livraison ni la tenue dans la durée.</description><pubDate>Sat, 18 Oct 2025 00:00:00 GMT</pubDate><category>achat</category><category>prestataire</category><category>méthode</category></item><item><title>Observabilité : ce que nous instrumentons, et ce que nous ignorons</title><link>https://we-it.co/blog/observabilite-que-mesurer</link><guid isPermaLink="true">https://we-it.co/blog/observabilite-que-mesurer</guid><description>Quatre signaux suffisent pour l&apos;essentiel : le taux d&apos;erreur, le temps de réponse des parcours critiques, la saturation des ressources, et le volume de trafic. À cela s&apos;ajoutent des indicateurs métier — commandes créées, paiements aboutis — souvent plus révélateurs qu&apos;une métrique technique. Une alerte qui se déclenche sans action possible sera ignorée : mieux vaut trois alertes qui réveillent quelqu&apos;un que trente que personne ne regarde.</description><pubDate>Mon, 13 Oct 2025 00:00:00 GMT</pubDate><category>RUN</category><category>qualité</category><category>architecture</category></item><item><title>Un premier rendez-vous chez nous : ce qui s&apos;y passe vraiment</title><link>https://we-it.co/blog/premier-rendez-vous-comment-ca-se-passe</link><guid isPermaLink="true">https://we-it.co/blog/premier-rendez-vous-comment-ca-se-passe</guid><description>Une heure, sans présentation commerciale. On vous pose des questions sur votre activité, votre processus actuel, vos contraintes de délai et de budget, et sur qui décidera. Vous repartez avec une fourchette assumée comme telle, les questions auxquelles il faudra répondre, et notre avis honnête sur la pertinence d&apos;un développement. Si aucune proposition de valeur ne se dégage, nous le disons — c&apos;est moins coûteux pour tout le monde qu&apos;un devis de complaisance.</description><pubDate>Fri, 10 Oct 2025 00:00:00 GMT</pubDate><category>achat</category><category>prestataire</category><category>méthode</category></item><item><title>Migrer une application ancienne sans tout casser</title><link>https://we-it.co/blog/migrer-une-application-legacy</link><guid isPermaLink="true">https://we-it.co/blog/migrer-une-application-legacy</guid><description>Par remplacement progressif : on place un point d&apos;entrée unique devant l&apos;ancienne application, on détourne un parcours à la fois vers le nouveau code, et on supprime l&apos;ancien morceau une fois la bascule stabilisée. L&apos;application reste en production en permanence, chaque étape est réversible, et l&apos;on peut s&apos;arrêter à tout moment sans perte. La réécriture complète, elle, suppose de reconstruire des années de règles non documentées pendant que l&apos;existant continue d&apos;évoluer.</description><pubDate>Mon, 06 Oct 2025 00:00:00 GMT</pubDate><category>architecture</category><category>RUN</category><category>méthode</category></item><item><title>Rédiger un cahier des charges qui ne se retourne pas contre vous</title><link>https://we-it.co/blog/cahier-des-charges-application</link><guid isPermaLink="true">https://we-it.co/blog/cahier-des-charges-application</guid><description>Décrivez les problèmes à résoudre et les résultats attendus, pas les écrans que vous imaginez. Un bon cahier des charges tient en 10 à 20 pages : contexte, utilisateurs et volumétrie, processus actuels, contraintes non négociables, critères de succès mesurables. Les documents de 80 pages remplis de spécifications d&apos;interface produisent des devis élevés et des applications rigides, parce qu&apos;ils verrouillent des solutions avant d&apos;avoir compris le besoin.</description><pubDate>Wed, 01 Oct 2025 00:00:00 GMT</pubDate><category>cadrage</category><category>achat</category><category>méthode</category></item><item><title>Choisir sa stack technique : les critères qui comptent vraiment</title><link>https://we-it.co/blog/choisir-sa-stack-technique</link><guid isPermaLink="true">https://we-it.co/blog/choisir-sa-stack-technique</guid><description>Quatre critères, dans cet ordre : la capacité à recruter ou remplacer un développeur sur cette technologie dans votre région, la stabilité des versions majeures et la longueur du support, la qualité de l&apos;écosystème sur les besoins non fonctionnels (authentification, paiement, export, observabilité), et l&apos;expérience réelle de l&apos;équipe qui va construire. La performance brute et la modernité du langage arrivent loin derrière : elles ne sont presque jamais le facteur limitant d&apos;une application métier.</description><pubDate>Sun, 28 Sep 2025 00:00:00 GMT</pubDate><category>architecture</category><category>arbitrage</category><category>durabilité</category></item></channel></rss>