Ce qu’il faut pour développer son propre logiciel de réponse aux RFP
Un prototype répond bien à une question. Une plateforme de bid qualifie les appels d’offres, extrait les exigences, remplit les fichiers de l’acheteur, produit offres et présentations, et tient à J-1.
Sur cette page
Développer votre propre logiciel de réponse aux RFP, c’est développer une plateforme pour l’ensemble du bid, pas un outil qui répond à des questions. Une équipe bid se sert du logiciel pour décider si un appel d’offres mérite d’être poursuivi, extraire les exigences et les échéances de quelques centaines de pages, préparer les questions de clarification pour l’acheteur, planifier qui rédige quoi, rédiger et relire les réponses, produire le document d’offre et la présentation, puis tout restituer dans les fichiers de l’acheteur avant l’échéance. Chacune de ces étapes pose ses propres problèmes d’ingénierie, et en dessous se trouvent les éléments que personne ne montre en démo : un traitement des documents qui résiste à tout ce que les acheteurs envoient, une base de connaissances qui reste à jour, une infrastructure qui tient la veille d’une échéance, et le travail de sécurité que votre propre équipe InfoSec exigera. Ce guide passe tout cela en revue, étape par étape, en s’appuyant sur les enseignements tirés du développement de SEQUESTO et sur ce que les équipes bid nous ont raconté des outils qu’elles avaient développés elles-mêmes. La checklist gratuite reprend chaque point sous la forme d’une ligne que vous pouvez attribuer et suivre.
La lecture est longue, et c’est voulu. Si vous rédigez un business case pour un développement interne, ou si vous en relisez un, l’essentiel du coût se trouve dans les sections que vous n’auriez pas pensé à inclure.
Pourquoi la première version semble facile
La première version semble facile parce qu’un modèle d’IA généraliste, alimenté par un dossier d’anciennes offres, répond bien à une question isolée. Collez une question d’appel d’offres dans un chat, joignez quelques documents de l’entreprise, et le brouillon suffit souvent à impressionner un comité de pilotage. Un développeur peut intégrer la même chose dans une petite application web en quelques jours. Ce prototype explique pourquoi tant d’organisations décident de développer elles-mêmes leur RFP response software, et il donne une image trompeuse de ce dans quoi elles s’engagent.
On nous raconte deux versions de la suite. Dans la première, une équipe rédige un prompt soigné, obtient un bon brouillon, puis essaie l’approche sur un appel d’offres réel. Celui-ci se compose d’un classeur Excel protégé de plusieurs centaines de lignes, avec des listes déroulantes qui renvoient à une feuille masquée, d’une déclaration Word remplie d’anciennes cases à cocher et d’un PDF de 150 pages avec la matrice de conformité à la fin. La qualité du texte rédigé tient la route. Tout le reste, non. Le fichier revient abîmé, les nombres de mots sont faux, les sous-questions logées dans des listes numérotées passent à la trappe, et quelqu’un passe la soirée précédant la remise de l’offre à coller les réponses à la main dans le fichier de l’acheteur.
La seconde version est plus lente. Une équipe IA interne construit un bon moteur de recherche sur la bibliothèque d’offres. L’équipe bid l’utilise pendant quelques mois et l’apprécie. Puis l’équipe IA est réaffectée au projet du département suivant, et plus personne ne s’occupe du nouveau format de fichier envoyé par un acheteur, du modèle retiré, du site SharePoint réorganisé ou du contenu de la bibliothèque devenu obsolète sans que personne ne s’en aperçoive. Plusieurs équipes nous ont dit avoir déjà tenté d’automatiser leurs bids, et que l’essai avait échoué parce que personne n’était responsable du contenu. L’outil a porté le chapeau.
Aucune de ces deux histoires ne signifie qu’il ne faut pas développer. Elles montrent que l’essentiel du travail se situe en dehors de ce que l’on voit dans une démo, et qu’il coûte moins cher de le voir en entier avant le premier sprint qu’après le premier bid réel.
Ce qu’implique un bid, du point de vue du logiciel
Un bid est un projet avec une échéance ferme, de nombreux contributeurs et un acheteur qui fixe toutes les règles. Un logiciel qui se contente de rédiger des réponses n’en couvre qu’une étape. Pour mesurer l’ampleur d’un développement, partez des étapes que suit réellement une équipe bid et demandez-vous, pour chacune, ce que le logiciel doit faire.
- L’appel d’offres arrive. Il se présente sous la forme d’un zip de trente documents, d’un lien vers une plateforme d’achat, d’un e-mail avec pièces jointes ou d’un dossier partagé par un collègue. Certains fichiers sont des doublons, d’autres sont dans une autre langue, d’autres encore sont des scans. Plus tard, des addenda et des bulletins de clarification en modifient certaines parties.
- Quelqu’un décide de répondre ou non. Cette décision repose sur l’échéance, les lots, les critères d’attribution, les exigences obligatoires, le montant du marché et l’adéquation de l’opportunité avec l’entreprise. Le logiciel doit trouver ces informations dans les documents et les présenter de sorte qu’un directeur puisse dire oui ou non en une seule réunion.
- L’équipe décompose l’appel d’offres. Les exigences, les questions, les documents obligatoires, les limites de pages et de mots, les règles de mise en forme et les pondérations d’évaluation sont extraits dans des listes sur lesquelles l’équipe peut travailler. C’est ce que les équipes bid appellent la décomposition (le shredding), et le résultat prend souvent la forme d’une matrice de conformité.
- L’équipe pose des questions à l’acheteur. Les ambiguïtés, les contradictions entre documents et les informations manquantes deviennent des questions de clarification, qui ont leur propre échéance, généralement bien avant la date de remise.
- Le travail est planifié. Les sections et les questions sont confiées à des experts nommément désignés, avec des échéances. Les bids plus importants ont droit à un plan, des thèmes gagnants et un calendrier de revues.
- Les réponses et les documents sont rédigés. Réponses aux questionnaires, argumentaire de l’offre, executive summary, CV, études de cas, mémoires méthodologiques et, souvent, une présentation pour la phase de shortlist.
- Tout est relu et approuvé. Plusieurs tours, plusieurs personnes, parfois une validation juridique et une validation des prix.
- La réponse repart au format de l’acheteur. Son classeur, rempli. Son formulaire Word, avec les bonnes cases cochées. Sa plateforme, avec chaque champ complété. Plus vos propres documents, dans votre modèle, dans la limite de pages.
- Après la remise de l’offre. L’acheteur envoie des questions de clarification sur votre offre, vous invite à présenter et finit par vous dire si vous avez gagné. Les réponses approuvées retournent dans la bibliothèque pour le bid suivant.
Un outil qui n’aide qu’à l’étape 6 laisse au bid manager tout le reste à faire à la main, ainsi que le transfert des données entre l’outil et tout le reste. Presque tous les développements internes dont on nous parle ont commencé à l’étape 6 et en sont restés là. La suite de ce guide reprend les étapes à peu près dans l’ordre, puis traite de la base de connaissances, de la couche IA, de l’infrastructure et de la plateforme dont elles dépendent toutes.
Faire entrer l’appel d’offres
Avant toute analyse, l’appel d’offres doit arriver entier dans le logiciel, ce qui est moins simple qu’un bouton d’import ne le laisse croire. Un dossier d’appel d’offres public est souvent un zip de trente ou quarante fichiers : le document principal, les annexes techniques, le classeur du questionnaire, les bordereaux de prix, le projet de contrat, les formulaires à signer, parfois un zip dans le zip. Les RFP privés arrivent en pièces jointes, sous forme de liens vers une data room ou via une plateforme d’achat qui vous demande de vous connecter et de télécharger chaque fichier. Les équipes bid nous ont dit que, pour savoir quelle version d’un document est à jour, il faut souvent fouiller dans sa boîte mail.
Le logiciel doit décompresser les archives imbriquées en toute sécurité, reconnaître les doublons (la même annexe envoyée deux fois sous deux noms), conserver intacts les fichiers de l’acheteur comme trace de ce qui a été reçu, et rattacher chaque document arrivé plus tard au même bid. Les conventions de dossiers comptent. Une équipe avec laquelle nous avons échangé ne modifie jamais un document de l’acheteur et déplace les versions remplacées dans un dossier d’archives, pour que la v0.2 ne soit jamais confondue avec la v0.3. Votre logiciel respecte ce genre de règle, ou il la combat.
Attendez-vous à ce que le dossier mélange les langues, avec le document principal dans une langue et les annexes dans une autre, et qu’il contienne des pages scannées, des fichiers protégés par mot de passe et, de temps à autre, un format que personne n’a ouvert depuis des années. Chacun de ces cas a besoin d’une issue définie : traité, traité avec un avertissement, ou refusé avec une raison sur laquelle le bid manager peut agir. Un fichier dont le traitement échoue en silence est pire qu’un fichier refusé, parce que le bid manager suppose que son contenu a été lu.
Comprendre l’appel d’offres : résumé et informations clés
La première chose qu’une équipe bid attend d’un nouvel appel d’offres, c’est une réponse courte et fiable à la question « de quoi s’agit-il et pour quand ». Extraire cela de quelques centaines de pages semble un travail tout trouvé pour un modèle de langage, et c’est en grande partie le cas. La difficulté, c’est que les informations qui comptent sont peu nombreuses, précises et ne pardonnent pas.
Prenez les dates. Un appel d’offres a une date limite de remise des offres, une date limite pour les questions de clarification, généralement bien plus tôt, parfois une visite de site, une date de présentation, une durée de validité de l’offre et une date d’attribution prévue. Des équipes bid nous ont parlé de résumés qui plaçaient la date limite des questions de clarification dans le mauvais mois, le genre d’erreur qui coûte un bid. Les dates s’accompagnent de fuseaux horaires et de formules comme « au plus tard à 12 h 00, heure locale », et le logiciel doit conserver cette précision au lieu de l’arrondir à un jour calendaire. Stockez les dates comme des dates, vérifiez qu’elles se lisent correctement et refusez de remplir un champ d’échéance avec une supposition. Une seule date mal formée, stockée dans le mauvais format, suffit à faire planter tous les rapports qui la lisent.
L’argent est le piège suivant. Un montant écrit « 1.234 » dans un appel d’offres belge signifie mille deux cent trente-quatre ; lu selon les conventions anglaises, il devient un virgule deux trois quatre, une erreur silencieuse d’un facteur mille. Un montant en dollars placé dans un champ qui suppose des euros devient le même nombre d’euros. Les fourchettes, les montants annuels et les montants maximaux des accords-cadres doivent tous être conservés pour ce qu’ils sont. Lorsqu’un document n’indique pas clairement un montant, le champ doit rester vide et le signaler, avec un lien vers l’endroit où le logiciel a cherché.
Les lots ajoutent une structure qu’un résumé à plat fait disparaître. Les exigences, les seuils financiers et les critères d’attribution peuvent varier selon le lot, et un résumé qui les fusionne, par exemple en présentant l’exigence de chiffre d’affaires d’un lot comme celle de tout l’appel d’offres, fausse la décision. Les critères d’attribution et leurs pondérations doivent ressortir intacts, avec les sous-critères rattachés au critère dont ils relèvent, car ils orientent à la fois la décision de répondre et la manière de rédiger la réponse. Trouver le bon regroupement est réellement ambigu : certains appels d’offres pondèrent les sous-critères séparément, d’autres les notent comme un tout, et les règles d’extraction doivent gérer les deux cas sans double comptage.
Le reste du résumé, ce sont les détails pratiques qui, sinon, vivent dans le carnet du bid manager : les modalités de remise (plateforme, e-mail, exemplaires papier, fichiers protégés par mot de passe), les documents et formulaires obligatoires, les limites de pages et de mots, les règles de mise en forme, les exigences linguistiques, la durée du marché et les options de reconduction, les conditions de paiement, les responsabilités, les niveaux d’assurance et les certificats exigés par l’acheteur. Les équipes bid nous ont aussi demandé des résumés différents selon les lecteurs. Le juridique veut les clauses de responsabilité et de résiliation, l’équipe produit veut le périmètre, le directeur veut l’opportunité en un paragraphe. Elles voulaient aussi le même modèle sur chaque bid, pour pouvoir comparer les résumés et en faire un suivi sur l’année.
Chaque information d’un résumé a besoin d’une source sur laquelle un relecteur peut cliquer : le fichier, la page, le passage. Sans cela, le bid manager doit vérifier chaque ligne à la main, et le résumé ne fait gagner aucun temps.
La qualification et la décision bid/no-bid
C’est en choisissant les appels d’offres auxquels répondre qu’une équipe bid gagne ou perd son temps, et l’aide à la qualification fait partie des premières demandes des équipes une fois que la rédaction des réponses fonctionne. Ce sont aussi deux tâches distinctes qui en ont l’air d’une seule.
La première consiste à lire l’appel d’offres : répondre, à partir des documents, à une série fixe de questions. Quel est le budget, quels sont les critères de sélection et d’attribution et leurs points, quels certificats sont obligatoires, quelles sont les responsabilités, les niveaux de service, les conditions de paiement et de livraison. C’est de l’extraction avec citations, et tout ce qui a été dit plus haut sur les informations clés s’applique.
La seconde consiste à juger l’adéquation : une auto-évaluation notée de la façon dont l’opportunité convient à l’entreprise. Connaissons-nous l’acheteur, connaissons-nous la concurrence, le budget est-il connu, sommes-nous inscrits sur la plateforme, avons-nous les références demandées, le contrat contient-il un point bloquant. Chaque entreprise a ses propres critères, et les équipes avec lesquelles nous échangeons veulent charger leur propre liste plutôt que d’accepter une liste générique. Une équipe est venue avec un long prompt de notation qu’elle avait affiné au fil de nombreux bids. D’autres veulent un contexte commercial que l’appel d’offres ne contient pas : le responsable de compte, le chiffre d’affaires probable, la santé financière de l’acheteur, les concurrents qui ont répondu la dernière fois.
Les utilisateurs se soucient rarement de la distinction, et des libellés séparés pour go/no-go, bid/no-bid et qualification les déroutent : mieux vaut donc les concevoir dès le départ comme un seul module. Changer d’avis plus tard coûte cher dans un produit en production : chaque bid existant doit conserver ses anciennes données de qualification, et les nouveaux modules doivent être ajoutés à des bids qui existent déjà.
La notation elle-même a besoin d’un vrai modèle. Chaque critère a des options, chaque option rapporte des points, certaines options sont des signaux d’alerte qui priment sur le total, et certains critères acceptent plusieurs options à la fois, dont les points s’additionnent. Le modèle choisit des options, et son choix doit être rapproché exactement de votre liste d’options. Si l’on demande au modèle de répondre en français et qu’il traduit « Yes » par « Oui », la notation cesse de fonctionner : les libellés d’options ne doivent donc jamais être traduits, même quand l’explication l’est. Quand rien ne correspond, le critère doit être marqué comme sans réponse, pas recevoir une valeur par défaut.
Les rapports de qualification sont lus par les directeurs et archivés : ils doivent donc s’exporter proprement vers Word et Excel, et les réponses doivent rester cohérentes avec ce que les utilisateurs voient à l’écran. Les réponses écrites en arrière-plan doivent apparaître sur les écrans déjà ouverts, et une réponse et ses sources doivent toujours être écrites ensemble, faute de quoi une nouvelle exécution peut laisser d’anciennes sources à côté d’un champ vide, ce qui ressemble à des preuves de rien du tout.
Toutes les équipes ne veulent pas de cette fonction. Certaines nous ont dit décider d’un coup d’œil, ou que la qualification se fait en réunion et y restera. D’autres veulent que le résultat alimente les étapes suivantes : la décision go crée un plan de bid avec des dates calculées à rebours depuis l’échéance, et les notes et signaux d’alerte réapparaissent dans l’executive summary. Déterminez dans quel camp se trouve votre équipe bid avant de développer un moteur de notation.
Les exigences et la matrice de conformité
Décomposer un appel d’offres en exigences est l’étape que les équipes bid décrivent comme la plus fastidieuse et la plus dangereuse à rater. Une exigence obligatoire oubliée peut entraîner l’élimination d’une offre. Un logiciel qui extrait des exigences doit répondre à un niveau d’exhaustivité qu’on n’attend jamais d’un simple résumé.
Les exigences sont dispersées entre les documents. Le document principal de l’appel d’offres en énonce certaines, l’annexe technique d’autres, la matrice de conformité fournie par l’acheteur en reprend une partie dans un autre ordre et avec d’autres mots, et le projet de contrat en cache encore quelques-unes. Une équipe nous a raconté que son outil avait extrait la matrice Excel et les annexes, en ignorant complètement le document principal. Une autre avait une très longue liste d’exigences répartie sur plusieurs fichiers. L’extraction s’est arrêtée tôt, a demandé s’il fallait continuer, puis a sauté le reste du document. Les deux échecs ont la même cause : rien ne vérifiait le résultat par rapport aux documents.
Les longs documents doivent être découpés en morceaux que le modèle peut traiter, et les exigences qui chevauchent la frontière entre deux morceaux sont perdues ou trouvées deux fois. Le recouvrement règle le premier problème et aggrave le second : la déduplication devient donc une étape du pipeline. Elle doit porter sur le sens autant que sur le texte, car la même exigence apparaît dans le document principal et dans la matrice avec une formulation différente. L’extraction doit aussi soumettre ce qu’elle a trouvé à une seconde vérification indépendante, avec un seuil de confiance, afin que les exigences inventées ou paraphrasées soient repérées avant qu’un relecteur ne les voie.
La mise en page casse l’extraction de manière difficile à prévoir. Des tableaux lus en travers de la page au lieu de colonne par colonne. Une exigence qui commence en bas d’une page et se poursuit dans un tableau sur la suivante. Une numérotation collée depuis d’anciens appels d’offres, qui passe de 1 à des puces, puis à 1.1, puis encore à des puces, où les sous-exigences sont les premières à disparaître. Des en-têtes, des pieds de page et des filigranes qui deviennent de fausses exigences. Des options de réponse (« Oui / Non / Partiel ») qui se retrouvent dans le texte de l’exigence. Chacun de ces cas est apparu lors d’échanges avec des équipes bid, et aucun n’est géré par une bibliothèque PDF généraliste.
Quand les exigences se trouvent dans un tableur, ne laissez pas le modèle les retaper. Si on lui demande de transformer un classeur d’exigences en liste, un modèle supprime des lignes sans le moindre avertissement, et convertir d’abord la feuille en texte fait aussi perdre des lignes. L’approche fiable consiste à lire chaque ligne du classeur dans le code et à n’utiliser le modèle que pour déterminer le rôle de chaque colonne. Comptez les lignes indépendamment de l’extraction et faites concorder les comptes : les lignes trouvées doivent être égales aux éléments créés, plus les lignes ignorées, plus les erreurs. Si le plan pointe vers une colonne vide, « 0 trouvé, 0 créé » ne doit pas ressembler à une réussite.
Chaque exigence extraite a besoin d’un lien vers son emplacement exact dans la source, surligné, pour qu’un relecteur puisse la vérifier en quelques secondes. Cela se complique dès que le texte a été normalisé, que les accents ont été supprimés ou que les cellules d’un tableau ont été entremêlées, et cela ne fonctionne plus du tout si l’extraction traduit le texte, car un texte traduit ne se retrouve plus dans l’original. Extrayez dans la langue du document et traduisez ensuite.
Les équipes bid ne s’accordent pas sur ce qu’est une exigence, par opposition à une question, un critère d’attribution, un motif d’exclusion ou un risque contractuel. Chaque catégorie a besoin d’une définition écrite qui précise aussi ce qu’elle n’est pas, sinon la même phrase atterrit dans trois listes. Les utilisateurs corrigeront les catégories, et ces corrections sont utiles : les éléments qu’ils valident ou suppriment peuvent servir à affiner chaque définition pour l’entreprise concernée.
La matrice de conformité est elle-même un livrable dont l’acheteur impose souvent le format : l’exigence, la référence, conforme oui, non ou partiellement, un commentaire, un renvoi vers l’endroit où la réponse la traite. « Conforme » doit signifier que la réponse traite réellement l’exigence. Un agent IA déclarera volontiers une offre complète alors que des sections entières manquent, si une exigence mentionnée quelque part compte comme couverte. La couverture doit être suivie exigence par exigence, avec des statuts tels que conforme, partiellement conforme, non traitée et clarification nécessaire auprès de l’acheteur, et « complète » n’est autorisé que lorsque chaque exigence est soit conforme, soit réellement sans objet. Cette vérification coûte cher sur les longs documents, puisque chaque exigence doit être confrontée à l’ensemble de la réponse : elle nécessite donc un traitement par lots et une solution pour les documents trop volumineux pour être vérifiés en une fois. Un faux « complet » est toujours pire qu’un faux « incomplet ».
Enfin, toutes les exigences n’ont pas la même importance pour l’équipe. Lors du renouvellement d’un accord-cadre, l’extraction peut trouver des centaines d’exigences alors que seule une poignée diffère de ce que l’entreprise fait toujours. Donnez à l’équipe un moyen de marquer les exigences standard et de se concentrer sur les autres.
Les questions de clarification à l’acheteur
Chaque appel d’offres prévoit une période pendant laquelle on peut poser des questions à l’acheteur, et les bonnes équipes bid s’en servent. Le rôle du logiciel est d’aider à trouver ce qu’il faut demander, avant la fin de cette période.
Il existe deux types de questions. Certaines viennent d’erreurs dans les documents de l’acheteur : deux documents qui donnent des échéances différentes, un interlocuteur différent dans l’annexe et dans le document principal, un bordereau de prix qui ne correspond pas à la structure des lots. D’autres viennent d’une véritable ambiguïté ou d’un risque : un niveau de service non défini, une clause de responsabilité inapplicable pour ce type de contrat, une exigence qui exclut votre solution sans le dire. Les équipes bid nous ont dit que les clarifications sont aussi stratégiques : une question bien placée peut contester une clause déraisonnable ou orienter la réflexion de l’acheteur, et poser des questions montre à l’acheteur que vous avez tout lu.
Repérer des contradictions dans vingt documents et quelques centaines de pages est une véritable épreuve pour un système d’IA. Il faut la même rigueur d’extraction que pour les exigences, puis une étape de comparaison qui cherche les conflits entre documents plutôt qu’à l’intérieur d’un seul. Avant qu’une question n’entre dans la liste, le logiciel doit vérifier si la réponse ne figure pas déjà ailleurs dans le dossier, car poser une question à laquelle les documents répondent déjà dit à l’acheteur le contraire de ce que vous vouliez montrer. Des équipes nous ont dit que, lorsqu’elles le font à la main, elles passent à côté de vrais problèmes et posent des questions inutiles dans des proportions à peu près égales.
Le résultat prend généralement la forme d’un registre des clarifications, avec chaque question, la référence concernée, la raison, la date d’envoi et la réponse de l’acheteur, plus un document au format exigé par l’acheteur, prêt à être envoyé. Les clarifications se font par vagues. Les réponses de l’acheteur, souvent publiées à l’ensemble des soumissionnaires dans un bulletin de questions-réponses, peuvent modifier le cahier des charges, ajouter des documents ou changer des réponses que vous avez déjà rédigées, et le logiciel doit répercuter ces changements dans le bid.
Addenda, nouvelles versions et bulletins de questions-réponses
Les appels d’offres changent après leur publication. Les acheteurs publient des addenda, des annexes corrigées, des reports d’échéance et des bulletins répondant aux questions de tous les soumissionnaires. Certains republient l’appel d’offres en entier. Chaque changement peut invalider une partie du travail déjà fait, et les équipes bid veulent savoir exactement laquelle.
Cela suppose de comparer les versions d’une manière qui comprend les appels d’offres. Une comparaison de documents générique signale chaque virgule modifiée, ce qui n’est que du bruit. Ce dont l’équipe bid a besoin, c’est d’une liste des obligations modifiées : exigences ajoutées, supprimées ou modifiées, dates déplacées, pondérations changées, questions reformulées. Il lui faut aussi un lien entre chaque changement et les réponses qu’il touche. Les équipes qui répondent régulièrement au même acheteur veulent la même chose d’une année sur l’autre : comparer l’appel d’offres de cette année avec celui de l’an dernier pour voir ce qui a changé et réutiliser ce qui n’a pas bougé.
Deux détails d’ingénierie rendent cela faisable. L’extraction doit être reproductible, de sorte qu’en l’exécutant sur la version 2 elle reconnaisse les exigences déjà trouvées dans la version 1 au lieu de créer des doublons, et les identifiants qu’elle utilise doivent survivre aux évolutions de votre propre logiciel, pas seulement à celles des documents. Changez la façon dont les éléments sont identifiés lors d’une mise à jour du logiciel, et la prochaine exécution duplique tout ce qu’elle avait trouvé auparavant. Par ailleurs, comparer deux longs documents se heurte aux mêmes limites de taille que tout le reste : les grandes comparaisons doivent donc être découpées et leurs résultats partiels conservés, plutôt que d’échouer à la dernière étape. Des équipes bid nous ont parlé de comparaisons qui butaient sur ces limites précisément sur les gros appels d’offres republiés, là où elles comptaient le plus.
Le workflow du bid et les personnes qui y participent
La rédaction n’est qu’une partie de la journée d’un bid manager. Le reste consiste à relancer : qui a la section sur la protection des données, le juridique a-t-il vu la réponse sur la responsabilité, quel CV est le bon, pourquoi l’onglet des prix indique-t-il encore « TBC » deux jours avant l’échéance. Un outil qui rédige et ne fait rien d’autre laisse cette journée inchangée, et les équipes qui ont commencé par la recherche ou la rédaction nous ont dit que le workflow était la pièce encore manquante un an plus tard.
Les fondamentaux sont l’attribution et le statut. Les questions et les sections sont confiées à des personnes nommément désignées, avec des échéances, et chacune voit sa propre liste plutôt que le bid entier. Chaque réponse et chaque section a un état, par exemple rédigée, en relecture, approuvée, et le bid manager voit l’état de tout le bid d’un coup d’œil. Des rappels partent avant que les échéances ne glissent, avec une escalade quand elles glissent. Les commentaires et les mentions atteignent les personnes sur le canal qu’elles utilisent réellement, que ce soit Teams, Slack ou l’e-mail, une seule fois, et pas dix fois pour dix modifications. Les récapitulatifs ne sont pas un luxe ; un expert qui reçoit quarante notifications par jour les désactive toutes.
Les bids sont rédigés par plusieurs personnes en même temps, et désormais aussi par l’IA. La coédition en temps réel, où deux personnes et un agent peuvent travailler dans le même document sans écraser le travail des autres, est un problème résolu au sens où les techniques sont connues, et un problème non résolu au sens où chaque équipe qui la développe passe des mois sur les cas limites : modifications hors ligne, très gros documents, un agent qui écrit mille mots dans une section que quelqu’un est en train de lire, et le moment où deux modifications arrivent pour la même phrase. Les équipes bid finalisent aussi leurs documents dans Word, Excel et PowerPoint, et l’acheteur exige des fichiers Office : l’édition dans le navigateur doit donc préserver les validations, les styles et les formats, ce qui implique généralement de faire tourner un serveur de documents pour l’édition Office dans le navigateur, à côté de votre propre éditeur.
L’historique des versions va de soi. Les relecteurs veulent voir ce qui a changé depuis leur dernier passage, et les bid managers veulent rétablir la version de la veille d’une section quand une modification tardive tourne mal. Le bid lui-même porte des données que l’équipe veut suivre et filtrer, comme l’échéance, le montant, les lots, le statut, le responsable, le secteur et l’issue, et chaque organisation veut des champs différents. Des champs figés renvoient les équipes vers un tableur posé à côté de l’outil. La direction demandera les taux de réussite par nombre de bids et par montant, le temps passé par bid et le contenu qui fait gagner : les données doivent donc être collectées dès le premier jour, car elles ne peuvent pas être reconstituées après coup.
Les utilisateurs les plus sous-estimés sont les occasionnels. Les experts métier de l’ingénierie, du juridique, de la finance ou des RH ouvrent un outil de bid quelques fois par an. Si répondre à leurs trois questions est plus compliqué que de taper dans le chat d’IA généraliste qu’ils utilisent déjà, ils utiliseront ce dernier, et l’équipe bid recopiera leurs réponses à la main. Concevez l’outil pour l’expert qui se connecte deux fois par an, pas seulement pour l’équipe bid qui y passe ses journées.
Lire les questionnaires de l’acheteur
C’est sur les questionnaires que la plupart des logiciels de bid sont jugés, parce que c’est le travail le plus répétitif et le plus facile à mesurer. C’est aussi là que le plus de raccourcis échouent, parce que chaque acheteur construit son formulaire à sa manière et que vos fichiers de test ne sont jamais aussi étranges que ceux qui arrivent un vendredi après-midi. Prévoyez Excel, Word, PDF et PowerPoint, dans toutes les langues dans lesquelles vous répondez.
Classeurs Excel
Un questionnaire qui ressemble à une simple grille pour un humain est, à l’intérieur du fichier, un ensemble de conventions qui varient selon le logiciel qui l’a produit et la version d’Excel qui l’a enregistré en dernier. La norme Office Open XML décrit le format ; les modèles des acheteurs en explorent tous les recoins.
Les listes déroulantes sont la première surprise. Une liste déroulante dont les options se trouvent sur une autre feuille est écrite par Excel 2010 et les versions suivantes dans un bloc d’extension du fichier, distinct du bloc de validation classique que lisent la plupart des bibliothèques. Un lecteur qui ne consulte que le bloc classique ne trouve aucune option sur de nombreux questionnaires réels. Les acheteurs aiment aussi placer les listes d’options sur des feuilles auxiliaires masquées, derrière des plages nommées, et les plages nommées prennent plus de formes qu’on ne l’imagine : simples listes de valeurs, colonnes entières, unions de plusieurs zones, et noms valables sur une seule feuille. Une liste définie comme une colonne entière couvre plus d’un million de cellules. Lisez-la cellule par cellule, et un seul classeur prend plusieurs minutes ou épuise la mémoire du worker : le parcours doit donc s’arrêter à la dernière ligne utilisée.
Trouver où vont les réponses est le deuxième problème. Sur une feuille protégée, c’est assez simple, car les cellules que l’acheteur veut voir remplies sont les cellules déverrouillées. La plupart des questionnaires ne sont pourtant pas protégés, et il faut alors combiner plusieurs indices : une validation sur la cellule, un en-tête qui signifie « réponse », une bordure, une couleur de remplissage, une cellule vide à côté d’une cellule remplie. Aucun n’est fiable à lui seul. Une même feuille peut aussi contenir plusieurs tableaux empilés les uns sur les autres, chacun avec sa propre ligne d’en-tête et sa colonne de réponse, et un lecteur qui ne trouve que le premier en-tête laisse des blocs entiers sans réponse tout en signalant une réussite.
Les en-têtes sont dans la langue de l’acheteur. « Response », « Antwort », « Commentaire du fournisseur », « Odpowiedź », « Svar » : une liste de mots d’en-tête en anglais transforme une grille française ou polonaise en feuille sans aucun formulaire. Certains en-têtes parlent de réponses sans être la colonne de réponse. « Answer guidance » décrit la question ; « Expected answer » peut être la réponse type de l’acheteur. D’autres en-têtes portent des règles qu’aucune liste déroulante n’impose. Une colonne intitulée « Compliance (FC/PC/NC) » ou « Score 1 to 5 » attend un code, et un paragraphe rédigé dans cette colonne peut vous coûter les points de la ligne.
La suite de la liste est longue, et chacun de ces cas s’est présenté dans un véritable appel d’offres :
- Des bandeaux fusionnés sur plusieurs colonnes créent des champs de réponse fantômes, tandis que deux cases fusionnées côte à côte peuvent fondre deux réponses en une seule.
- Les réponses écrites dans des lignes ou colonnes masquées sont invisibles pour l’évaluateur : le logiciel doit donc refuser de les y placer et le signaler.
- Des références de ligne comme « 1.10 » ou « 3.2.1 » ressemblent à des titres de section pour un analyseur naïf, qui traite alors toutes les lignes suivantes comme faisant partie d’un titre.
- Le même texte de question apparaît sur plusieurs onglets avec des réponses attendues différentes : les questions doivent donc être identifiées par leur feuille et leur ligne, jamais par leur formulation.
- Certains classeurs affichent ou masquent des questions en fonction des réponses précédentes, au moyen de formules ou d’une mise en forme conditionnelle, et certains s’allongent une fois les premières réponses saisies.
- Un texte d’espace réservé comme « [Insert details] » occupe la cellule de réponse et doit être reconnu comme vide.
- Les colonnes déjà remplies par l’acheteur, comme la pondération ou les numéros de référence, doivent rester en lecture seule.
- Les fichiers produits par d’autres logiciels qu’Excel écrivent les mêmes structures avec des préfixes XML différents. Un lecteur strict les ouvre et ne trouve aucune feuille.
- Les anciens fichiers .xls, les fichiers .xlsm avec macros et les exports CSV arrivent encore dans les dossiers d’appel d’offres, et les convertir en .xlsx peut faire perdre les listes déroulantes dont vous aviez besoin.
- Les très grandes feuilles, avec des dizaines de milliers de lignes de produits ou de postes de prix, doivent être lues en streaming plutôt que de charger tout le fichier en mémoire.
Les équipes bid décrivent la même chose de leur côté : de vieux classeurs verrouillés de façon curieuse, des valeurs de liste déroulante qui changent d’une ligne à l’autre, des limites de caractères sur des cellules protégées, et la consigne de reprotéger la feuille avant de la renvoyer.
Formulaires Word
Les formulaires Word recueillent les saisies d’au moins quatre manières, et les acheteurs les mélangent dans un même document. Les champs de formulaire hérités, c’est-à-dire les zones de texte, cases à cocher et listes déroulantes des anciennes versions de Word, restent la norme dans les formulaires du secteur public et dans les déclarations sur l’honneur allemandes et autrichiennes. Les formulaires plus récents utilisent des contrôles de contenu, y compris des cases à cocher qui n’ont aucun état enregistré tant que personne ne les a cochées. Beaucoup de formulaires utilisent plutôt des symboles de case saisis comme du texte, parfois issus de polices de symboles comme Wingdings, parfois écrits sous forme de caractères encodés. Et un très grand nombre sont simplement des tableaux avec une colonne vide à remplir.
Chaque type a son piège. Un symbole de case au milieu d’une phrase (« cocher la case le cas échéant ») fait partie du texte, alors qu’une rangée de cases après « oui » et « non » est une question, et l’analyseur doit faire la différence. Écrire une réponse qui commence par un symbole de coche peut créer une nouvelle case à cocher aux yeux de votre propre analyseur et décaler la numérotation de tous les champs suivants, si bien que les réponses suivantes cochent les mauvaises cases. Le suivi des modifications imbrique la mise en forme d’une manière qui casse l’extraction de texte simple. Les zones de texte sont stockées deux fois, une fois pour le Word actuel et une fois comme solution de repli, et écrire dans la copie que Word n’affiche pas laisse la zone apparemment vide. Les colonnes d’espacement étroites dans les tableaux font passer les réponses à la ligne à chaque caractère. Certains formulaires vierges arrivent sous forme de modèles .dotx qui s’ouvrent à chaque fois comme une nouvelle copie sans titre. Certaines déclarations vous demandent de barrer les mentions inutiles, ce qui signifie que votre logiciel doit savoir appliquer le barré, et pas seulement du texte.
Formulaires PDF et scans
Les PDF existent en trois variantes, et il faut une solution pour chacune. Les formulaires remplissables sont le cas favorable, jusqu’à ce que vous rencontriez leurs polices : les polices standard des formulaires PDF couvrent un jeu de caractères limité, si bien qu’un signe inférieur ou égal, un nom polonais ou un guillemet typographique peut faire échouer l’enregistrement ou se transformer en points d’interrogation. Les lecteurs PDF ne dessinent pas non plus les cases à cocher à partir des mêmes valeurs enregistrées : une case qui paraît cochée dans l’un paraît vide dans l’autre.
Les formulaires aplatis sont plus courants que les acheteurs ne le pensent. Quelqu’un a imprimé le formulaire en PDF, et il ne reste plus aucun champ. Le logiciel doit trouver les cases, les lignes et les cellules de tableau sur la page, déterminer à quelle question appartient chacune, et placer chaque réponse par-dessus la page, à la bonne position et à la bonne taille, à l’intérieur de la case. Les scans sont encore plus plats : une page scannée ne contient aucun texte tant que l’OCR ne lui en a pas donné, et la qualité de l’OCR varie d’une page à l’autre. En plus de cela, les PDF des acheteurs sont souvent légèrement malformés, produits par des logiciels anciens ou inhabituels, et l’analyseur doit le tolérer plutôt que de rejeter tout le document.
PowerPoint et autres formats
PowerPoint arrive en entrée plus souvent qu’on ne le pense : présentations de briefing, modèles de présentation que l’acheteur veut vous voir utiliser, tableaux d’exigences collés dans des diapositives. Les diapositives masquées demandent une décision (les lire ou non), et les diapositives doivent être lues une par une pour qu’une citation puisse renvoyer à la diapositive 14 plutôt qu’à « la présentation ». Nous reviendrons plus loin sur PowerPoint comme format de sortie, un sujet bien plus vaste.
Plateformes
Certains questionnaires n’arrivent jamais sous forme de fichier. Les plateformes d’achat comme SAP Ariba, Coupa ou Jaggaer permettent souvent d’exporter les questions vers Excel, de répondre hors ligne puis d’importer, ou de recoller chaque réponse champ par champ. Certaines ne proposent plus d’export. Certaines révèlent de nouvelles questions à mesure que vous répondez aux premières, et dix questions deviennent trente. Certaines vous déconnectent après un court temps d’inactivité, avec vos réponses non enregistrées. Décidez tôt quelles plateformes vous prendrez en charge et comment : export et import, copier-coller assisté ou saisie manuelle. C’est une décision de périmètre au coût bien réel, pas un détail à régler plus tard.
Réécrire les réponses sans casser le fichier
Les acheteurs attendent qu’on leur renvoie leur propre fichier, rempli, exactement tel qu’ils l’ont envoyé. Un nouveau document soigné à votre format n’est pas la même chose, et certains acheteurs le rejettent purement et simplement. C’est là que les outils internes perdent le plus souvent la confiance de l’équipe bid, parce qu’un fichier abîmé est généralement découvert par l’acheteur, pas par vous.
La règle la plus sûre que nous ayons trouvée consiste à ne modifier que les cellules, les champs et les paragraphes qui contiennent des réponses, et à ne toucher à aucun autre octet du fichier. La plupart des bibliothèques de tableur font l’inverse : elles chargent tout le classeur en mémoire et en écrivent un nouveau, et au passage elles réécrivent les définitions de tableaux, suppriment des filtres, réordonnent des parties ou perdent le bloc d’extension où se trouvent les listes déroulantes. Excel ouvre alors le fichier avec un message proposant de le réparer. La réparation fait de vrais dégâts. Excel supprime ce qu’il ne sait pas lire, parfois des blocs entiers de lignes, et le signale dans une boîte de dialogue que l’évaluateur ferme d’un clic. Vérifiez donc le nombre de lignes et la structure avant d’enregistrer, refusez d’enregistrer un fichier qui a perdu quoi que ce soit, et rouvrez le résultat pour confirmer que chaque valeur est arrivée là où elle devait. Une vérification visuelle par un modèle est lente et peu fiable pour cela. Relire le fichier ne coûte presque rien et donne un résultat exact.
Les types de données comptent. Une note écrite en texte casse les formules de l’acheteur, et un code produit écrit comme un nombre perd ses zéros initiaux. Une cellule Excel contient au maximum 32 767 caractères, et en écrire davantage corrompt le fichier. Un seul caractère de contrôle invisible, collé depuis un ancien document, peut rendre un classeur impossible à ouvrir. Les formules qui dépendent de vos réponses continuent d’afficher leurs anciens résultats en cache tant que rien ne les recalcule : les totaux peuvent donc paraître faux quand l’acheteur ouvre le fichier, sauf si vous demandez à Excel de recalculer à l’ouverture. Les feuilles protégées par l’acheteur doivent être reprotégées, avec les mêmes paramètres, avant que le fichier ne reparte.
Les réponses doivent correspondre exactement aux options du formulaire. Quand le modèle écrit « 3,5 sur 5 » et que la liste déroulante propose des nombres entiers, le logiciel ne doit pas choisir « 3 » à sa place. Quand le modèle écrit « No problem, yes we do », il ne doit pas le rapprocher de « No ». Les remplissages en masse ont besoin de leur propre vérification : un remplissage peut copier un même paragraphe de synthèse dans chaque ligne d’une feuille, laisser deux autres onglets vides, et signaler malgré tout une réussite. Comptez les éléments renseignés, ignorés et en échec par onglet, et faites en sorte que les totaux concordent.
Word connaît des variantes des mêmes problèmes. Écrire de la mauvaise manière dans un paragraphe vide produit un fichier que Word déclare illisible. Une cellule de tableau contenant plusieurs paragraphes peut se réduire à une seule ligne après une conversion, et cette structure est perdue pour de bon. Les styles dérivent au bout de quelques pages d’un document généré, et des polices non installées modifient la mise en page et le nombre de pages, ce qui compte quand l’acheteur fixe une limite de pages. Les noms de fichiers demandent aussi de l’attention : des caractères sans problème sur un système d’exploitation font échouer un téléchargement sur un autre, et deux fichiers exportés portant le même nom s’écrasent l’un l’autre dans un zip.
Un consultant bid nous a dit avoir complètement renoncé aux allers-retours avec Word. Il rédige en texte brut et applique un modèle stylé à la fin, parce que la mise en forme se perdait trop souvent. Cela fonctionne pour les documents qui vous appartiennent. Cela ne fonctionne pas pour le formulaire de l’acheteur.
Les documents d’offre dans votre propre modèle
La plupart des bids comprennent des documents que l’acheteur ne fournit pas : l’offre technique, le mémoire méthodologique, l’executive summary, le plan de management. Ils partent dans le modèle Word de votre entreprise, avec vos styles, votre page de couverture, vos en-têtes et votre charte graphique, et les équipes bid sont formelles : tout le reste a l’air inachevé. Plusieurs nous ont dit qu’un fichier Word brut, aussi bon soit le texte, n’était pas acceptable comme version finale. Produire un document à la charte qu’un graphiste validerait est l’un des plus gros chantiers d’ingénierie de toute cette liste, et l’un de ceux que les prototypes ignorent complètement.
Il existe deux façons d’utiliser un modèle, et le logiciel doit savoir laquelle l’utilisateur a en tête. La première traite le modèle comme une référence graphique : reprendre son format de page, ses marges, ses polices, ses styles de titres, ses couleurs, sa couverture et son pied de page, et construire un nouveau document avec le nouveau contenu. La seconde remplit le modèle tel quel : conserver chaque page, remplacer le texte d’espace réservé, ne pas toucher au reste. « Utilisez notre modèle » peut vouloir dire l’un ou l’autre, et le logiciel doit poser la question ou choisir avec discernement, car remplir un modèle tel quel reprend tout ce qu’il contient, y compris un ancien texte, des commentaires et parfois le nom d’un autre client.
Ce dernier point mérite une règle à part entière. Un en-tête indiquant « Proposition pour » suivi du client du bid précédent, répété sur chaque page, est le genre d’erreur qu’un acheteur remarque immédiatement. Le texte des en-têtes, des pieds de page et de la couverture doit provenir du bid en cours ou de l’utilisateur, jamais de ce que le modèle contenait par hasard. Il en va de même pour les images d’exemple des modèles, qui sont souvent des photos tirées de l’étude de cas d’un autre client.
Le format de fichier de Word rend la voie du remplissage périlleuse. Les listes numérotées ont besoin de leurs propres définitions de numérotation, sinon chaque liste du document poursuit la numérotation de la première. Les modifications suivies à l’intérieur d’un paragraphe que vous réécrivez doivent être traitées, pas supprimées. Les sauts de section portent l’orientation des pages et les en-têtes, et en supprimer un par accident modifie la mise en page de tout ce qui suit. Les champs, les notes de bas de page, les commentaires et les caractères de symbole doivent tous survivre à une réécriture. Un modèle contenant un texte qui ressemble à votre propre syntaxe d’espace réservé peut entraîner un outil de remplissage naïf dans une boucle sans fin. Aucun de ces cas n’apparaît sur un document de test simple, et chacun finit par apparaître sur un vrai modèle.
C’est dans les tableaux que les documents générés se trompent le plus visiblement. Un tableau de questions et réponses dans la source doit rester un tableau dans le résultat, avec les mêmes colonnes ; si on lui en laisse le choix, une étape de mise en page par l’IA transforme parfois un tableau en paragraphes empilés, et un relecteur IA l’accepte parfois. Les tableaux font aussi exploser les limites de pages, les limites de taille et les contrôles de mise en page d’une façon que la prose ne fait pas, car un tableau qui paraît petit à l’écran peut contenir beaucoup de texte.
Vérifier le résultat exige un rendu. Un document peut être un XML valide et avoir pourtant un mauvais aspect : un titre isolé en bas de page, un tableau coupé sur deux pages de façon illisible, une image qui déborde de la marge. Vérifier la mise en page signifie examiner des pages rendues, et toute correction automatique doit se limiter aux espacements et à l’enchaînement, jamais au contenu. Indépendamment de toute revue visuelle, le résultat doit être comparé à la source pour confirmer que la formulation, l’ordre, les montants et les notes de bas de page ont survécu, et une tentative de correction qui aggrave les choses ne doit jamais remplacer une meilleure version. Si certains passages ne peuvent pas être placés, ils sont ajoutés à la fin et signalés, car un document qui prétend tout contenir sans que ce soit le cas est pire qu’un document qui dit ce qui manque.
Les limites de pages relient tout cela aux règles du bid. Les acheteurs fixent des limites de pages, parfois par section, et les polices, l’interligne et les marges peuvent aussi être imposés. Les équipes bid nous ont dit que les modèles respectent mal un nombre de pages : elles convertissent donc les limites de pages en nombres de mots et croisent les doigts. Le logiciel peut faire mieux en mesurant le document rendu, ce qui suppose que les polices utilisées par le modèle soient installées partout où le rendu a lieu. Une police de repli différente modifie les retours à la ligne, et les retours à la ligne modifient le nombre de pages.
Executive summary
L’executive summary est la section que lisent les décideurs, souvent avec les prix et les références, et rien d’autre. Les équipes bid nous ont dit vouloir qu’il parte du problème de l’acheteur plutôt que de l’historique du soumissionnaire, qu’il reprenne les thèmes gagnants et les conclusions de la qualification, et qu’il reste cohérent avec le reste de la réponse. Elles nous ont aussi dit ce qui tourne mal. Quand on leur demande un executive summary, les outils d’IA généralistes rédigent une explication de manuel sur le service au lieu de l’offre propre à l’entreprise et, pire, ils produisent des chiffres précis qui sonnent juste. Une équipe nous a décrit un brouillon qui promettait un niveau de service précis sans aucune source derrière, et qui annonçait des objectifs de performance sur lesquels son entreprise refuse délibérément de s’engager dans les appels d’offres. Dans un executive summary, ces erreurs sont lues par ceux qui décident. Tout ce qui a été dit plus haut sur l’ancrage dans les sources s’applique ici avec encore plus de force, tout comme la bibliothèque de blocs de synthèse approuvés de l’équipe bid, que de nombreuses équipes tiennent déjà par type de client.
Revue juridique et signaux d’alerte
Les appels d’offres comprennent un projet de contrat, et quelqu’un doit le lire. Les équipes juridiques veulent comparer les conditions de l’acheteur avec les positions de l’entreprise : plafonds de responsabilité, indemnisations, propriété intellectuelle, résiliation, pénalités de service, protection des données, assurance, conditions de paiement. Elles veulent que les écarts soient signalés et disposer d’une courte liste des points bloquants, suffisamment tôt pour les soulever sous forme de questions de clarification. Les accords-cadres publics peuvent compter de nombreuses annexes, dont certaines font cent pages, et chacune doit être lue.
Deux exigences rendent cet exercice plus difficile qu’un résumé. D’abord, ce qui constitue un signal d’alerte varie d’une entreprise à l’autre et évolue à mesure que l’équipe juridique corrige le logiciel : la définition doit donc apprendre des éléments qu’elle confirme et de ceux qu’elle supprime. Ensuite, les équipes juridiques veulent leurs modifications sous une forme qu’elles reconnaissent. Lors d’un échange, la demande était que chaque modification proposée au contrat apparaisse en suivi des modifications, avec un commentaire qui l’explique. Écrire correctement des modifications suivies dans Word, à travers les tableaux et les liens hypertexte, sans imbriquer des révisions dans des révisions, est un travail de précision.
Il existe un risque juridique plus discret dans les réponses elles-mêmes. Une réponse de sécurité ou de conformité rédigée à partir d’un document de politique peut engager l’entreprise à fonctionner d’une manière qui n’est pas la sienne. Ce risque relève du workflow de relecture, mais le logiciel peut aider en signalant à un relecteur nommément désigné les réponses qui contiennent des engagements, comme des niveaux de service, des délais de réponse, des certifications et des garanties.
CV, études de cas et références
De nombreux appels d’offres demandent les CV de l’équipe proposée, au format de l’acheteur ou au vôtre, avec une limite de pages par CV. Des équipes nous ont dit qu’elles ne peuvent pas refaire un CV pour chaque bid et qu’elles veulent la version à jour, réduite à ce que demande cet acheteur, dans la bonne mise en page. Les études de cas et les références fonctionnent de la même façon : le logiciel doit trouver les projets passés qui correspondent le mieux au secteur, à la taille, à la région et aux exigences de cet acheteur, vérifier que la référence peut toujours être citée, et la présenter sous la forme requise. Les deux dépendent d’une bibliothèque qui contient des fiches structurées et à jour plutôt qu’un dossier de vieux fichiers Word, ce qui nous ramène à la question de la responsabilité du contenu.
Prix et offre financière
L’offre financière se présente généralement sous la forme d’un classeur distinct comportant de nombreux onglets, d’un bordereau de prix ou d’une grille tarifaire, avec des spécifications qui se trouvent dans une autre annexe. La qualité et le prix sont généralement pondérés séparément, et l’équipe commerciale travaille souvent sur les prix en parallèle de l’équipe bid. L’essentiel de ce travail reste entre les mains de l’équipe commerciale et de ses propres outils, et c’est très bien ainsi. Le logiciel de bid doit tout de même gérer trois choses. Il doit remplir le modèle de prix de l’acheteur sans l’abîmer, ce qui revient au problème Excel vu plus haut, avec davantage de formules. Il ne doit jamais réutiliser un prix d’un ancien bid comme s’il était à jour : les prix de la bibliothèque doivent donc être marqués comme indicatifs ou approuvés, et datés. Enfin, les chiffres doivent survivre : un séparateur de milliers européen, un symbole monétaire mal placé ou un nombre négatif écrit entre parenthèses peut multiplier un montant par mille ou en inverser le signe sans que personne ne s’en aperçoive. Chacun de ces cas passe facilement inaperçu lors des tests.
Présentations et decks PowerPoint
Les soumissionnaires retenus sur la shortlist sont souvent invités à présenter, et beaucoup de bids comprennent un deck dès le départ : une présentation de la solution, une présentation au management, une soutenance de l’offre. Les équipes bid veulent que le logiciel transforme la réponse écrite en diapositives dans le modèle PowerPoint de l’entreprise, et d’après notre expérience, c’est la tâche de génération la plus difficile de toute la liste.
La version facile prend le contenu, demande à un modèle un titre et cinq puces par diapositive, et les place dans la disposition titre et contenu du modèle. Elle fonctionne en démo. Les équipes bid qui l’ont essayée ont jugé le résultat inutilisable : des murs de puces sur des diapositives larges, rien à voir avec les decks produits par leurs graphistes, si bien qu’elles sont revenues à la construction manuelle des decks pour préserver leur charte graphique.
Pourquoi c’est difficile
Un modèle PowerPoint, c’est un masque, un ensemble de dispositions et souvent des dizaines de diapositives d’exemple, chacune étant une page de formes positionnées avec leurs propres polices, tailles, couleurs et limites de texte. Le modèle d’IA ne voit rien de tout cela si vous ne le lui décrivez pas, et si vous le décrivez mal, il travaille à l’aveugle. Associez le contenu aux formes selon leur position dans une liste, et le texte d’un bandeau atterrit dans la zone de corps. Ne donnez au modèle aucune idée de la quantité de texte que contient chaque forme, et il écrit des paragraphes dans des zones conçues pour une statistique de trois mots. Laissez-le planifier diapositive par diapositive, et un modèle comptant des dizaines de types de diapositives soigneusement conçus produit des decks qui n’en utilisent qu’une poignée, sans couverture ni diapositive de conclusion. Et si rien ne regarde les diapositives finies, des éléments décoratifs vides et des notes de rédaction internes partent chez l’acheteur.
Les allers-retours via des services de présentation en ligne causent leurs propres dégâts : tailles de police du modèle réinitialisées à une valeur par défaut, si bien que le texte grossit et déborde ; graphiques natifs aplatis en images ; caractères spéciaux échappés deux fois ; cadres de tableau aux dimensions périmées. Si vous prévoyez de générer des decks via Google Slides ou une API similaire, testez d’abord un aller-retour avec votre propre modèle.
Faire tenir le texte
L’ajustement du texte doit se mesurer dans le code, à partir de la géométrie de chaque forme et de la taille de police qui s’y applique réellement, et cette taille de police est étonnamment difficile à trouver. Elle peut être définie au niveau de la portion de texte, du paragraphe, de la forme, d’un style de liste, de la disposition ou du masque, et elle se transmet par héritage le long de cette chaîne. Si vous vous trompez dans l’héritage, tous les budgets de texte du deck sont faussés d’un coup, du même facteur.
Les caractères ne sont pas la seule limite. Dix-sept puces d’une ligne peuvent tenir dans le budget de caractères d’une zone qui n’a de place que pour onze lignes : le nombre de paragraphes et de lignes doit donc aussi être limité. Les zones paramétrées sans retour à la ligne coupent leur texte au lieu de le faire passer à la ligne, et les zones à plusieurs colonnes doivent être vérifiées colonne par colonne. Les bulles, les légendes et les autres formes non rectangulaires contiennent moins de texte que leur cadre ne le laisse supposer. Quand le contenu ne tient toujours pas, la solution de repli est une réduction limitée de la taille de police, recalculée à chaque assemblage de la diapositive, et jamais un débordement sur la diapositive.
Raccourcir un texte pour le faire tenir échoue de manière prévisible : les modèles abrègent. « Coord. transfront. » est plus court et illisible. Il faut demander explicitement à l’étape de raccourcissement de ne pas abréger, et en dessous d’un certain budget, réécrire de zéro fonctionne mieux que couper. Le problème inverse existe aussi. Une diapositive riche avec trop peu de contenu paraît inachevée, et la tentation est de la remplir de prose inventée. Chaque diapositive a besoin d’un taux de remplissage cible, et de la règle selon laquelle le logiciel ne comble jamais les vides avec un contenu absent de la source.
Tableaux, graphiques et images
Les tableaux sur les diapositives forment une catégorie d’échecs à part entière. Les nouvelles lignes clonées depuis le modèle copient la ligne d’exemple, très haute, du modèle, et le tableau sort par le bas de la diapositive. Un tableau du modèle comptant moins de colonnes que le contenu en perd une, et c’est toujours celle qui compte, comme les honoraires. Les colonnes étroites font passer un mot sur plusieurs lignes. Les cellules fusionnées faussent le rapprochement entre le modèle et le contenu. Fusionner deux diapositives peu remplies en une seule peut faire disparaître un tableau entier : les fusions qui impliquent des tableaux doivent donc être refusées, et tout texte de tableau qui n’arrive pas dans le résultat doit bloquer le deck au lieu de produire un simple avertissement.
Les graphiques, les diagrammes SmartArt et les objets incorporés sont invisibles pour l’extraction de texte. S’ils ne sont pas modélisés explicitement, une diapositive reprise d’un ancien deck part avec le graphique de l’ancien deck. Les diapositives de calendrier et de Gantt montrent l’autre face du même problème : quand le modèle renomme les étapes d’un calendrier, les barres restent où elles étaient, parce que leurs positions sont des coordonnées et non du texte. La solution est de ne jamais laisser le modèle faire de calculs de coordonnées. Il modifie le contenu, et le code redessine à partir de ce contenu les barres, les grilles de cartes, les trombinoscopes d’équipe et les tuiles de chiffres.
Les modèles contiennent des images d’espace réservé intégrées aux diapositives, des images « insérer une photo ici » qu’aucun contrôle de texte ne peut voir. Il faut les détecter lors de l’analyse du modèle pour pouvoir les remplacer ou les supprimer. Les images que vous ajoutez doivent garder leurs proportions, voir leur taille limitée et leur source vérifiée au regard des droits de l’utilisateur.
Réutiliser des diapositives d’anciens decks
Les équipes bid disposent de bonnes diapositives accumulées pendant des années et veulent les réutiliser : la réutilisation de diapositives devient donc un sous-système. Les anciens decks doivent être découpés en diapositives et indexés diapositive par diapositive. Une diapositive choisie pour être réutilisée doit être copiée dans le nouveau deck avec sa disposition, son masque, son thème, ses polices et ses médias, remise à l’échelle si l’ancien deck est en 4:3 et le nouveau en 16:9, et ses styles de tableau doivent suivre. Les masques qu’aucune diapositive n’utilise plus doivent être supprimés, sinon les fichiers grossissent à chaque réutilisation.
Une diapositive réutilisée emporte aussi son ancien contenu. Changer le nom du client dans le titre est la partie facile ; une étape de réécriture générale laissera en place la plupart des libellés d’un calendrier issus de l’ancien projet. Bien adapter une diapositive exige une étape dédiée qui lit la diapositive rendue, raisonne sur le sens de chaque élément et intervient sur chacun d’eux. Quand un utilisateur dit « utilise cette diapositive », ce choix doit être respecté par toutes les étapes suivantes, y compris les boucles de déduplication et de correction automatique qui, sinon, la remplaceraient.
Vérifier le deck
Un deck a besoin de deux types de vérification, qui détectent des problèmes différents. La première porte sur le fichier lui-même. Les moteurs de prévisualisation affichent des fichiers que PowerPoint sur poste de travail refuse d’ouvrir. Un deck peut s’afficher parfaitement en prévisualisation et pourtant refuser de s’ouvrir dans PowerPoint à cause d’un caractère invisible copié depuis un deck source, d’un nom de police non échappé, d’une image enregistrée deux fois sous « JPG » et « jpg », d’identifiants de forme en double dans un groupe copié, d’un lien interne cassé ou d’un préfixe d’espace de noms que PowerPoint n’attendait pas. Validez le package avec la même rigueur que PowerPoint.
La seconde vérification est visuelle : produire le rendu des diapositives, les examiner, corriger ce qui peut l’être automatiquement et signaler le reste. Deux règles méritent d’être énoncées. Les diapositives qui n’ont pas changé conservent leur verdict précédent, sinon les inspections successives se contredisent. Et si le service de rendu se bloque, le deck terminé est livré avec une mention indiquant qu’il n’a pas été vérifié visuellement, au lieu d’être jeté.
Les notes internes sont une fuite propre aux decks. Notes de rédaction, « hypothèses ci-dessous », rappels de vérifier un chiffre : dans un document, c’est gênant ; sur une diapositive montrée à un acheteur, c’est pire. Il faut un moyen de marquer les notes internes et de les retirer avant la sortie, un contrôle des formulations autoréférentielles et une dernière relecture de l’ensemble du deck. Les notes du présentateur en sont le pendant utile : le détail qui ne tient pas sur une diapositive va dans les notes, à condition que le modèle ait une disposition de notes, et les modifications ne doivent pas les effacer.
Les utilisateurs veulent approuver un plan avant que les diapositives ne soient construites, et corriger une diapositive sans régénérer le deck. Régénérer tout un deck pour modifier une diapositive prend assez de temps pour que les gens abandonnent ; corriger une diapositive devrait prendre quelques secondes. Cela suppose des identifiants de diapositive stables, et le refus d’appliquer une correction si l’utilisateur a réordonné le deck entre-temps, afin de ne jamais modifier la mauvaise diapositive. Les fichiers sont ici volumineux et lourds à traiter. Les modèles arrivent avec des vidéos incorporées et des centaines de mégaoctets d’images : il faut donc retirer la vidéo et l’audio, réduire la résolution des photos et plafonner la taille totale avant le début du traitement. C’est la mémoire, et non la puissance de calcul, qui limite le nombre de decks qu’un serveur peut construire en même temps.
Enfin, un générateur de decks a besoin de ses propres évaluations : un ensemble fixe de modèles et de contenus, des contrôles automatiques de l’ajustement, du débordement et des textes d’espace réservé restants, et une note visuelle avec un plancher par diapositive, car une note moyenne masque la seule diapositive cassée dont l’acheteur se souviendra. Chaque nouveau modèle que vous rencontrez doit devenir un cas de test, pour que les améliorations apportées à un modèle n’en cassent pas un autre.
Après la remise de l’offre
Le bid n’est pas terminé une fois l’offre remise, et le travail du logiciel non plus. Les acheteurs envoient des questions de clarification sur votre réponse, parfois avec un délai court, et les réponses doivent rester cohérentes avec ce que vous avez remis. La version remise doit donc être figée et facile à retrouver, distincte des brouillons de travail qui ont continué d’évoluer ensuite. Les soumissionnaires retenus sur la shortlist font une présentation, ce qui ramène le deck sur la table. Certaines procédures comportent un tour de best and final offer, qui rouvre les prix et certaines parties de la réponse.
Puis le résultat arrive, souvent des mois plus tard, et c’est là que la bibliothèque est censée s’améliorer. Les équipes bid nous ont dit vouloir que seules les réponses bien notées retournent dans la bibliothèque, avec le retour de l’acheteur rattaché à la réponse précise qu’il concernait. En pratique, ce retour arrive sous forme de courrier ou d’un débriefing téléphonique, il est éparpillé dans les boîtes mail, et les retours d’expérience sont rares. Si le logiciel enregistre l’issue, les notes et le retour par section, et les relie aux réponses et au contenu dont elles proviennent, le bid suivant peut privilégier le contenu qui a gagné. En raison du délai entre la remise de l’offre et l’attribution, il faut aussi pouvoir ajouter les réponses remises à la bibliothèque avant que le résultat ne soit connu, marquées comme non éprouvées, puis les promouvoir ou les retirer une fois le résultat connu.
Les taux de réussite, le temps passé par bid, le contenu réutilisé et les sections qui perdent des points sont les rapports que demande la direction, et ils n’existent que si les données ont été collectées en cours de route.
La base de connaissances
La base de connaissances détermine la qualité de chaque réponse, de chaque rapport de qualification et de chaque diapositive, et c’est la partie qui se dégrade le plus vite. C’est aussi là que les projets internes s’enlisent le plus souvent : on construit un bon moteur de recherche, et le travail qui consiste à le maintenir à jour, à gérer les droits d’accès et à le garder fiable n’est jamais doté en personnel.
Décider ce que l’IA peut lire
La première décision n’est pas technique. Connecter tous les dossiers de l’intranet à l’IA semble généreux, et cela fait entrer des brouillons, des politiques remplacées, les prix d’autres clients et la version 2014 de votre politique de sécurité. Les équipes qui l’ont essayé nous ont dit avoir fini par vouloir plutôt une bibliothèque organisée, avec une règle claire sur ce qui y entre et qui l’approuve, en complément d’un accès en lecture aux dossiers de travail où se trouve la matière à jour. Les deux ont leur place, et le logiciel doit savoir distinguer l’une de l’autre, car une réponse issue d’une entrée approuvée de la bibliothèque et une réponse issue d’un brouillon trouvé dans un dossier de projet ne méritent pas le même niveau de confiance. Comment construire une bibliothèque de réponses auditable traite du volet contenu.
Faire entrer les documents
Chaque convertisseur perd quelque chose. La structure des tableaux, l’ordre de lecture, des lignes d’un tableur, les options d’une liste déroulante, le texte d’un schéma. Mesurez ce que perd le vôtre sur vos propres documents avant de lui faire confiance. Les tableurs sont le cas d’école : convertis en texte, ils peuvent perdre des lignes sans la moindre erreur, et c’est pourquoi il vaut mieux lire les lignes dans le fichier d’origine.
L’OCR et la conversion de documents sont généralement des services externes ou des processus lourds que vous exécutez vous-même, et les deux ont leurs limites. Une réponse « surchargé » est une raison d’attendre et de réessayer, pas un fichier en échec. Les imports interactifs ont besoin de leur propre capacité, pour que l’import par un collègue de dix mille anciens bids archivés ne fasse pas attendre tous les autres pendant des heures pour lire un addendum de deux pages.
Les images contiennent souvent la réponse : schémas d’architecture, certificats, organigrammes, captures d’écran d’un produit. Pour être retrouvables, elles ont besoin de vraies descriptions, générées par un modèle qui regarde l’image, et un nom de fichier n’est pas une description. Le même logo présent sur chaque page de chaque document doit être reconnu une fois, puis ignoré. Et quand la description échoue, le traitement du fichier doit tout de même aller à son terme, avec une mention claire indiquant que ses images n’ont pas été décrites.
Le découpage des documents en morceaux recherchables fonctionne mieux lorsqu’il suit la structure propre du document : un morceau par diapositive, par feuille, par section, avec une étiquette indiquant son origine, pour qu’un résultat de recherche puisse dire « feuille Security, ligne 48 » et qu’une citation puisse ouvrir le bon endroit. Retirez la mise en forme avant l’indexation, mais conservez les positions dans l’original. Retirez aussi les en-têtes, les pieds de page, les filigranes et les tables des matières, sinon ils reviennent comme résultats de recherche et, pire, comme exigences extraites.
La recherche repose sur des embeddings, et les embeddings ont des versions. Quand vous changez de modèle d’embedding, chaque document doit être de nouveau vectorisé, et une bibliothèque aux versions mélangées donne de mauvais résultats tant que ce n’est pas fait. Ignorez les documents dont le contenu n’a pas changé, car les rédacteurs enregistrent souvent et les files d’attente livrent certains messages deux fois : sans ce contrôle, votre facture d’embeddings double sans que personne ne s’en aperçoive. Un fournisseur de secours pour les embeddings doit produire des vecteurs dans le même espace, sinon la recherche renvoie n’importe quoi dès que le secours prend le relais.
Le pipeline doit encore remplir quelques conditions. Chaque fichier atteint un état final, terminé ou en échec avec une raison, et aucun ne tourne indéfiniment ; les fichiers qui tournent sans fin sont la première chose que signalent les utilisateurs et la dernière qu’ils pardonnent. Supprimer un fichier supprime aussi ses morceaux et ses embeddings, car un contenu supprimé qui reste recherchable est à la fois un problème de qualité et un problème de confidentialité. Déplacer ou supprimer un fichier en cours de traitement annule le traitement. Les nouvelles fonctionnalités, comme la recherche dans les images ou les diapositives, ne s’appliquent qu’aux nouveaux imports tant que vous n’avez pas retraité la bibliothèque existante, et ce retraitement est un projet à lui seul. Le premier import de plusieurs années d’anciens bids dure plus longtemps que les jetons de connexion et résiste mal aux coupures réseau : les imports doivent donc reprendre là où ils se sont arrêtés.
Trouver le bon passage
C’est à l’étape de la recherche que se joue la qualité des réponses, et l’essentiel du travail est dans les détails.
Les questions d’appel d’offres sont longues et indirectes. Une question comme « Décrivez votre approche pour garantir la continuité de service en cas d’incident majeur affectant votre centre de données principal, en vous référant aux normes dont vous êtes certifié » donne de meilleurs résultats lorsqu’elle est réécrite en quelques recherches ciblées. Les correspondances faibles ont besoin d’un seuil d’exclusion : un passage vaguement lié incite le modèle à l’étirer pour en tirer une réponse qu’il ne soutient pas. Certains index vectoriels renvoient moins de résultats que demandé sans vous le dire, et des filtres appliqués après la limite peuvent renvoyer une page vide alors que de bonnes correspondances existent plus bas.
Les droits d’accès doivent être appliqués au moment de la recherche. Si l’index ne contient pas les droits d’accès, une question peut faire remonter un passage d’un document que l’utilisateur n’a pas le droit d’ouvrir, et l’IA le citera sans hésiter. Vérifiez les accès au retour des résultats, refusez par défaut quand la vérification échoue, puis rendez cette vérification rapide : vérifier chaque résultat séparément transforme un traitement en masse en des milliers de contrôles de droits. Les mêmes règles doivent s’appliquer partout où un document peut apparaître : listes, recherche, téléchargements, aperçus, réponses de l’IA, descriptions d’images partagées entre fichiers en double, et transcriptions de chat qu’un collègue partage. Les descriptions partagées et les transcriptions partagées sont les fuites classiques.
Fraîcheur
Quand deux documents divergent sur un certificat, un effectif, un montant d’assurance ou un prix, le plus récent doit l’emporter et le plus ancien doit être signalé plutôt qu’utilisé. Une réponse qui cite un fichier vieux de dix ans coûte plus de crédibilité qu’une réponse manquante. Un texte barré dans un document signifie qu’une affirmation a été retirée, et il ne doit pas revenir sous forme d’engagement. Le contenu archivé ne doit pas occuper des résultats de recherche dont le contenu à jour a besoin.
Les dossiers synchronisés posent leurs propres questions. Quand un fichier change dans SharePoint, remplacez-vous votre copie, gardez-vous les deux, ou conservez-vous des versions ? Remplacer fait perdre l’historique. Garder les deux crée des quasi-doublons que l’IA mélange. Conserver des versions exige une règle pour décider laquelle répond aux questions. Quel que soit votre choix, gardez la version précédente quelque part avant qu’une synchronisation ne l’écrase, car tôt ou tard quelqu’un demandera ce que disait la réponse le mois dernier.
Les contenus propres à un client et les contenus confidentiels ont besoin d’une clôture. Les prix, les données d’un client et tout ce qui a été partagé dans le cadre d’un accord de confidentialité ne doivent jamais apparaître dans le bid d’un autre client, aussi pertinents qu’ils paraissent à un moteur de recherche.
Qui la maintient à jour
Ce n’est pas le logiciel qui maintient une bibliothèque à jour. Ce sont les gens. Chaque entrée de la bibliothèque a besoin d’un responsable et d’une date de revue, et quelqu’un doit disposer de temps dans sa semaine pour donner suite aux rappels. Les équipes qui avaient déjà échoué avec l’automatisation nous ont donné la même cause à chaque fois : personne n’était responsable du contenu, les réponses sont devenues obsolètes, et l’outil a été blâmé pour ce qu’il produisait. Prévoyez le travail sur le contenu comme une partie du développement, avec des noms et des heures en face. Le guide de la bibliothèque RFP explique comment la structurer.
Des réponses que vous pouvez assumer
Une réponse de bid est un engagement que votre entreprise signe. Les contrôles qui l’entourent doivent donc se trouver dans le code, et pas seulement dans un prompt, car un prompt qui dit « n’invente rien » n’empêche pas un modèle d’écrire quelque chose de plausible. Les mêmes contrôles s’appliquent à tout ce que l’IA rédige d’autre pour un bid : le rapport de qualification, les exigences extraites, les diapositives.
Ancrage dans les sources et citations
Quand la recherche ne trouve rien de pertinent, la bonne réponse est « nous n’avons pas pu le confirmer à partir de vos documents », avec un niveau de confiance nul, et non un paragraphe fluide tiré des connaissances générales du modèle. Cela paraît évident. En pratique, cela signifie que le logiciel doit savoir que la recherche est revenue vide ou faible, et transmettre cette information au modèle et au relecteur, plutôt que de laisser le modèle décider.
Les modèles citent des choses qui n’existent pas. Ils citent un fichier qu’on ne leur a jamais montré, un numéro de page plausible, ou un document lu lors d’un tour précédent de la conversation et qu’ils n’ont plus. Chaque citation doit être vérifiée par rapport à ce qui a réellement été trouvé pour cette réponse, et les citations inventées doivent être supprimées avant que quiconque ne les voie. Citez les passages sur lesquels repose la réponse plutôt que tout ce qui a été trouvé, et citez au moyen d’un identifiant de fichier stable pour que les liens continuent de fonctionner après le renommage d’un dossier. Un détail facile à manquer : si les conversations stockées sont dépouillées de leurs marqueurs de citation, le modèle voit ses propres réponses précédentes sans citations et cesse peu à peu de citer.
Certaines réponses doivent provenir uniquement d’un ensemble défini de sources, comme le dossier de sécurité approuvé ou les documents de l’appel d’offres en cours. Quand un utilisateur restreint les sources, toute lecture en dehors de celles-ci doit échouer avec un message, et non élargir discrètement la recherche. Les équipes sécurité et conformité veulent souvent que leur formulation approuvée soit insérée mot pour mot, sans que le modèle la reformule, et le logiciel doit pouvoir le faire.
Les réponses « non trouvé » demandent un soin particulier. Un refus standard collé dans un bid fait négligé ; une brève description de ce qui est couvert et de ce qui ne l’est pas, rédigée pour le client, est préférable. Une affirmation négative (« nous ne sous-traitons aucune partie du service ») a besoin de preuves comme n’importe quelle affirmation positive. Et le vocabulaire de la traçabilité doit rester en dehors du texte destiné au client. Des formules comme « sur la base des documents fournis » ou « selon la base de connaissances » finissent dans les offres remises si rien ne les arrête. Les explications ont leur place dans un champ distinct que le relecteur voit et que l’acheteur ne voit pas.
Auditez aussi vos propres paramètres par défaut. Une instruction au niveau de la plateforme, écrite pour rendre service, comme « écris TBD en cas de doute », peut prendre le pas sur les instructions des utilisateurs et glisser des notes de rédaction dans les offres. Ce que les relecteurs doivent voir dans une réponse auditable rédigée avec l’aide de l’IA approfondit le dossier qui se trouve derrière chaque réponse.
Relecture et contrôle
Les relecteurs ont besoin de savoir où regarder en premier. Un score de confiance par réponse, sur une échelle définie et accompagné du raisonnement qui le justifie, remplit ce rôle, à condition que l’échelle ait toujours la même signification. Quand la génération échoue pour une question, laissez une mention visible « à relire » plutôt qu’une cellule vide. Une cellule vide ressemble à une question que personne n’a traitée, et dans une feuille de 400 lignes, elle passe inaperçue.
Relancer l’IA ne doit jamais écraser le travail d’une personne. Un expert corrige une réponse, quelqu’un relance la section une heure plus tard, et la correction a disparu : c’est le moyen le plus rapide de perdre la bonne volonté d’un expert. Le logiciel doit détecter les modifications humaines, ne pas y toucher et indiquer qu’il les a laissées telles quelles.
Les traitements en masse doivent tomber juste. Après un traitement de 500 questions, la somme des réponses rédigées, à relire, ignorées et en échec doit être égale au nombre de questions trouvées. Les omissions silencieuses sont l’échec le plus coûteux dans un grand questionnaire, car personne ne cherche une question qui n’apparaît pas à l’écran. Un agent à qui l’on demande de remplir la section 3 ne doit pas, par excès de zèle, réécrire les sections 1, 2 et 4, et il doit demander avant d’aller au-delà de ce qu’on lui a demandé. Les modifications que l’IA apporte aux documents partagés exigent l’autorisation de l’utilisateur, ainsi qu’une trace indiquant quel texte vient de l’IA et qui l’a approuvé, car les relecteurs, le juridique et parfois les acheteurs le demanderont.
Limites, ton et langues
Les limites de mots et de caractères se comptent sur le texte rendu, comme Word ou la plateforme de l’acheteur les comptent, et non sur le balisage que stocke votre système. Même un petit écart entre votre décompte et celui de Word compte face à une limite stricte, et les acheteurs rejettent bel et bien les réponses qui dépassent la limite ; voir si une offre peut être rejetée pour dépassement d’une limite de mots. Respecter une limite sans abîmer la réponse est une compétence à part. Les assistants généralistes ratent les décomptes exacts, comblent avec des répétitions ou coupent une phrase en deux. Un consultant bid nous a raconté qu’après avoir entraîné un modèle à adopter son style, lui avoir demandé de compter ses propres mots et l’avoir fait écrire long puis couper, les réponses restaient encore loin de la limite. Le décompte doit être fait par le code, et le modèle réécrit jusqu’à ce que le code soit d’accord.
Les règles de ton viennent de plusieurs sources : le style de l’entreprise, une équipe ou un persona, le bid lui-même, les préférences de l’utilisateur. Elles ont besoin d’un ordre de priorité clair, et quand deux règles se contredisent, le logiciel doit poser la question plutôt que choisir l’une d’elles. « Nous » désigne le soumissionnaire, et les modèles confondent le soumissionnaire, l’acheteur, les partenaires et le titulaire sortant, surtout dans du contenu réutilisé, rédigé pour un autre bid. Les noms de fichiers internes, les noms de collègues et les notes de rédaction ont une fâcheuse tendance à atterrir dans les documents destinés au client, et on a vu des personas à qui l’on avait donné des noms de sources internes les répéter.
Certains appels d’offres arrivent en plusieurs langues et doivent recevoir une réponse dans une seule, qui n’est pas toujours la langue de l’appel d’offres. Les équipes avec lesquelles nous échangeons répondent en danois, en norvégien, en finnois, en néerlandais, en polonais et en mandarin, pas seulement en anglais, en français et en allemand. L’extraction, la recherche et la rédaction doivent toutes fonctionner dans chacune de ces langues, la bibliothèque doit être interrogeable d’une langue à l’autre, et un glossaire doit garder les noms de produits et les termes juridiques cohérents d’une langue à l’autre. Les services de traduction automatique ont leurs propres bizarreries avec la mise en forme et les espaces réservés, qu’il faut traiter avant que le texte ne retourne dans un document.
Les agents et les traitements longs
Tout ce qui a été décrit jusqu’ici, de la décomposition d’un appel d’offres à la construction d’un deck, est un traitement long : de nombreux appels au modèle, de nombreux appels d’outils, des minutes de travail, parfois une demi-heure. L’exécuter de manière fiable est un problème différent de la réponse à un message de chat, et la plupart des bugs se logent entre les deux.
Ce qu’un agent a le droit de faire
Un agent IA capable de lire la bibliothèque, d’écrire dans des documents et de modifier un bid est puissant, et il a besoin de limites écrites dans le code : des modifications uniquement avec l’autorisation de l’utilisateur, et des lectures uniquement dans les sources que l’utilisateur a placées dans le périmètre. Sans elles, les agents réécrivent avec zèle les sections voisines, lisent des documents qu’on ne leur a pas indiqués et exécutent des instructions trouvées dans un fichier. Les informations de contexte que vous donnez au modèle, comme le profil de l’entreprise ou le persona, doivent être marquées comme de la configuration, sinon le modèle se met à en accuser réception comme s’il s’agissait d’une demande.
Les outils ont besoin de descriptions étroites et explicites indiquant quand les utiliser et quand ne pas le faire ; sinon, une question qui se trouve commencer par un nombre peut être aiguillée vers un outil de calcul, et son erreur présentée à l’utilisateur comme la réponse. Les échecs d’outils doivent pouvoir être rattrapés par l’agent au lieu de mettre fin au traitement, et l’agent ne doit jamais annoncer la réussite d’une étape qui n’a rien fait, comme un document « rempli » sans aucune modification. Chaque annonce d’achèvement doit s’appuyer sur un décompte : éléments trouvés, créés, ignorés et en échec, dont la somme tombe juste.
Plans, workflows et passages de relais
Les équipes bid veulent des procédures reproductibles : pour chaque nouvel appel d’offres, le résumer, extraire les exigences, lancer la qualification, rédiger les questions de clarification. Écrite seulement sous forme de prompt, une telle procédure n’est pas fiable ; les modèles sautent des étapes et en changent l’ordre, si bien que les étapes doivent être imposées en dehors du modèle. Les workflows doivent aller jusqu’au bout et ne s’arrêter que pour une vraie raison : une décision que seul l’utilisateur peut prendre, un écrasement ou une suppression, ou une étape qui a échoué malgré sa meilleure tentative.
Les agents spécialisés, par exemple un pour les decks et un pour les tableurs, ont besoin de passages de relais nets : le parent transmet une tâche et un périmètre, le spécialiste renvoie un résultat, et aucun ne présume du contexte de l’autre. Les sous-agents ont besoin d’un budget commun d’étapes, de tokens et de données, sinon l’un d’eux peut consommer tout le traitement.
Arrêt, plantage et reprise
L’annulation est pleine de pièges. Quand un utilisateur appuie sur stop, chaque serveur qui porte une partie de ce traitement doit s’arrêter, pas seulement celui qui a reçu le clic, sinon un agent continue de travailler, et de dépenser, longtemps après que l’utilisateur a abandonné. Le travail exécuté en parallèle au sein d’un traitement doit lui aussi écouter le signal d’arrêt, sinon il continue de programmer de nouvelles étapes après l’annulation. Une échéance et une annulation par l’utilisateur sont des événements différents qui exigent des traitements différents : un dépassement de délai doit livrer le travail terminé, pas le jeter. Même les bibliothèques des fournisseurs de modèles ont connu des bugs d’annulation : testez-la.
Les longues conversations dépassent la fenêtre de contexte du modèle, et leurs parties les plus anciennes doivent donc être résumées, ce qu’on appelle la compaction. L’étape de résumé a elle aussi une limite de taille, et quand elle déborde, chaque message suivant de cette conversation échoue de la même manière. Les étapes d’un workflow en cours doivent survivre à la compaction. Les tours doivent être écrits de manière durable, pour qu’un plantage au milieu d’un tour puisse être rattrapé ou rejoué. Un tour qui ne doit pas être rejoué, parce qu’il a déjà envoyé quelque chose ou qu’il attend une décision humaine, doit plutôt être mis en attente.
Les traitements longs ne doivent pas s’exécuter dans la requête web qui les a lancés. Sinon, un déploiement ou un plantage par manque de mémoire sur le serveur web met fin à tous les traitements en cours. Placez-les dans un worker avec une file d’attente, un signal de vie (heartbeat) et un moyen pour l’écran de l’utilisateur de se reconnecter à la progression du traitement après un rechargement de page.
Faire tourner l’IA en production
Les modèles sous votre outil changent plusieurs fois par an, et chaque changement peut modifier du jour au lendemain la longueur des réponses, le ton, les habitudes de citation et les refus. Les équipes bid s’en aperçoivent. Lors d’échanges cette année, on nous a parlé de réponses devenues plus génériques après un changement de modèle, de prompts pour les exigences et la stratégie de bid devenus beaucoup plus variables, et d’utilisateurs qui se demandaient si les réponses étaient meilleures trois semaines plus tôt. Faire tourner l’IA en production est un travail permanent, distinct du développement de fonctionnalités, et il lui faut un responsable.
Fournisseurs, régions et contrats
Les relecteurs des grandes entreprises demandent quel fournisseur de modèles traite les données, dans quelle région, dans le cadre de quel contrat, et si le fournisseur conserve quoi que ce soit ou s’en sert pour l’entraînement. La réponse peut varier selon la business unit ou le client : une division peut exiger que ses données soient traitées uniquement dans l’UE, une autre peut avoir un contrat avec un fournisseur cloud précis. Ajouter un second fournisseur à un système conçu pour un seul prend plus de temps que prévu. Les noms de modèles, les paramètres, les limites, les codes d’erreur et les formats de streaming diffèrent tous, et la configuration a tendance à diverger entre les services qui appellent les modèles. Faites passer chaque appel par un seul endroit du code, pour que le fournisseur, le modèle, la région et les limites soient décidés une seule fois.
Un même fournisseur peut se comporter différemment selon l’interface, par exemple en raisonnant moins ou en cherchant moins quand des outils sont associés, et la documentation ne le dit pas toujours. Seules des mesures sur votre propre jeu d’évaluation vous le diront.
Changements et retraits de modèles
Déployez un nouveau modèle d’abord auprès d’un groupe d’utilisateurs, comparez ses résultats avec ceux du modèle actuel sur votre propre jeu d’évaluation, et gardez un moyen de revenir au modèle que vous connaissez. Suivez la date de retrait de chaque modèle dont vous dépendez. Les modèles retirés cessent de fonctionner à une date choisie par le fournisseur, et leur remplaçant se comporte rarement de manière identique. Les nouveaux modèles arrivent aussi avant que vos bibliothèques ne les connaissent, et des paramètres comme l’effort de raisonnement peuvent être ignorés sans la moindre erreur. Des modèles moins chers conviennent aux tâches légères, comme les titres et les classifications courtes, et y transférer ce travail est l’une des économies les plus simples.
Tokens, contexte et coût
Les estimations approximatives de tokens fondées sur le nombre de caractères sous-estiment fortement les textes chinois, japonais et coréens, et un gros PDF peut faire plusieurs fois la taille de la fenêtre de contexte d’un modèle. Les lectures doivent être paginées, les longues conversations compactées, et les anciens résultats d’outils d’une conversation peuvent être remplacés par de courts résumés dès qu’ils ne servent plus. Le prompt caching change beaucoup l’équation des coûts, et il dépend de l’ordre de ce que vous envoyez : un contenu qui change à chaque appel, placé tôt dans le prompt, invalide le cache pour tout ce qui suit.
Le volume doit être géré explicitement. Un classeur de 500 questions ne peut pas être envoyé d’un coup sans atteindre les limites de débit, et répondre question par question prend des heures. Il faut une concurrence bornée, un délai maximal par élément, une vérification d’annulation entre les éléments, et de nouvelles tentatives pour les lots qui reviennent avec des lignes manquantes ou répétées, car un faible taux d’erreur par lot suffit à faire échouer la plupart des grandes feuilles. Certaines vérifications croissent plus vite que les documents : vérifier chaque exigence par rapport à une réponse entière coûte à peu près le nombre d’exigences multiplié par la longueur de la réponse, ce qui exige un traitement par lots et une limite.
Suivez le coût des modèles par opération, par utilisateur, par bid et par business unit, dès le premier jour. Des clients nous ont demandé ce que coûte l’analyse d’un appel d’offres, s’ils risquaient d’épuiser leurs crédits en plein bid, et comment refacturer le coût aux business units qui l’utilisent. Sans imputation, vous ne pouvez pas répondre, vous ne pouvez pas établir de budget et vous ne pouvez pas repérer le traitement emballé qui dépense le budget d’un mois en un week-end. L’imputation doit être testée comme tout le reste, car un identifiant mélangé ou une seule requête bloquée peut interrompre l’enregistrement des coûts pour tout le monde.
Les nouvelles tentatives demandent de la prudence avec les services payants. Classez une erreur selon son type, pas selon le texte de son message, et jugez un appel relancé sur sa dernière tentative, pas sur la première, sinon un échec définitif survenu après une limite de débit est relancé comme s’il était temporaire. Certains services facturent une étape à laquelle on ne s’attend pas, comme le téléchargement d’un document traduit plutôt que l’envoi de l’original, et les nouvelles tentatives doivent être conçues en conséquence.
Évaluation
Chaque modification de prompt, de modèle ou de recherche doit être testée sur un ensemble fixe de vraies questions dont on connaît les bonnes réponses avant d’atteindre les utilisateurs. Rejouez les échecs de production comme de nouveaux cas de test. Figez les paramètres et les feature flags utilisés par une évaluation ; un paramètre manquant peut activer une fonctionnalité pendant le test et rendre le résultat dénué de sens.
Certains résultats sont difficiles à noter. Pour la couverture des exigences, un score ne signifie rien tant que vous n’avez pas défini précisément ce qu’est une exigence : atomique, explicite, notée comme couverte ou non, avec les exigences impératives et souhaitées de l’acheteur présentées séparément. La liste des exigences doit être figée avec le cas de test, sinon relancer l’extraction change le dénominateur et les anciens scores ne sont plus comparables. Quand un modèle note les réponses, sa notation doit d’abord être confrontée au jugement humain, puis exécutée plusieurs fois pour mesurer sa variabilité. Même alors, la couverture montre seulement qu’une réponse existe ; une réponse vague couvre tout de même une exigence. Les decks et les documents ont en plus besoin d’une notation visuelle. Les évaluations sur de vrais documents coûtent de l’argent et prennent du temps : prévoyez-les dans le budget, sinon les régressions atteignent d’abord les utilisateurs.
Les logs font aussi partie de la couche IA. Les prompts et les réponses contiennent l’appel d’offres et vos propres documents confidentiels : tenez-les à l’écart des logs généraux, des outils de suivi des erreurs et des données de facturation. Les logs sont copiés à plus d’endroits, et conservés plus longtemps, que les données elles-mêmes.
Chaque appel d’offres est un fichier non fiable
Chaque dossier d’appel d’offres vient de l’extérieur de votre organisation, et votre logiciel l’ouvre automatiquement, souvent avant qu’une personne ne l’ait regardé. Le traitement des fichiers devient ainsi une surface d’attaque, et pas seulement un problème d’analyse.
Les fichiers Office sont des archives zip, et un petit fichier importé peut se décompresser en plusieurs gigaoctets. Vérifiez les tailles pendant la décompression, sans vous fier aux tailles que l’archive déclare elle-même, sinon un seul fichier fait tomber un worker et tout ce qui attend derrière lui dans la file. Certains fichiers coûtent cher d’autres manières : un classeur rempli de formules imbriquées, une page PDF dessinée à partir de dizaines de milliers de minuscules traits, une image aux dimensions absurdes. Limitez l’évaluation des formules, le nombre de pages, le temps d’analyse et les calculs géométriques, et exécutez l’analyse dans un environnement où un plantage n’emporte rien d’autre avec lui.
Les analyseurs ont des vulnérabilités. PDF.js, la visionneuse PDF de Firefox et de nombreuses applications web, a connu la CVE-2024-4367, qui permettait à un PDF piégé d’exécuter du code à son ouverture. Les bibliothèques d’images, les analyseurs XML et les convertisseurs Office ont des antécédents similaires. Maintenez-les à jour, configurez-les pour refuser les références externes, et exécutez les convertisseurs sans aucun accès réseau dont ils n’ont pas besoin. Analysez chaque fichier importé à la recherche de logiciels malveillants avant tout traitement, et donnez aux utilisateurs un état clair pour un fichier mis en quarantaine, plutôt qu’un fichier qui n’apparaît tout simplement jamais.
Vient ensuite le prompt injection. Un appel d’offres, ou un document de votre propre bibliothèque, peut contenir un texte écrit pour modifier le comportement du modèle : une instruction cachée en texte blanc, une ligne dans une note de bas de page, une cellule dans une colonne masquée. L’OWASP classe le prompt injection comme le premier risque des applications fondées sur de grands modèles de langage, et un logiciel de bid lit plus de documents de tiers que la plupart. Traitez le contenu des documents comme des données, jamais comme des instructions, limitez strictement les outils du modèle, et empêchez l’IA de modifier des parties d’un fichier Office auxquelles elle n’a pas à toucher, comme les logos, les liens hypertexte, les objets incorporés et le thème. Un texte collé qui ressemble par hasard à l’une de vos propres commandes ne doit pas la déclencher.
Une conséquence passe facilement inaperçue. Si un collègue teste le prompt injection sur votre outil, ou si un document malveillant le fait à sa place, le fournisseur de modèles voit des abus provenant de votre compte. Sans identifiant par utilisateur ou par équipe sur chaque appel, la seule option du fournisseur est de restreindre le compte entier, et toutes les équipes bid perdent leur IA le même après-midi.
L’infrastructure sous-jacente
Un prototype tourne comme une seule application web qui appelle un seul modèle. Une plateforme de bid qui fait tout ce qui précède tourne comme un ensemble de services aux besoins très différents, et les décisions d’infrastructure que vous prenez les premiers mois sont celles qui sont le plus difficiles à changer ensuite. Cette section en décrit les grandes lignes, pour que le business case en tienne compte.
Les composants que vous ferez tourner
Au minimum, prévoyez les éléments suivants :
- une application web et une API pour les écrans sur lesquels travaillent les utilisateurs ;
- des workers qui traitent les documents : décompression, analyse antivirus, conversion, OCR, découpage, description des images, embedding ;
- des workers qui exécutent les longs traitements d’IA : réponse à des centaines de questions, extraction, contrôles de couverture, génération de documents et de decks ;
- un service temps réel pour la coédition et la progression en direct, qui maintient des connexions ouvertes avec chaque utilisateur actif ;
- un serveur de documents pour l’édition des fichiers Office dans le navigateur, si vous la proposez ;
- des files d’attente entre tous ces éléments, avec des dead-letter queues pour les messages qui échouent sans cesse ;
- une base de données relationnelle pour les données de l’application, et un index vectoriel pour la recherche, dans la même base ou séparément ;
- un moteur de recherche pour la recherche par mots-clés, si vous en avez besoin en plus de la recherche vectorielle ;
- un stockage objet pour les fichiers eux-mêmes, avec gestion des versions ;
- des planificateurs pour tout ce qui suit une horloge : synchroniser SharePoint, envoyer des rappels, nettoyer les traitements bloqués, appliquer les règles de conservation ;
- et les services externes : fournisseurs de modèles, OCR, traduction, analyse antivirus, gestion des identités, e-mail.
Chacun a son propre comportement de montée en charge, ses propres modes de défaillance, sa supervision et son coût. Plusieurs tournent en permanence, que quelqu’un réponde à un appel d’offres ou non. Certains sont lourds : un serveur de documents pour l’édition dans le navigateur peut demander plus de mémoire que tout le reste de votre application réuni.
Séparer le travail lourd du travail interactif
La décision précoce la plus utile consiste à tenir le travail lent et lourd à l’écart des processus qui servent les utilisateurs. La conversion de documents, l’OCR et les traitements d’IA peuvent prendre plusieurs minutes et consommer beaucoup de mémoire. S’ils tournent dans le serveur web, un seul gros appel d’offres ralentit les écrans de tout le monde, et un seul plantage fait tomber la session de chaque utilisateur et chaque traitement en cours.
À l’intérieur des workers, séparez encore. L’import en masse de dix mille fichiers archivés par un collègue ne doit pas faire attendre tous les autres pendant des heures le traitement d’un addendum de deux pages : le travail interactif a donc besoin d’une capacité que le travail en masse ne peut pas accaparer. Les types de traitements lourds ont besoin du même cloisonnement entre eux, sinon les tâches longues de plusieurs minutes affament les exports rapides de quelques secondes.
Les appels externes lents méritent leur propre schéma. Une conversion qui prend plusieurs minutes ne doit pas monopoliser un emplacement de worker pendant qu’elle attend. Soumettez-la, déposez un message de vérification ultérieure dans une file différée, et libérez l’emplacement. Sinon, une poignée de gros classeurs occupe tous les emplacements et tout ce qui se trouve derrière attend.
Le traitement des documents est un problème de mémoire
L’analyse des fichiers Office et des PDF consomme bien plus de mémoire que ne le laisse supposer la taille des fichiers. Un classeur compressé de quelques mégaoctets peut se décompresser en centaines de mégaoctets de XML. Un long PDF converti dans un format interne peut avoir besoin, pendant un bref instant, de plusieurs fois la mémoire du worker qui le traite, et le worker est tué en cours de route, à chaque nouvelle tentative. Les bibliothèques qui gardent en vie un objet par page ou par bloc jusqu’à la fin d’une boucle en sont une cause fréquente. Tout comme les convertisseurs bureautiques lancés une fois par requête : sous charge parallèle, ils épuisent la mémoire de la machine.
Prévoyez des limites sur tout : taille des fichiers importés, taille décompressée, nombre de pages, nombre de diapositives, dimensions des images, temps par fichier. Exécutez les convertisseurs comme des processus séparés que vous pouvez tuer, avec leurs propres répertoires temporaires, et tuez tout le groupe de processus quand un utilisateur annule, sinon le convertisseur continue jusqu’à son délai maximal alors que plus personne ne veut du résultat. Les bibliothèques d’images arrivent avec des paramètres par défaut prévus pour un poste de travail, comme de gros caches et de nombreux threads, qu’il faut réduire sur un serveur.
Les services externes de conversion et d’OCR échouent d’une manière qu’on ne devinerait pas. Un service peut déclarer un traitement à la fois terminé et en échec, dans deux champs différents, et un code qui n’en lit qu’un enregistre des documents vides comme traités. Les limites de débit peuvent arriver sous forme d’erreurs HTTP ou d’un résultat d’apparence normale. Lisez chaque champ que renvoie un service, et testez délibérément les chemins d’échec.
La couche de données
Les plateformes de bid mettent beaucoup de choses dans la base de données : les bids, les métadonnées des documents, les éléments extraits, les réponses et leurs versions, les droits d’accès, le journal d’audit, les traitements, et souvent aussi les vecteurs de recherche. Il est tentant de tout garder dans une seule base, et pendant longtemps, cela fonctionne. Puis une base qui sert à la fois l’application et la recherche vectorielle peut se dégrader progressivement plutôt que d’un coup. Le jeu de données actif dépasse la mémoire, les lectures partent sur le disque, le disque épuise sa capacité de rafale, la maintenance en arrière-plan sur la plus grosse table entre en concurrence avec les utilisateurs, et une requête de comptage coûteuse fait tout basculer. Cela se produit sur plusieurs semaines, et si la seule alerte porte sur l’espace disque libre, personne ne le voit venir. Surveillez dès le départ la latence de lecture, la mémoire, la profondeur de la file d’attente disque et les requêtes les plus lentes, et envoyez le journal des requêtes lentes à un endroit où vous pouvez réellement le lire.
Les index vectoriels ont leur propre vie opérationnelle. Construire un index sur une grande table peut bloquer les écritures : il faut donc le construire en mode concurrent, ce qui ne peut pas s’exécuter dans une transaction et peut laisser un index invalide derrière soi en cas d’interruption. Les migrations suivantes l’ignorent alors, parce qu’un index portant ce nom existe. Les recherches filtrées peuvent renvoyer moins de résultats que demandé si l’on n’augmente pas les paramètres de recherche de l’index. Changer la manière dont le texte est découpé et stocké, ce que vous voudrez faire à mesure que vous apprenez, exige un plan par étapes : écrire dans l’ancienne et la nouvelle table en même temps, basculer la lecture un client à la fois, et conserver l’ancienne table jusqu’à être sûr.
Les connexions sont la contrainte suivante. Chaque service, chaque worker et chaque fonction planifiée détient des connexions à la base de données, et la base a une limite. Un pooler de connexions aide, mais apporte des restrictions, comme des paramètres qu’il refuse au moment de la connexion. Des connexions inactives fermées par le pooler peuvent faire planter l’application si le pool ne s’y attend pas. Dans de nombreuses bibliothèques, l’attente par défaut d’une connexion libre est infinie. Une fonction qui prend une seconde connexion alors qu’elle en détient déjà une peut provoquer un interblocage dans un petit pool.
Les fichiers résident dans le stockage objet, et les échanges entre vos services et le stockage ont besoin de délais maximaux. Une lecture du stockage qui ne revient jamais, pendant qu’elle détient un verrou, peut figer tout ce qui attend ce verrou. Certains environnements d’exécution ignorent les paramètres de délai des propres bibliothèques du fournisseur cloud, le genre de chose que l’on découvre en production.
Temps réel et coédition
La coédition et la progression en direct ont besoin d’un service qui maintient une connexion avec chaque utilisateur actif et garde les documents partagés en mémoire. Répartir ce service sur plusieurs serveurs exige un moyen de partager l’état entre eux, et de nombreuses équipes commencent avec un seul serveur en prévoyant d’ajouter les autres plus tard. Dans les deux cas, un plantage ou un déploiement déconnecte tout le monde d’un coup, et si chaque client se reconnecte après exactement le même délai, ils font retomber le serveur dès qu’il revient. La reconnexion a besoin de délais aléatoires réellement étalés, et les clients doivent recharger ce qu’ils ont manqué plutôt que supposer qu’ils ont reçu chaque mise à jour. L’historique d’édition grossit sans limite s’il n’est pas compacté, et le traitement de compaction ne doit pas entrer en concurrence avec les modifications enregistrées au même moment.
Régions et localisation des données
Si certaines business units ou certains clients ont besoin que tout tourne dans l’UE et d’autres aux États-Unis, prévoyez-le dès le premier jour. Tourner entièrement dans une région signifie que les données, les fichiers, l’index de recherche, les sauvegardes et le traitement par l’IA y restent tous, et une infrastructure écrite pour une seule région porte partout des hypothèses à son sujet. La localisation des données chez vos fournisseurs compte autant que la vôtre : le fournisseur de modèles, le service d’OCR, le service de traduction et le fournisseur d’identité traitent chacun du contenu quelque part, dans le cadre de leur propre contrat. Votre équipe InfoSec posera des questions sur chacun d’eux.
Robustesse : ce qui doit rester vrai quand tout lâche
Un logiciel de bid est le plus sollicité dans les quarante-huit dernières heures avant une échéance, c’est-à-dire précisément quand une panne coûte le plus cher. Un prospect nous a demandé cette année ce qui se passe si l’outil est indisponible juste avant une remise d’offre de plusieurs millions. Un autre nous a demandé notre plan de reprise après sinistre et notre délai de rétablissement. Des équipes qui avaient utilisé d’autres outils nous ont décrit des déploiements en heures de bureau qui rendaient l’outil inutilisable, et des traitements qui s’arrêtaient sans message d’erreur, laissant des questions vides. On ne peut pas ajouter la robustesse à la fin. Elle découle d’une poignée de propriétés que chaque partie du système possède dès le départ.
Chaque traitement se termine
Chaque fichier et chaque traitement ont besoin d’un ensemble défini d’états, de la réception jusqu’à l’état terminé ou en échec, en passant par l’analyse et le traitement, et ils doivent toujours atteindre l’un des états finaux. Un fichier qui reste indéfiniment « en cours de traitement » est la première chose que signalent les utilisateurs et la plus difficile à expliquer. Cela suppose des délais maximaux à chaque étape, des processus de nettoyage qui repèrent le travail bloqué au-delà de son délai et le font échouer avec une raison, et un état visible pour chaque échec, comme « mis en quarantaine », « illisible », « trop volumineux », pour que les utilisateurs sachent quoi faire ensuite.
Échecs temporaires et échecs définitifs ne sont pas la même chose
Une micro-coupure réseau et un fichier corrompu sont deux échecs différents, qui exigent des traitements différents. Relancez le premier, avec un délai qui augmente à chaque fois ; faites échouer le second immédiatement. Si vous ne les distinguez pas, deux mauvaises choses se produisent. Soit les échecs temporaires font échouer des fichiers qui auraient fonctionné une minute plus tard, soit les échecs définitifs sont relancés indéfiniment. Un worker qui acquitte chaque message, réussi ou non, n’envoie jamais rien dans sa dead-letter queue, et une coupure réseau fait échouer un fichier aussi définitivement qu’un fichier corrompu. Classez les erreurs selon leur type et leur code, jamais selon la formulation du message, qui change d’une version de bibliothèque à l’autre. Une réinitialisation de connexion qui survient après que l’autre partie a déjà répondu avec succès n’est pas un échec de la requête.
Les dead-letter queues ne servent que si quelqu’un les regarde. Une dead-letter queue qui reste en alerte pendant des mois est une liste de fichiers clients qui n’ont jamais abouti.
Tout s’exécute deux fois
Les files d’attente livrent les messages plus d’une fois, les workers plantent après avoir fait le travail mais avant de l’avoir enregistré, et les utilisateurs cliquent deux fois sur les boutons. Chaque traitement doit pouvoir être répété sans risque : écrire deux fois la même réponse doit laisser une seule réponse, traiter deux fois un fichier doit laisser un seul ensemble d’entrées de recherche, et un appel payant ne doit pas être payé deux fois si vous pouvez l’éviter. Les techniques sont classiques : clés uniques, vérification du statut avant chaque étape, enregistrement de ce qui a été fait dans la même transaction que le travail, réservations qui expirent. Elles doivent pourtant être appliquées partout, y compris aux endroits que personne ne considérait comme un traitement. Une variante subtile : un worker récupère plus de messages qu’il ne peut en traiter à la fois, ceux qui attendent expirent, la file les confie à un autre worker, et ils sont traités deux fois.
Deux exécutions simultanées sur le même élément sont l’autre moitié du problème. Deux réindexations du même fichier, deux renommages du même dossier sur deux serveurs, un traitement de compaction et un enregistrement en direct : chacun a besoin d’un verrou ou d’un contrôle de version, et un verrou détenu dans un processus ne protège en rien d’un second serveur.
Chaque appel a un délai maximal
De nombreuses bibliothèques attendent indéfiniment par défaut : une connexion à la base de données, une lecture du stockage, une réception dans une file d’attente, une API tierce. Un seul appel qui ne revient jamais peut bloquer indéfiniment un verrou, un emplacement de worker ou la session d’un utilisateur. Mettez un délai maximal sur chaque appel externe, y compris la résolution DNS qui le précède, et assurez-vous que ce délai fonctionne réellement dans votre environnement d’exécution. Décidez ensuite de ce qui se passe quand il expire, et testez-le.
Des contrôles de santé qui disent la vérité
Un contrôle de santé qui répond toujours « OK » masque un processus vivant mais bloqué. Un contrôle trop strict tue des processus occupés mais en bon état. Les longs tours d’IA peuvent bloquer un processus serveur par brèves rafales, et un contrôle par défaut de l’équilibreur de charge tue alors des agents qui fonctionnent normalement, tandis qu’un processus dont la configuration ne s’est jamais chargée peut continuer à se déclarer en bonne santé alors que chaque requête échoue. Définissez ce que « en bonne santé » signifie pour chaque service, et faites en sorte qu’un processus qui rencontre une erreur inattendue s’arrête et redémarre plutôt que de continuer en boitant, car un processus corrompu qui répond encore aux contrôles de santé est le pire état possible.
Déploiements, migrations et retours arrière
Vous déploierez souvent, et les équipes bid seront en train de travailler quand vous le ferez. Les déploiements doivent passer progressivement d’un serveur à l’autre, les workers doivent terminer ou rendre leur travail en cours dans la fenêtre d’arrêt de la plateforme, et les longs traitements d’IA doivent survivre à un déploiement ou reprendre après. Les migrations de base de données doivent fonctionner pendant que l’ancien code tourne encore, ce qui veut dire ajouter avant de supprimer et modifier les données par petits lots pour que les tables ne soient pas verrouillées pendant plusieurs minutes. Les migrations sur de grandes tables en production ont besoin d’une limite sur la durée d’attente des verrous, sinon une seule migration bloque toute la mise en production sans la moindre ligne de log. Promouvez une version par étapes, d’abord les migrations, puis les services qui détiennent les données, puis les workers, et arrêtez-vous si une étape ne se stabilise pas. Sachez comment revenir en arrière, base de données comprise, avant d’en avoir besoin.
Les feature flags aident ici : livrez le nouveau code désactivé, activez-le pour une équipe, puis pour tout le monde, puis supprimez le flag. Désactiver un flag ne doit jamais laisser en plan un travail commencé pendant qu’il était actif. Des interrupteurs d’arrêt d’urgence (kill switches) pour les fonctionnalités coûteuses, vérifiés avant l’appel payant et non après, vous permettent d’arrêter un coût qui s’emballe sans déploiement.
Sauvegardes et restauration
Sauvegardez la base de données et les fichiers, conservez les versions antérieures des fichiers et protégez le stockage contre les suppressions accidentelles. Ensuite, restaurez régulièrement à partir des sauvegardes, dans un environnement séparé, et chronométrez l’opération, car une sauvegarde que vous n’avez jamais restaurée est un espoir plutôt qu’un plan. Écrivez noir sur blanc la quantité de données que vous pouvez vous permettre de perdre et la durée d’indisponibilité que vous pouvez vous permettre, et vérifiez que le dispositif tient ces objectifs. N’oubliez pas les services dont l’état est facile à négliger : l’index de recherche, le stockage du serveur de documents, les files d’attente, les secrets. Les clients demanderont ces chiffres dans leur questionnaire de sécurité, et certains les inscriront dans le contrat.
Montée en charge : les formes de la charge
Un logiciel de bid ne connaît pas un trafic régulier et prévisible. Sa charge prend des formes, et chaque forme casse quelque chose de différent.
La première est le pic d’échéance. Plusieurs équipes remettent leur offre la même semaine, souvent le même jour, et l’utilisation la veille d’une échéance peut représenter plusieurs fois celle d’une matinée normale. Une capacité dimensionnée sur la moyenne lâche précisément quand cela compte. Un nombre fixe de serveurs, que quelqu’un modifie à la main après un plantage, c’est ainsi que démarrent beaucoup d’outils internes, et ainsi qu’ils restent jusqu’à la première mauvaise semaine.
La deuxième est le très gros traitement unique. Un appel d’offres de 600 pages, un classeur de mille lignes, un modèle de cent diapositives avec des vidéos incorporées, une comparaison de deux longues versions du même appel d’offres. Des équipes bid nous ont raconté avoir découpé en morceaux une réponse de bien plus de cent pages parce que l’outil était trop lent, avoir laissé tourner un long traitement pendant une heure, et une comparaison qui avait atteint ses limites précisément sur le gros appel d’offres republié où elle comptait. Chacun de ces cas exige du streaming plutôt que tout charger en mémoire, un travail découpé en morceaux avec une progression sauvegardée après chacun, et des limites qui échouent tôt avec un message clair plutôt que tard avec un plantage.
La troisième est l’import en masse. La première synchronisation d’un grand site SharePoint, ou la migration de plusieurs années d’anciens bids, ce sont des milliers de fichiers qui arrivent d’un coup. Cet import ne doit retarder le travail en cours de personne, il doit reprendre après une interruption, et son coût doit être prévisible, car chaque fichier passe par la conversion, la description des images et l’embedding.
La quatrième est le voisin bruyant. Que vos locataires soient des clients ou des business units, l’un d’eux lancera un jour quelque chose de lourd, et les autres ne doivent pas s’en apercevoir. Chaque ressource partagée a besoin d’une limite par locataire : files de traitement, emplacements de traitement, débit de recherche, limites de débit de l’API, dépenses en modèles. Un limiteur de débit qui écrit dans la base de données pour chaque requête refusée devient lui-même un problème de charge : les requêtes refusées doivent donc être rejetées en mémoire.
La cinquième est la croissance dans le temps. Les bibliothèques grossissent, les conversations grossissent, les historiques de versions grossissent, les journaux d’audit grossissent, l’index vectoriel grossit, et des requêtes qui étaient rapides avec les données de dix clients font des parcours de table complets avec cinquante. Les index manquants se révèlent sous charge, typiquement sur les historiques de versions, l’historique des chats et les listes de dossiers, et des listes qui se chargent élément par élément transforment l’affichage d’une page en centaines de requêtes. Mesurez les plans d’exécution des écrans les plus sollicités à mesure que les données augmentent, pas une seule fois au lancement.
Les limites de débit des modèles s’ajoutent à ces cinq formes. Votre fournisseur vous accorde un nombre de tokens et de requêtes par minute, partagé par chaque utilisateur et chaque traitement. Un traitement en masse lancé par une équipe peut épuiser la limite pour tout le monde : le travail d’IA a donc besoin d’une file d’attente, de priorités et de quotas par locataire, et les questions interactives ne doivent pas attendre derrière un lot de mille lignes.
Exploitation : surveiller et faire tourner
Une fois l’outil en production, quelqu’un doit savoir qu’il est en panne avant l’équipe bid, et le réparer à onze heures du soir avant une échéance.
Supervision et alertes
Surveillez ce que vivent les utilisateurs, pas seulement ce que remontent les serveurs. Taux d’erreur et temps de réponse par service, profondeur des files d’attente et âge du plus ancien message, temps de traitement par fichier, taux de réussite des traitements, erreurs et latence des modèles, coût par heure, et état de santé de chaque intégration. Déclenchez les alertes sur le plus ancien message d’une file, pas seulement sur le nombre de messages, car une file qui n’avance pas est pire qu’une file longue.
Deux leçons valent d’être apprises tôt. Des seuils d’alerte calqués sur des moyennes se déclenchent sans arrêt et finissent ignorés ; fixez-les à partir d’incidents réels et de percentiles. Et certaines alertes se rétablissent d’elles-mêmes alors qu’un client est encore complètement bloqué, parce que les utilisateurs de ce client abandonnent et cessent d’envoyer des requêtes. Vous devez pouvoir voir les problèmes par client ou par business unit sans mettre de données clients dans vos métriques, ce qui implique généralement des logs filtrables par locataire et des métriques qui ne le sont pas.
Les graphiques de mémoire sont trompeurs parce qu’ils reposent sur des échantillons, et le moment où un processus est tué faute de mémoire tombe entre deux échantillons. C’est la trace que garde la plateforme de la raison de l’arrêt d’un processus qui fait foi. Enregistrez la taille des entrées des traitements lourds pour pouvoir dire, quand l’un d’eux manque de mémoire, quel document en est la cause.
Le traçage entre services, du clic de l’utilisateur à l’appel au modèle en passant par l’API, la file d’attente et le worker, transforme un vague « c’était lent » en réponse précise. Mettez-le en place tôt ; il est bien plus difficile à ajouter une fois qu’il y a dix services.
Support et outils d’administration
Sans de vrais outils d’administration, le support travaille avec des scripts de base de données écrits à la main : relancer un fichier bloqué, réimporter un dossier, supprimer les données d’un utilisateur, comprendre pourquoi un bid paraît incorrect, souvent avec des identifiants copiés depuis un endroit où ils ne devraient pas se trouver. C’est lent et risqué. Prévoyez des écrans d’administration pour les opérations que le support effectue chaque semaine, avec leur propre journal d’audit, et un accès juste-à-temps aux données de production, approuvé et limité dans le temps, pour tout le reste.
Opérations de sécurité
La sécurité est un coût récurrent, pas une tâche de lancement. Les dépendances doivent être corrigées en continu, et les analyseurs de documents et les bibliothèques d’IA publient souvent des vulnérabilités. Une analyse automatisée des dépendances et des images de conteneurs, avec une personne chargée de donner suite aux résultats, est le minimum. Les fichiers de verrouillage des dépendances doivent être respectés à chaque build, car un outil de build qui installe discrètement d’autres versions peut faire tomber un service en production. Les secrets ont leur place dans un gestionnaire de secrets, injectés au démarrage, avec une rotation qui fonctionne sans interruption de service. Les identifiants donnant accès au SharePoint, à Teams et à la messagerie des clients doivent être chiffrés de manière liée à l’enregistrement auquel ils appartiennent, pour qu’une valeur copiée ne puisse pas être utilisée ailleurs, avec une procédure pour les rechiffrer quand une clé change. Les requêtes sortantes, comme les webhooks, la récupération d’images pour les documents et le suivi des redirections depuis les espaces de stockage de documents, doivent être contrôlées à chaque saut pour bloquer les requêtes vers des adresses internes. L’accès humain à la production doit rester l’exception, approuvé et journalisé. Et prévoyez les tests d’intrusion et les audits indépendants que vos clients, ou votre propre équipe InfoSec, demanderont à voir.
Environnements et mises en production
Il vous faut au moins un environnement hors production, avec des volumes de données réalistes, où les versions sont testées avant que les clients ne les voient. L’infrastructure a sa place dans le code, appliquée via un pipeline relu, avec une vérification régulière que ce qui tourne correspond à ce que dit le code ; les modifications faites à la main dans une console pendant un incident ont une fâcheuse tendance à être annulées par le déploiement suivant, sans rapport avec elles. Les tests doivent tourner contre une vraie base de données plutôt que contre des mocks, car beaucoup des bugs décrits plus haut, comme les accès concurrents aux verrous, les index manquants et l’épuisement du pool de connexions, n’apparaissent jamais face à un mock. Les évaluations des résultats de l’IA ont aussi leur place dans le processus de mise en production, sinon les régressions de qualité partent en production comme n’importe quel autre bug.
La plateforme d’entreprise
Un outil interne qui traite des documents d’appel d’offres reste une application d’entreprise. Vos équipes InfoSec, juridique et gouvernance de l’IA l’examineront comme elles examinent n’importe quel fournisseur, et le travail de plateforme est souvent plus important que le travail sur l’IA.
Isolation, identité et droits d’accès
Que vous serviez une seule entreprise avec plusieurs business units ou de nombreuses entreprises, chaque requête, entrée de cache, clé de fichier, index de recherche, ligne de log, traitement en arrière-plan et canal temps réel doit être limité au bon périmètre. Un seul filtre manquant montre les prix d’une division à une autre. Les workers en arrière-plan méritent une méfiance particulière : ils agissent sur les identifiants qu’ils reçoivent dans un message, et doivent donc vérifier eux-mêmes l’appartenance au lieu de supposer que l’API l’a déjà fait. Les clés de stockage ne doivent pas pouvoir être devinées ni falsifiées depuis l’extérieur. Le lien entre un espace de travail externe, comme un tenant Slack ou Teams, et une organisation doit être un à un, et imposé par la base de données, car un code applicatif qui vérifie d’abord et écrit ensuite peut se faire doubler par une requête concurrente.
La DSI d’une grande entreprise n’approuvera pas un outil doté de ses propres mots de passe : l’authentification unique via le fournisseur d’identité de l’entreprise est donc le point de départ, avec l’authentification multifacteur là où la politique l’exige. Les arrivées et les départs doivent être gérés automatiquement. Une désactivation manuelle des comptes laisse d’anciens salariés avec un accès à des bids en cours, et la suppression d’un utilisateur doit atteindre chaque intégration qu’il a connectée, pas seulement la connexion. Les journées de bid sont longues, et un jeton de session qui expire au milieu d’une modification ne doit pas faire perdre cette modification.
Un champ « rôle » sur l’utilisateur n’est pas un modèle de droits d’accès. Dès que les bids impliquent des partenaires, des relecteurs externes, le juridique et des prix à accès restreint, il vous faut des droits par projet, par dossier et par source de connaissances, avec des groupes et de l’héritage, et des règles qui tiennent sous la pression : un responsable manquant ne signifie jamais « tout le monde », un identifiant d’utilisateur n’est jamais réattribué à une autre personne, et la modification d’un droit pendant que quelqu’un travaille prend effet sans accès concurrent. Les droits s’appliquent aussi à ce que produit l’IA. Une réponse rédigée à partir d’un document à accès restreint hérite de la restriction, tout comme une transcription de chat qui l’a cité.
D’autres systèmes voudront aussi y accéder. Les intégrations ont besoin de clés d’API qui expirent, portent des périmètres et ont leurs propres limites de débit, et les outils qui se connectent via le Model Context Protocol ont besoin d’un vrai OAuth plutôt que d’un secret partagé.
Sécurité, confidentialité et conformité
Les relecteurs demanderont où les données sont stockées et où les appels aux modèles sont traités, et si tout, IA comprise, reste dans l’UE, au Royaume-Uni ou aux États-Unis. Ils demanderont une confirmation écrite qu’aucun fournisseur de modèles ne s’entraîne sur votre contenu ; c’est l’une des premières questions de toute revue. Les identifiants pour SharePoint, Teams, Google Drive et la messagerie doivent être chiffrés, avec un moyen de faire tourner les clés. Les webhooks et tous les autres appels sortants ont besoin d’une protection contre la falsification de requêtes côté serveur (SSRF), y compris contre les adresses qui pointent vers un endroit au moment de la vérification et vers un autre au moment de l’appel. Le contenu des clients, les noms de fichiers et les secrets restent en dehors des logs, car les logs sont copiés à plus d’endroits et conservés plus longtemps que les données elles-mêmes.
Tenez un journal d’audit en ajout seul de qui a fait quoi, qui survive aux renommages et aux suppressions. Les acheteurs, les auditeurs et votre propre service juridique demanderont qui a rédigé et qui a approuvé une réponse, parfois des années plus tard. La suppression demande plus de conception qu’on ne lui en accorde : une suppression récupérable pour les utilisateurs, une signification définie pour « archiver », et la capacité d’effacer une personne ou une business unit entière de chaque espace de stockage, index de recherche et embeddings compris. Le droit à l’effacement prévu par le RGPD s’applique à votre outil comme à n’importe quel autre. Les personnes qui partent doivent être anonymisées sans détruire le contenu qu’elles ont rédigé, et un traitement de purge ne doit jamais pouvoir déborder sur les données d’une autre organisation. Les règles de conservation doivent être automatisées, et chaque nouvelle table ou nouvel espace de stockage ajouté plus tard doit être intégré à la purge, d’où l’intérêt d’un contrôle qui échoue lorsqu’il en manque un.
Attendez-vous à remplir le questionnaire de sécurité fournisseur de votre propre entreprise pour l’outil, et prévoyez les mesures qui sous-tendent ISO 27001 ou SOC 2 si d’autres business units, filiales ou partenaires doivent l’utiliser. Utiliser l’IA pour répondre aux questionnaires de sécurité montre ce que demandent ces questionnaires. Demandez aussi au juridique un avis écrit sur le règlement européen sur l’IA et sur les règles de votre secteur ; le règlement européen sur l’IA s’applique-t-il à la rédaction d’offres est un bon point de départ.
Intégrations
Le contenu des bids se trouve dans SharePoint, OneDrive, Google Drive, Teams et Slack, et l’équipe attend de l’outil qu’il le lise là où il se trouve. Synchroniser correctement un espace de stockage de documents suppose de gérer des suppressions qui n’arrivent qu’avec un identifiant, des renommages et des déplacements appliqués dans le bon ordre, la pagination et le throttling sur les grands sites, les dossiers auxquels l’intégration perd l’accès, et des resynchronisations qui ne doivent pas écraser un fichier que quelqu’un a importé à la main. Teams et Slack ont chacun besoin de leur propre application, avec un manifeste, une revue par la plateforme, des jetons par espace de travail et des états clairs pour les connexions suspendues, cassées ou désinstallées. Les notifications par e-mail ont besoin de préférences par utilisateur et de récapitulatifs. Les données sur les comptes et les opportunités se trouvent dans le CRM ; décidez si vous en avez besoin au lancement ou plus tard. D’autres équipes voudront lancer un bid ou lire des résultats depuis leurs propres systèmes, via une API dotée de webhooks qui réessaient quand le destinataire est indisponible.
L’équipe et le budget
L’équipe nécessaire est plus large que l’équipe IA dont disposent déjà la plupart des organisations. Comptez les rôles, chacun avec du temps réservé pendant des années et non des mois :
- un product owner issu de l’équipe bid, capable de nommer les étapes les plus longues et de dire non aux fonctionnalités qui ne brillent qu’en démo ;
- des ingénieurs backend pour la plateforme, les intégrations et le pipeline de traitements ;
- au moins un ingénieur spécialisé dans les formats de documents, car la gestion d’Excel, Word, PDF et PowerPoint est une discipline à part entière et les bugs ne cessent jamais d’arriver ;
- un ingénieur pour la recherche, les modèles et l’évaluation ;
- des ingénieurs frontend pour le workflow, les éditeurs et les écrans de relecture ;
- l’infrastructure, la sécurité et l’astreinte, car l’outil tourne aussi la nuit avant les échéances ;
- des responsables de contenu pour chaque domaine de la bibliothèque.
Quand des équipes bid nous décrivent leurs propres estimations de développement, leurs collègues les jugent souvent optimistes, et ce n’est pas la première version qui absorbe l’essentiel du budget. Le coût le plus important, c’est le travail qui continue une fois l’outil en production. Des modèles sortent et sont retirés. Les acheteurs envoient des formats de fichiers que personne n’a jamais vus. Les analyseurs et les bibliothèques ont besoin de correctifs de sécurité. Les fournisseurs changent leurs API et leurs prix. Les sites SharePoint sont réorganisés. La bibliothèque doit être entretenue, les évaluations exécutées, l’infrastructure surveillée, et votre équipe InfoSec réexamine l’outil chaque année. Ce travail est indirect et facile à oublier dans un business case, et c’est précisément pour cela qu’il doit y figurer.
Pour chiffrer tout cela, le calculateur build vs buy compare, sur trois ans et avec vos propres chiffres, le développement de votre propre plateforme, la configuration d’outils d’IA généralistes sur votre espace documentaire et l’achat d’un produit spécialisé.
Quand développer a du sens
Développer peut être la bonne décision. C’est généralement le cas lorsque le périmètre est étroit et le reste : un seul type de document, une seule langue, un seul format de fichier que vous maîtrisez, comme une recherche interne sur une bibliothèque approuvée pour une seule équipe. Cela peut l’être lorsque vos bids dépendent d’un système ou d’un processus qu’aucun produit ne prend en charge et que cette différence mérite d’être maîtrisée en interne. Il faut pour cela une équipe engagée : des ingénieurs avec un mandat qui se compte en années, un product owner issu de l’équipe bid et des responsables de contenu qui ont le temps d’entretenir la bibliothèque. Et de nombreuses organisations choisissent une voie intermédiaire. Elles achètent la plateforme et ne développent, via son API, que ce qui leur est propre, comme un lien vers un moteur de tarification interne ou un entrepôt de données.
C’est en général la mauvaise décision lorsque la raison principale est que des licences d’IA généraliste sont déjà payées. Les licences sont la partie bon marché. Quelle place pour un outil spécialisé dans votre stratégie d’IA d’entreprise explique comment les deux s’articulent.
Quel que soit votre penchant, testez la décision de la même manière. Faites tourner votre façon de travailler actuelle, votre prototype et chaque produit de votre shortlist sur le même bid clôturé, avec ses vrais fichiers, et comparez les résultats et les heures passées. Comment choisir un RFP response software sur un bid clôturé explique comment mener cet essai, et le modèle de RFP pour choisir un logiciel RFP vous donne les exigences à envoyer aux éditeurs.
Comment SEQUESTO s’en charge pour vous
Nous avons créé SEQUESTO aOS™ parce que nous nous sommes heurtés nous-mêmes à chaque point de cette liste, et nous continuons d’en rencontrer de nouveaux à mesure que les acheteurs envoient de nouveaux fichiers et que les modèles changent. SEQUESTO aOS est l’agentic operating system des équipes bid et appels d’offres. Il couvre le bid du dossier d’appel d’offres jusqu’aux fichiers remis : qualification, extraction des exigences et des informations clés, remplissage sur place des fichiers Excel, Word, PDF et PowerPoint de l’acheteur, documents d’offre et decks dans votre modèle, relecture et approbation. Il rédige à partir des documents de votre entreprise, là où ils se trouvent déjà, dans SharePoint, Teams, Google Drive ou Slack, cite ses sources et laisse le dernier mot à votre équipe. SEQUESTO fonctionne entièrement dans l’UE ou entièrement aux États-Unis : chaque client choisit sa région à la création du compte, et ses données comme l’IA restent dans cette région. Aucun fournisseur de modèles d’IA ne s’entraîne sur les données des clients, et SEQUESTO est certifié ISO 27001 et SOC 2 Type II. James, l’agent IA de bid de SEQUESTO, fait le travail ; votre bid manager relit et valide. Découvrez SEQUESTO aOS, ou venez avec l’un de vos propres appels d’offres à une démo en direct.
La checklist
La checklist pour développer votre propre logiciel de réponse aux RFP est un classeur Excel gratuit qui reprend chaque point de ce guide sur une ligne, regroupé par section, avec une priorité, un statut et un responsable à renseigner, et une synthèse qui compte ce qui reste ouvert. Chaque point s’applique tout autant à un produit que vous évaluez : vous pouvez donc envoyer la même liste aux éditeurs. La version courte, à vérifier avant de vous engager :
- Vous avez listé chaque type de document de bid et chaque format de fichier auxquels vous avez répondu l’an dernier, et chacun est dans le périmètre ou explicitement exclu.
- Vous savez pour quelles étapes du bid vous développez, de la qualification aux fichiers remis, et qui fait le reste à la main.
- Vous avez rassemblé de vrais fichiers d’acheteurs pour les tests : classeurs protégés avec des listes déroulantes sur des feuilles masquées, formulaires Word avec des champs hérités, PDF aplatis et scannés, un long appel d’offres avec une matrice de conformité, vos propres modèles Word et PowerPoint.
- Votre outil renvoie le fichier de l’acheteur, rempli, et Excel ne propose jamais de le réparer.
- Chaque exigence extraite renvoie à sa source, et les comptes concordent.
- Chaque réponse cite des sources qui existent, le signale quand elle ne trouve pas de réponse et n’écrase jamais la modification d’une personne.
- Chaque entrée de la bibliothèque a un responsable et une date de revue, et quelqu’un a le temps d’y donner suite.
- Les droits d’accès s’appliquent au moment de la recherche et à tout ce que produit l’IA.
- Les traitements longs tournent en dehors des serveurs web, survivent à un déploiement, s’arrêtent quand l’utilisateur les arrête et se terminent toujours.
- Vous savez comment le système se comporte la veille d’une échéance, avec trois équipes qui remettent leur offre en même temps.
- L’équipe InfoSec a approuvé par écrit les flux de données, les fournisseurs de modèles et les régions d’hébergement.
- Une équipe nommément désignée et un budget annuel sont prévus pour faire tourner l’outil après le lancement.
- Vous avez comparé le développement, sur le même bid clôturé, avec votre façon de travailler actuelle et au moins un produit.
Questions fréquentes
Sources
- Excel specifications and limits, Microsoft
- CVE-2024-4367 detail, NIST National Vulnerability Database
- LLM01:2025 Prompt Injection, OWASP Gen AI Security Project
- Regulation (EU) 2016/679 (General Data Protection Regulation), EUR-Lex
- ECMA-376 Office Open XML file formats, Ecma International
