Développement web

Comment gérer les règles métier partagées entre plusieurs applications

Jérémy Chomel Dawap
  • Publié le : 19 avril 2026
  • Mis à jour le : 14 novembre 2026
  • Temps de lecture : 15 minutes
  1. Partager le sens métier avant de partager du code
  2. Distinguer décision, donnée dérivée et règle d’interface
  3. Nommer l’autorité qui tranche chaque décision
  4. Bibliothèque commune : simple, mais jamais instantanément uniforme
  5. Service de décision : cohérence centrale contre dépendance réseau
  6. Projection locale : autonomie au prix de la cohérence différée
  7. Accepter une duplication temporaire sans perdre le contrôle
  8. Construire un contrat qui explique la décision
  9. Séparer la politique métier du workflow applicatif
  10. Versionner une politique sans bascule aveugle
  11. Choisir le mode dégradé avant la première panne
  12. Limiter les données et les pouvoirs du composant partagé
  13. Tester les cas dorés, les frontières et les écarts de version
  14. Mesurer les divergences plutôt que compter les appels
  15. Pour quelles équipes cette méthode devient nécessaire
  16. Erreurs fréquentes qui transforment le partage en dépendance
  17. Plan d’action et grille de décision pour un premier périmètre
  18. Guides complémentaires pour fiabiliser l’architecture
  19. Conclusion : une règle partagée reste une décision gouvernée
Portrait de Jérémy Chomel

Un commercial accepte une remise dans le CRM. Le portail la refuse et la facture affiche encore un autre montant. Le client doit faire corriger son dossier, alors que chaque application a passé ses propres tests. Le premier contrôle consiste à retrouver la règle, sa version et le montant réellement engagé.

Une même décision peut être exécutée dans une bibliothèque, confiée à un service ou alimentée par une copie locale des données. En réalité, centraliser un calcul peut rendre la vente dépendante d’un appel de plus. La bonne option dépend du délai acceptable et des effets que l’entreprise peut encore autoriser en cas de panne.

Pour une application connectée à un ERP et à un CRM, décrivez comment le métier approuve la règle et ce que le portail doit afficher en cas d’écart. Comparez les solutions sur les mêmes devis, les mêmes droits et les mêmes limites de disponibilité.

Partager le sens métier avant de partager du code

Une règle métier transforme une situation en décision : autoriser une remise, rendre une commande annulable, déterminer une éligibilité ou réserver une quantité. Deux applications partagent réellement cette règle lorsqu’elles reconnaissent les mêmes entrées, les mêmes exceptions et la même conséquence. Utiliser le même nom de fonction ne suffit pas. Si le portail évalue le plafond sur le montant hors taxes tandis que le CRM utilise le montant toutes taxes comprises, une bibliothèque commune peut même donner l’illusion d’une cohérence qui n’existe pas.

Le premier travail consiste à écrire des exemples que le métier peut contredire. Une commande de 9 800 euros, un client classé dans une catégorie donnée et une remise demandée de 12 % doivent produire un résultat accompagné de sa raison. Le seuil local n’a rien d’universel : il rend seulement le cas reproductible. Une personne indépendante doit pouvoir changer une entrée, prévoir la décision attendue et expliquer pourquoi une exception existe.

Le langage partagé doit également survivre aux canaux. « Client actif » peut signifier que le contrat est ouvert pour le service commercial, que les paiements sont à jour pour la finance ou qu’un accès numérique reste valide pour le portail. Tant que ces trois décisions conservent le même libellé, mutualiser leur code consolide une ambiguïté. Il faut d’abord nommer séparément l’éligibilité commerciale, l’autorisation financière et le droit d’accès.

Distinguer décision, donnée dérivée et règle d’interface

Tous les éléments ressemblant à une règle ne méritent pas la même stratégie. Une décision critique modifie ce que l’entreprise accepte de faire : engager un prix, accorder un crédit ou autoriser une action sensible. Une donnée dérivée résume un état déjà possédé ailleurs, comme un segment d’affichage ou un indicateur calculé. Une règle d’interface adapte enfin le parcours local, par exemple masquer un bouton lorsque l’utilisateur ne peut raisonnablement pas l’utiliser.

La décision critique demande une autorité claire et une preuve durable. La donnée dérivée peut souvent être projetée dans plusieurs applications, à condition d’afficher sa fraîcheur et de prévoir une réconciliation. La règle d’interface doit rester proche du canal, car sa centralisation ferait dépendre chaque écran d’un service distant sans renforcer la décision finale. Le serveur qui exécute l’action doit toujours revérifier l’autorisation opposable.

Cas concret. Un portail masque le bouton d’annulation après l’expédition, mais l’API Commande reste la seule autorité capable d’accepter ou de refuser l’annulation. Le portail peut reproduire une condition d’affichage pour améliorer l’expérience. Il ne doit pas présenter cette copie comme une garantie, puisque le colis peut changer d’état entre l’ouverture de la page et la confirmation.

Nommer l’autorité qui tranche chaque décision

La source de vérité d’une règle n’est pas nécessairement l’application qui possède le plus de données. C’est l’entité responsable de sa définition, de ses versions, de ses exceptions et de sa date d’effet. La finance peut posséder la politique de crédit tandis que le CRM fournit le segment commercial et que l’ERP expose l’encours. Le composant qui exécute la décision orchestre ces informations sans devenir automatiquement propriétaire de leur sens.

Une fiche d’autorité tient sur une page : décision couverte, responsable métier, équipe technique gardienne, entrées autorisées, résultat produit, motifs de refus, version courante et procédure d’exception. Elle précise aussi ce qui reste hors périmètre. Cette frontière évite qu’un service générique de « validation client » absorbe progressivement crédit, conformité, remise et habilitation sans qu’aucune équipe ne puisse encore le faire évoluer seule.

Le signal faible le plus révélateur apparaît lorsqu’une correction urgente passe systématiquement par la base de données ou par un tableur parallèle. Cela indique que l’autorité officielle ne sait pas porter l’exception réelle. Avant d’ajouter un nouveau consommateur, il faut intégrer le cas manquant ou décider explicitement qu’il reste manuel, puis tracer sa date de réexamen.

Bibliothèque commune : simple, mais jamais instantanément uniforme

Retenir la bibliothèque quand les cycles restent compatibles

Une bibliothèque partagée convient lorsque les applications utilisent le même langage, le même environnement d’exécution et des calendriers de déploiement raisonnablement coordonnés. Elle évite une dépendance réseau, conserve une latence locale et permet des tests rapides. Pour un calcul pur fondé sur des entrées explicites, elle offre souvent le coût d’exploitation le plus faible.

Elle ne crée pourtant pas une décision unique au moment de l’exécution. Chaque application embarque une copie de la version installée. Pendant une migration, la version 3 peut coexister avec la version 4 durant plusieurs semaines. Le contrat doit donc exposer la version de politique dans les traces et les résultats importants. Sans cette information, une différence légitime de déploiement ressemble à un défaut aléatoire.

Refuser le paquet qui importe tout le domaine

Le paquet devient dangereux lorsqu’il transporte entités, accès aux données, configuration, client HTTP et conventions propres à l’application d’origine. Chaque mise à jour force alors des dépendances sans rapport avec la règle. Une bibliothèque saine reçoit des valeurs explicites, retourne une décision explicite et ne connaît ni l’écran, ni la base, ni le framework du consommateur.

Le coût caché se voit dans les mises à niveau différées. Si cinq applications doivent aligner simultanément leurs versions pour corriger une règle urgente, l’organisation a construit un monolithe de livraison réparti dans plusieurs dépôts. Le bon seuil de refus est atteint lorsque la compatibilité descendante et les tests de contrat coûtent plus cher qu’un point d’exécution central maîtrisé.

Service de décision : cohérence centrale contre dépendance réseau

Un service de décision exécute la politique au même endroit pour tous les consommateurs. Il devient pertinent lorsque le résultat doit changer immédiatement, que plusieurs technologies consomment la règle ou que l’entreprise doit expliquer précisément la version appliquée. Un moteur d’éligibilité, un calcul de plafond ou une autorisation contractuelle peuvent relever de ce modèle si leur indisponibilité est traitée comme un risque produit.

La centralisation ajoute de la latence, de la capacité, de la supervision et une nouvelle surface de sécurité. Elle transforme aussi une méthode locale en dépendance opérationnelle. Appeler le service à chaque affichage, chaque ligne d’un tableau et chaque validation peut créer un point de saturation qui n’existait pas. Le consommateur doit demander une décision au moment utile, éventuellement en lot, puis conserver le justificatif nécessaire.

Cas concret. Le CRM demande si une remise de 14 % peut être proposée pour un compte donné. Le service retourne « refusée », le motif « plafond contractuel dépassé », la version de politique, l’heure d’évaluation et un identifiant de décision. Le portail ne reconstruit pas le calcul ; il affiche le motif autorisé. Si la remise change, une nouvelle évaluation est demandée au lieu de réutiliser silencieusement l’ancien verdict.

La décision d’architecture dépend du coût de l’incohérence face au coût de l’indisponibilité. Lorsque deux versions actives pendant une heure sont inacceptables mais qu’un refus temporaire reste supportable, le service central est cohérent. Si le terrain doit continuer plusieurs heures hors connexion, une exécution locale versionnée ou une projection devient plus réaliste.

Projection locale : autonomie au prix de la cohérence différée

Une projection locale reçoit des faits métier et maintient l’état dont une application a besoin pour décider ou afficher. Elle protège l’autonomie et la disponibilité du canal : le portail peut continuer à connaître les droits contractuels déjà reçus même si le système source répond lentement. En contrepartie, l’équipe accepte une fenêtre de décalage et doit savoir la rendre visible.

L’événement publié doit décrire un fait stable, par exemple « conditions commerciales révisées », avec l’identifiant, la version et la date d’effet. Il ne demande pas au consommateur d’exécuter une procédure interne du producteur. Le traitement local est idempotent, refuse une version antérieure et expose son retard. Une réconciliation périodique compare la projection à la source afin de récupérer un événement perdu ou une correction exceptionnelle.

Le piège consiste à appeler « projection » une seconde implémentation complète de la politique. Si chaque consommateur reçoit les données brutes puis recalcule l’éligibilité selon sa propre lecture, la divergence revient. Il vaut souvent mieux publier le fait décidé, ses motifs et sa période de validité, puis laisser aux canaux uniquement leurs choix de présentation.

Accepter une duplication temporaire sans perdre le contrôle

Dupliquer volontairement une règle peut être rationnel lorsque deux applications doivent être découplées rapidement, que le risque reste faible et que la future autorité n’est pas encore prête. Le problème n’est pas la copie elle-même, mais l’absence de durée, de responsable et de détection des écarts. Une duplication gouvernée porte un identifiant de politique commun, des cas de référence communs et une date de sortie.

Cette option convient mal aux mouvements d’argent, aux droits d’accès ou aux engagements externes lorsque deux résultats contradictoires peuvent être exécutés. Elle reste acceptable pour un classement interne réversible ou une recommandation qui sera confirmée plus tard par l’autorité. Le coût d’erreur et la capacité de correction priment sur la préférence technique.

Les deux implémentations sont comparées sur un échantillon de décisions réelles, sans modifier le résultat servi. Dès qu’un écart apparaît, l’équipe conserve les entrées, les versions et les sorties pour comprendre la différence. Si le taux de divergence dépasse le seuil défini par le produit, le déploiement s’arrête ou l’unique autorité reprend la main.

Construire un contrat qui explique la décision

Un bon contrat ne retourne pas seulement un booléen. Il reçoit des entrées nommées et datées, puis produit un statut, des motifs structurés, la version de politique, la date d’évaluation et la durée éventuelle de validité. Lorsque le résultat engage une action coûteuse, un identifiant stable permet de relier l’écran, le journal, l’événement et la reprise.

Les motifs doivent être utiles sans exposer une donnée sensible. « Plafond contractuel dépassé » aide le commercial ; le détail de l’encours ou une information de conformité n’a pas forcément à traverser toutes les applications. Le contrat sépare donc le code de motif destiné à l’automatisation, le message affichable et les éléments réservés à l’audit autorisé.

L’entrée inclut le contexte qui influence réellement la politique : identité du compte, montant, devise, date d’effet, canal ou rôle lorsque ces dimensions sont pertinentes. Lire implicitement une table partagée rend le résultat impossible à reproduire. Avec des entrées explicites, un test peut rejouer la décision et une nouvelle version peut être comparée à l’ancienne.

Séparer la politique métier du workflow applicatif

La politique répond à une question ; le workflow décide quand la poser et quoi faire du résultat. Une règle d’éligibilité peut retourner accepté, refusé ou à examiner. Le portail orchestre ensuite la saisie, l’appel, l’affichage et la demande de revue manuelle. Mélanger ces responsabilités dans le composant partagé l’oblige à connaître les écrans, les notifications et les files de travail de chaque application.

Cette séparation permet aussi de traiter les effets sans double exécution. Le service de décision n’envoie pas lui-même une remise au client et ne modifie pas la commande. Il produit une réponse déterministe. L’application appelante enregistre la décision utilisée, applique l’action avec une clé d’idempotence et publie le fait correspondant. La frontière avec les orchestrateurs est détaillée dans la réflexion sur les services applicatifs et cas d’usage.

Une exception manuelle suit la même discipline. La personne autorisée ne contourne pas la règle en modifiant directement la donnée finale ; elle crée une décision dérogatoire avec un motif, un périmètre et une expiration. Le workflow applique ensuite cette décision comme n’importe quelle autre entrée opposable.

Versionner une politique sans bascule aveugle

Une version de contrat décrit la forme des échanges ; une version de politique décrit le sens appliqué. Les deux évoluent parfois séparément. Ajouter un champ facultatif ne change pas nécessairement la décision, tandis qu’un nouveau plafond peut modifier des résultats sans toucher au schéma. Les traces doivent distinguer ces versions pour éviter de chercher une incompatibilité technique là où le métier a changé.

Avant la bascule, la nouvelle politique peut fonctionner en mode comparaison. Elle reçoit les mêmes entrées que l’ancienne, mais son résultat n’est pas appliqué. L’équipe examine les divergences, les classe entre changement attendu, donnée manquante et défaut de logique. Cette exécution parallèle vaut mieux qu’un pourcentage arbitraire de trafic lorsque les décisions rares sont précisément les plus risquées.

Le déploiement progressif commence par des comptes internes ou un périmètre réversible. Le journal conserve la version effectivement utilisée. Le rollback remet l’ancienne politique pour les nouvelles décisions sans effacer celles déjà engagées ; si une décision antérieure doit être corrigée, une action compensatoire distincte préserve l’historique.

Choisir le mode dégradé avant la première panne

Le mode dégradé dépend de l’effet, pas de la technologie. Une autorisation de paiement peut échouer en position fermée et demander une reprise manuelle. Une recommandation de tri peut conserver la dernière valeur connue. Une information purement décorative peut disparaître. Utiliser le même comportement de secours pour toutes les règles crée soit trop de blocages, soit des décisions dangereuses.

Un cache de décision précise sa clé, sa durée de validité et les événements qui l’invalident. Une valeur périmée reste marquée comme telle dans les traces et, si nécessaire, dans l’interface. Le délai acceptable est un choix métier : dix minutes peuvent convenir à un segment d’affichage, mais pas à la révocation immédiate d’un droit sensible.

Le runbook distingue au moins quatre situations : refus métier normal, entrée invalide, délai dépassé et service indisponible. Pour chacune, il nomme l’action, la personne capable d’arbitrer et le mécanisme de reprise. Un retry n’est autorisé que lorsque l’appel reste idempotent et que son budget ne prolonge pas l’incident. La journalisation conserve l’identifiant de corrélation, la dépendance appelée et la décision de repli.

Limiter les données et les pouvoirs du composant partagé

Centraliser une politique concentre souvent des informations venant de plusieurs domaines. Le service ne doit pas devenir un entrepôt invisible. Il reçoit uniquement les attributs nécessaires, applique une durée de conservation cohérente et évite d’inscrire des données personnelles complètes dans les logs. Un identifiant de décision suffit généralement à retrouver les preuves dans l’espace autorisé.

L’authentification du consommateur ne remplace pas l’autorisation métier. Le portail peut avoir le droit d’évaluer une remise sans avoir celui de la forcer. Le back-office peut consulter un motif détaillé tandis qu’un canal public reçoit un message générique. Les permissions se définissent par action et par contexte, puis les dérogations sont auditées séparément.

Les dépendances doivent aussi être protégées contre l’abus involontaire. Une opération en lot, des quotas par consommateur et des délais courts empêchent un nouvel écran de multiplier les appels jusqu’à saturer l’autorité. Ces limites font partie du contrat d’exploitation et sont testées avant l’ouverture à une application supplémentaire.

Tester les cas dorés, les frontières et les écarts de version

Conserver des exemples approuvés par le métier

Les cas dorés décrivent des entrées, une date d’effet, une décision attendue et son motif. Ils couvrent le cas nominal, les limites exactes, les données absentes et les exceptions. Toutes les implémentations autorisées exécutent ce même jeu. Une modification volontaire met à jour la politique et les attentes dans une seule revue explicite.

Ces exemples ne remplacent pas les tests propres à chaque application. Ils vérifient le sens partagé, tandis que les tests d’intégration contrôlent la sérialisation, les droits, les délais, l’idempotence et la persistance de la version. Un test de bout en bout confirme enfin que l’utilisateur voit un résultat cohérent et que l’action finale respecte encore l’autorité.

Provoquer les situations que le cas nominal masque

La recette coupe le service, retarde un événement, rejoue deux fois le même message et fournit une politique plus récente que celle comprise par le consommateur. Elle vérifie la mise en attente, le refus ou le secours prévu. Le test est incomplet si l’équipe répare manuellement la base sans reproduire la procédure documentée.

Une comparaison en parallèle détecte les divergences sémantiques avant qu’elles produisent un effet. Pour mille décisions représentatives, l’objectif peut être zéro écart non expliqué sur les règles financières. Ce seuil est une décision locale, pas une norme générale. Les différences attendues sont étiquetées ; toute autre différence bloque la bascule jusqu’à son analyse.

Mesurer les divergences plutôt que compter les appels

Le volume d’appels renseigne sur la charge, mais pas sur la justesse. Le tableau de bord utile suit les décisions par version, les motifs dominants, les réponses servies depuis un cache périmé, les modes dégradés et les écarts détectés en comparaison. Il relie ces signaux à un identifiant fonctionnel sans exposer les données qui n’aident pas le diagnostic.

Deux signaux faibles méritent une alerte précoce. Le premier est la persistance d’une ancienne version dans une application rarement déployée. Le second est l’augmentation des dérogations manuelles alors que le taux d’erreur technique reste stable. Dans le premier cas, le processus de mise à niveau échoue ; dans le second, la politique ne représente probablement plus les situations du terrain.

Les objectifs de service portent sur la décision réellement consommable : latence au percentile utile, disponibilité, fraîcheur des projections et délai de réconciliation. Une réponse HTTP réussie mais fondée sur une politique obsolète n’est pas un succès métier. L’observabilité des workflows métier aide à relier ces mesures techniques à l’étape bloquée et à la reprise attendue.

Pour quelles équipes cette méthode devient nécessaire

La méthode devient utile lorsqu’au moins deux applications exécutent une décision coûteuse, que plusieurs équipes les font évoluer ou qu’un changement doit être expliqué après coup. Elle concerne les responsables métier qui possèdent la politique, les équipes produit qui choisissent l’expérience dégradée, les développeurs qui construisent les contrats et l’exploitation qui doit diagnostiquer puis reprendre.

Elle reste volontairement légère pour une règle locale, réversible et sans conséquence externe. Une validation de confort propre à un formulaire ne justifie ni service central ni comité de gouvernance. La priorité va aux décisions portant sur argent, droits, stock rare, conformité, engagement contractuel ou action difficile à compenser.

Une petite organisation peut commencer par un registre de décisions et des cas dorés dans le dépôt. Une plateforme plus distribuée aura besoin d’un catalogue de contrats, d’une supervision transverse et de responsables de domaine identifiés. La maturité de l’outillage doit suivre le nombre de consommateurs et la criticité, pas les effets de mode architecturaux.

Erreurs fréquentes qui transforment le partage en dépendance

  • Partager les entités complètes. Chaque application hérite alors du modèle, des dépendances et du rythme de livraison de l’autre, même lorsque seule une décision devait être commune.
  • Centraliser tous les appels. Une règle d’affichage ou une donnée dérivée ne mérite pas forcément une dépendance synchrone sur chaque écran et chaque export.
  • Publier des données brutes sans décision. Les consommateurs reconstruisent ensuite la politique avec leurs propres arrondis, dates et exceptions, ce qui recrée exactement la divergence initiale.
  • Cacher la version appliquée. Le support ne peut plus distinguer un défaut réel d’une transition normale entre deux politiques compatibles.
  • Ajouter un cache sans sémantique de fraîcheur. Une valeur ancienne continue à circuler comme si elle était certaine, parfois longtemps après une révocation importante.
  • Confondre événement et transaction. La cohérence différée ne convient pas lorsqu’une action externe irréversible dépend immédiatement du résultat.
  • Laisser la technique posséder seule la règle. Sans responsable métier pour valider les cas limites, le composant partagé devient une accumulation d’exceptions que personne n’ose simplifier.

Plan d’action et grille de décision pour un premier périmètre

D’abord, cadrer une seule décision coûteuse

Choisissez une contradiction déjà observée, par exemple le plafond de remise entre le CRM et le portail. Recueillez dix à vingt situations représentatives, dont les valeurs limites, les refus et les dérogations. Nommez l’autorité métier, les applications qui consomment la décision et l’effet produit par chacune. Cette entrée réduit le débat à un problème vérifiable au lieu d’ouvrir un programme abstrait de mutualisation.

Décrivez ensuite le contrat indépendamment de l’outil : entrées, sortie, motifs, version, durée de validité et données interdites. L’équipe responsable précise les seuils, les dépendances et la politique en cas d’indisponibilité. L’exploitation ajoute la journalisation, l’identifiant de corrélation et le chemin de reprise. Ces responsabilités doivent être attribuées avant la première implémentation.

Ensuite, choisir le support selon quatre contraintes

Retenez une bibliothèque lorsque le calcul est pur, les technologies compatibles et les versions coexistantes acceptables. Préférez un service de décision lorsque tous les consommateurs doivent appliquer immédiatement la même politique et que la dépendance réseau peut être correctement exploitée. Utilisez une projection lorsque l’autonomie locale et la disponibilité priment sur une cohérence instantanée. Autorisez enfin une duplication temporaire lorsque le risque est faible, la sortie datée et les écarts automatiquement détectés.

  1. D’abord, évaluer l’incohérence. Refuser la duplication lorsqu’un résultat contradictoire engage de l’argent, un droit ou une promesse difficile à corriger.
  2. Ensuite, évaluer l’indisponibilité. Écarter l’appel synchrone si le canal doit continuer hors ligne ou si aucun mode dégradé acceptable n’existe.
  3. Puis, évaluer le rythme de changement. Choisir une bibliothèque seulement si les consommateurs savent installer et observer les nouvelles versions dans le délai attendu.
  4. Après cela, évaluer la fraîcheur. Retenir une projection lorsque son retard maximal peut être mesuré, affiché et réconcilié sans mettre le métier en danger.
  5. Enfin, décider une date de revue. Documenter les limites, le coût complet et la condition qui ferait changer d’architecture au lieu de figer le choix pour toujours.

Puis, déployer avec comparaison et retour maîtrisé

Implémentez le contrat avec des dépendances explicites, des délais bornés, une idempotence adaptée et une journalisation exploitable. Les tests de contrat exécutent les cas dorés dans chaque consommateur. Le runbook précise le retry autorisé, le basculement vers le mode dégradé, la réconciliation et le rollback de politique. Deux paragraphes de documentation opérationnelle valent mieux qu’un diagramme qui ne décrit aucune reprise.

Faites fonctionner la nouvelle politique en comparaison sur un périmètre représentatif. Les écarts sont expliqués avant la bascule, puis un petit groupe de comptes reçoit effectivement la nouvelle décision. Le tableau de bord surveille versions anciennes, latence, dérogations et fraîcheur. Si le seuil de divergence ou le budget d’indisponibilité est dépassé, revenez au palier précédent sans réinterpréter les décisions déjà exécutées.

Guides complémentaires pour fiabiliser l’architecture

Le pilier sur l’intégration d’un ERP à une application métier aide à choisir les échanges et leurs responsables. Pour les identifiants et les règles déjà portées par l’ERP, consultez aussi le guide de raccordement sans double calcul.

Concevoir les échanges sans diluer la responsabilité

Une règle exposée à plusieurs équipes exige un contrat utilisable et une politique de compatibilité. La méthode consacrée à la conception d’une API interne durable prolonge ce travail sur les erreurs, la pagination, les limites et le support des consommateurs.

Lorsque la propagation repose sur des faits métier, l’analyse de l’architecture orientée événements aide à distinguer autonomie réelle, cohérence différée et complexité inutile. Le transport ne doit jamais masquer l’autorité de la décision.

Préparer les reprises et les contrôles de production

Les doublons, les échecs partiels et les messages retardés demandent une stratégie avant la mise en service. Les bases de l’idempotence et de la reprise sur erreur permettent de relier le contrat de décision aux effets réellement appliqués.

Enfin, la réflexion sur la source de vérité des données complète celle sur les politiques. Une donnée peut appartenir à un domaine tandis qu’une décision combinant plusieurs données appartient à un autre ; confondre les deux crée des intégrations impossibles à gouverner.

  • Commencer par l’autorité métier et les cas dorés avant de retenir une bibliothèque, une API ou un flux d’événements.
  • Rendre visibles la version de politique, la fraîcheur et le mode dégradé dans les preuves consultées pendant un incident.
  • Vérifier régulièrement les divergences, les dérogations et les anciennes versions afin de corriger la gouvernance avant la panne.

Conclusion : une règle partagée reste une décision gouvernée

Attribuez la politique à une équipe et consignez sa date, ses entrées et le motif du verdict. Vérifiez comment chaque application obtient le résultat et gère les cas où il manque.

Exercez un devis courant, une ancienne version et l’indisponibilité de la décision. Fixez avec les métiers ce qui peut rester consultable, ce qui doit attendre et qui réconcilie les écarts.

Dawap peut vous aider à cadrer votre application connectée à l’ERP et au CRM en attribuant les règles et en éprouvant leurs contrats sur un premier parcours.

Portrait de Jérémy Chomel

Garder une même décision métier entre ERP, CRM et portail

Identifier la version, le résultat et le comportement autorisé quand la décision de référence tarde.

Cadrer mon application ERP / CRM

Articles recommandés

Service layer, cas d’usage et orchestrateurs clairement séparés Développement web Service layer, use cases et orchestrateurs : comment ne pas tout mélanger Lire l'article
  • 17 avril 2026
  • Lecture ~16 min

Une classe qui valide, écrit, appelle trois services et relance les erreurs ne porte plus une responsabilité lisible. Ce guide sépare décision métier, cas d’usage et orchestration, puis montre comment fixer la transaction, absorber les doublons et rendre chaque reprise compréhensible par le support.

Flux métier piloté par des événements explicites Développement web Architecture orientée événements : quand elle aide vraiment le métier Lire l'article
  • 15 avril 2026
  • Lecture ~14 min

L’événementiel aide lorsque plusieurs capacités autonomes réagissent à un fait stable, sans partager la même transaction. Encore faut-il nommer la source de vérité, accepter un délai mesuré, absorber les doublons et rendre chaque écart réconciliable. Ce guide donne les critères d’un premier flux maîtrisé.

API interne conçue autour des gestes et contraintes terrain Développement web Concevoir une API interne qui tienne vraiment les usages terrain Lire l'article
  • 11 avril 2026
  • Lecture ~14 min

Une API propre sur un diagramme peut échouer dès que le réseau coupe, qu’un geste est répété ou qu’un droit dépend du dossier. Cette méthode part des utilisateurs réels pour définir capacités, erreurs, listes et reprises, puis éprouve le contrat avec deux consommateurs avant d’élargir sa surface et ses responsabilités.

Recette de reprise après panne pour une outbox transactionnelle Développement web Outbox : reprendre après une panne Lire l'article
  • 25 octobre 2026
  • Lecture ~19 minutes

La commande est enregistrée, mais le message ne part jamais. Une outbox peut conserver cette intention, à condition de maîtriser ses reprises et ses doublons. Le dossier suit un arrêt réel après commit, une réponse perdue et un bail expiré, avec un programme local pour vérifier les effets et les acquittements.

Garder une même décision métier entre ERP, CRM et portail

Identifier la version, le résultat et le comportement autorisé quand la décision de référence tarde.

Cadrer mon application ERP / CRM