Développement web

Comment découper un domaine fonctionnel sans casser les responsabilités

Jérémy Chomel Dawap
  • Publié le : 27 avril 2026
  • Mis à jour le : 14 novembre 2026
  • Temps de lecture : 8 minutes
  1. Observer le dossier avant de dessiner les modules
  2. Nommer les décisions et les résultats transmis
  3. Désigner qui écrit chaque donnée de référence
  4. Définir le contrat entre deux domaines
  5. Tester un incident à la frontière
  6. Mesurer les changements qui traversent plusieurs domaines
  7. Mettre en place une première frontière interne
  8. Faire accepter les cas par les métiers et le support
  9. Pour qui découper par domaine
  10. Éviter les erreurs fréquentes de découpage
  11. Arbitrer entre une limite plus nette et un module commun
  12. Préparer un premier lot de découpage
  13. Plan d’action pour exercer la frontière
  14. Définir les preuves qui autorisent un transfert
  15. Vérifier les dépendances oubliées après la recette
  16. Relier les frontières au premier lot et à l’exploitation
  17. Conclusion
Portrait de Jérémy Chomel

Le service commercial voit une commande validée. La finance utilise le même statut pour dire que la facture peut être émise. Un tableur corrige les dossiers entre les deux. Tant que ces décisions partagent une seule valeur, une nouvelle interface peut encore reproduire le même écart.

Le vrai enjeu est de placer chaque décision chez le domaine qui peut en accepter les conséquences. En réalité, conserver un module commun peut résoudre un défaut que deux services séparés rendraient plus difficile à diagnostiquer. Un dossier peut garder un identifiant commun alors que la conformité, le plafond et la facturation relèvent de responsables différents. La frontière devient utile quand un changement de règle peut être vérifié sans déplacer les écritures qui appartiennent aux autres domaines.

Dans une application métier sur mesure, partez d’une commande entière. Rejouez un refus, une correction et une réponse en retard. Ces essais montrent quelles décisions doivent partager une transaction et quelles sorties peuvent être transmises à un autre domaine.

Observer le dossier avant de dessiner les modules

Suivez un dossier complet, puis un dossier qui a nécessité une correction. Relevez chaque geste, le fichier parallèle, l’écran et l’écriture reçue. Demandez aux agents quelle preuve leur permet de poursuivre et à qui ils signalent un écart.

Dans un exemple fictif, la commande validée dans le portail est corrigée dans un tableur avant facturation. Comparez le montant initial, la correction et le montant émis. Faites préciser qui a autorisé la correction et si elle peut encore s’appliquer après émission.

Nommer les décisions et les résultats transmis

L’accord commercial confirme un engagement. La facturation produit un document sur une commande éligible. Le support peut consulter les deux états et qualifier les écarts. Écrivez ce qui autorise chacun de ces gestes, dans le vocabulaire du service qui le reçoit.

Si un changement de plafond invalide des commandes déjà préparées, alors identifiez la décision qui définit la date d’effet et les dossiers qui gardent la règle précédente. La cohérence de ces dossiers guide la frontière.

Désigner qui écrit chaque donnée de référence

Lorsqu’un architecte coordonne trois fournisseurs autour de la donnée client, faites rejouer la correction d’une adresse avant facturation. Un fournisseur transmet la demande, le propriétaire valide la correction et les autres lisent la version datée. L’architecte tient la liste des dépendances et vérifie que les contraintes d’accès et de migration sont testées sur la même version. Si chaque fournisseur prévoit d’écrire sa propre valeur, faites arbitrer la responsabilité avant de signer les interfaces.

Séparer les droits de lecture et de modification

Deux interfaces peuvent afficher un plafond, mais attribuez sa modification à un seul responsable. Le contrat donne sa version, sa date d’effet et la procédure de correction. Le consommateur garde la référence lue à l’instant où il a pris sa décision.

Exemple concret fictif. La vente baisse le plafond dans son portail pendant que la conformité le modifie dans un autre outil. Tant que les deux écrivent, le résultat dépend de la dernière modification reçue. Attribuez l’écriture, convertissez le second écran en demande de modification et testez les refus de mise à jour directe.

Définir le contrat entre deux domaines

La commande décrit une intention, comme demander une facturation. La réponse confirme un refus, une attente ou un effet reçu. Un événement annonce un fait déjà établi. Fixez le sens, le propriétaire, la version et l’identité de l’opération pour chacun de ces échanges.

Une dépendance doit avoir une entrée, une sortie et un seuil. Le contrat indique aussi la responsabilité du repli et la journalisation. Si l’ERP est indisponible, la demande garde son état et le support retrouve la dernière référence confirmée avant d’envisager un rejeu.

Tester un incident à la frontière

Rejouer la même demande avec une réponse en retard

Envoyez une demande de facture depuis le portail et interrompez la réception de la réponse. La finance peut parfois confirmer qu’une facture existe déjà. Dans ce cas, le backend rattache la référence au dossier avant de présenter une nouvelle action. Faites refaire le diagnostic avec les droits du support.

Si les journaux ne relient aucune demande à la facture existante, alors gardez le flux en attente et rétablissez la corrélation. Testez aussi le rejet métier, où le système a répondu mais où le résultat n’autorise aucune relance automatique.

Mesurer les changements qui traversent plusieurs domaines

Considérez les dernières modifications. Notez celles qui exigent de modifier plusieurs règles, une base partagée ou un export dont personne ne connaît tous les consommateurs. Un changement pour lequel les équipes déploient toujours ensemble mérite une revue des dépendances.

Dans un essai de 5 jours, demandez au métier d’ajuster une règle puis au support de reprendre un rejet. Si l’équipe doit modifier la même règle dans trois modules, alors regroupez les écritures sous le même responsable avant d’ajouter des appels réseau.

Mettre en place une première frontière interne

Avant de transférer la facturation dans un module dédié, repérez toutes les voies qui produisent une facture. Vous pouvez en trouver une dans le formulaire, une dans l’API et une dans la reprise nocturne. Faites appeler la même décision par ces trois entrées. La sortie garde l’identifiant du dossier, la règle appliquée et l’état du document après chaque appel.

Dans un second essai, bloquez le consommateur d’un message après l’enregistrement du résultat. La journalisation et le contrat indiquent le dernier effet, la responsabilité du rejeu et le seuil d’arrêt. Une personne du support doit retrouver la même preuve depuis ses accès. La QA vérifie que la reprise ne produit pas une seconde écriture.

Commencez par un module avec un contrat appelé par le formulaire et par l’import. Faites passer les deux par la même décision. Le test de dépendance échoue si un autre module écrit directement dans ses tables. Gardez un seul déploiement tant que la charge et la cadence le permettent.

Un dossier historique peut utiliser un ancien chemin. Recensez les imports, fichiers et tâches planifiées puis faites rejouer les dossiers encore en attente. Le repli indique quelle version reste capable de traiter ces états.

Faire accepter les cas par les métiers et le support

La recette porte sur le chemin courant, un refus et la reprise. Le métier confirme le vocabulaire et les résultats. La QA vérifie les droits et les échanges. Le support explique quelle action est possible depuis la trace.

Si un état « validé » désigne encore deux choses, alors demandez aux deux équipes d’énoncer la décision précise qu’elles ont prise. Faites apparaître ces décisions dans les écrans et dans la trace avant d’étendre le modèle.

Pour qui découper par domaine

Le sujet apparaît quand plusieurs canaux ou équipes partagent le logiciel, ou quand une règle en cours d’évolution peut déclencher un effet dans un autre système. Un référentiel stable peut rester dans un module simple avec des responsabilités explicites.

Éviter les erreurs fréquentes de découpage

Évitez de créer un domaine pour chaque écran ou chaque service de l’organigramme. Les mêmes personnes peuvent porter plusieurs décisions distinctes. Vérifiez qui doit intervenir quand une décision échoue pendant la clôture.

Une bibliothèque commune peut contenir un format ou un type stable. Une règle qui engage plusieurs équipes doit avoir un propriétaire et des cas de recette, même si sa mise en œuvre est partagée.

Arbitrer entre une limite plus nette et un module commun

Si un contrôle de TVA dépend à la fois du tarif et de la ligne de facture, alors réunissez les données nécessaires à la décision dans le même périmètre de contrôle. Un service de consultation peut recevoir ensuite un état daté. Demandez au métier si un délai de publication est acceptable pour définir ce que la recette doit exercer.

Pour deux opérations qui doivent réussir ensemble sur le même état, vérifiez si un module et une transaction locale permettent de tenir cette règle. Si l’une peut attendre avec un résultat intermédiaire décrit, alors un contrat asynchrone peut devenir une option.

Le coût complet inclut la recette, les files, le délai de diagnostic et les reprises. Une frontière qui rend toutes les modifications plus lentes appelle un autre découpage ou une responsabilité plus claire.

Préparer un premier lot de découpage

Prenez le dossier où la frontière affecte une décision que plusieurs personnes peuvent vérifier. Faites définir par les métiers le cas attendu et le refus qui protège le travail.

  1. Contrôlez d’abord les écritures et documentez leurs responsables.
  2. Testez ensuite le dossier dans les deux versions, puis attribuez chaque écart.
  3. Documentez le verdict, la procédure de reprise et les dépendances à retirer.

Plan d’action pour exercer la frontière

Définissez une date de contrôle après le premier lot. Rejouez un statut en attente et une correction tardive. Mesurez le temps nécessaire pour expliquer le résultat, puis cherchez les écritures qui passent encore par l’ancien chemin.

Quand la nouvelle frontière protège le résultat et simplifie le diagnostic, préparez le transfert d’une autre décision. Sinon, corrigez le sens du contrat sur le périmètre courant.

Définir les preuves qui autorisent un transfert

Le métier confirme le statut et ses exceptions. L’exploitation valide le délai de reprise. Le responsable de la donnée vérifie que le résultat convenu apparaît dans chaque système consommateur. Un écart reçoit un responsable et un périmètre fermé.

Vérifier les dépendances oubliées après la recette

Relisez les exports et les corrections faites à la main. Un traitement de nuit qui écrit toujours dans le domaine révèle une frontière incomplète. Attribuez sa reprise ou son retrait avant de limiter les accès à l’ancienne base.

Relier les frontières au premier lot et à l’exploitation

Le pilier sur le premier lot d’application métier aide à choisir le dossier qui prouve le résultat. Pour modéliser la règle à l’intérieur d’une frontière, choisissez un usage proportionné du DDD.

Le guide des workflows à fortes exceptions aide à représenter la progression du dossier. Pour vérifier ce que montre le support à travers plusieurs traitements, utilisez le guide d’observabilité métier.

Conclusion

Le découpage prend forme quand les métiers nomment leurs décisions et que chaque écriture a un responsable. Faites vérifier la même frontière par l’équipe qui produit l’effet et celle qui le reçoit.

Testez l’échec partiel, le repli et le chemin historique avant de déplacer une responsabilité. Les preuves obtenues guident le choix d’un module ou d’un service séparé.

Pour cadrer votre application métier, Dawap peut suivre avec vos équipes les dossiers réels et définir les premiers contrats à recevoir.

Portrait de Jérémy Chomel

Découper les domaines à partir des décisions métier

Attribuer chaque écriture et éprouver les contrats sur un dossier réel avant de déplacer la responsabilité.

Cadrer mon application métier

Articles recommandés

Développement d’application métier sur mesure : les vrais enjeux en 2026 Développement web Cadrer le premier lot d’une application métier Lire l'article
  • 23 décembre 2024
  • Lecture ~47 min

Choisissez le premier processus à fiabiliser avant d’engager le budget. Le guide aide à mesurer les reprises, vérifier ce que le standard couvre et définir un résultat recevable avec les équipes. Les critères de décision couvrent droits, intégrations, données et exploitation pour délimiter un lot que vous pouvez réellement tester.

DDD pour application métier : utile ou trop lourd selon le contexte Développement web DDD pour application métier : utile ou trop lourd selon le contexte Lire l'article
  • 29 avril 2026
  • Lecture ~8 min

Le DDD aide lorsque deux équipes donnent des sens différents au même statut ou qu’une erreur sur une règle déclenche des reprises. Ce guide compare une réservation de ressources, une autorisation de publication et un référentiel stable. Il montre quoi modéliser, comment exercer la concurrence et quelles preuves faire recevoir.

Architecture d’un workflow métier à fortes exceptions Développement web Architecture d’un workflow métier à fortes exceptions Lire l'article
  • 17 juillet 2026
  • Lecture ~16 min

Un workflow complexe ne se résume pas à une succession d’écrans. Ce guide sépare états, décisions, effets externes, compensations, reprises et preuves. Il aide à choisir une orchestration proportionnée, à traiter les points de non-retour et à donner aux équipes une trajectoire claire pour chaque exception.

Observabilité fonctionnelle d’un workflow métier de bout en bout Développement web Observabilité d’un workflow métier : voir le dossier réel Lire l'article
  • 17 juillet 2026
  • Lecture ~17 min

Logs techniques et disponibilité ne suffisent pas. Instrumentez états, transitions, décisions, délais et reprises pour expliquer où un dossier métier s’est réellement bloqué. Le guide relie événements fonctionnels, traces, métriques, alertes et modes opératoires sans transformer les données personnelles en identifiants de corrélation.

Découper les domaines à partir des décisions métier

Attribuer chaque écriture et éprouver les contrats sur un dossier réel avant de déplacer la responsabilité.

Cadrer mon application métier