UNIFINplatform

Solution

Unifin Architect Builder

Un nouveau système s\'assemble à partir de briques prêtes, il ne s\'écrit pas de zéro.
Le constructeur transforme un modèle de problème en services, écrans et processus.
La livraison passe des mois aux jours, le circuit d\'argent reste sous contrôle.

  • Constructeur low-code
  • Briques prêtes
  • Génération déterministe
Toutes les solutions

Écrans en service des terminaux produit

Exécution de génération avec le verdict du vérificateur Exécution de génération avec le verdict du vérificateur Studio de préréglages avec le système assemblé Studio de préréglages avec le système assemblé Éditeur du modèle de solution

Constructeur interactif

Ouvrir le constructeur

Le constructeur est une application qui marche, pas une page statique. Ouvrez le moteur, choisissez un préréglage et assemblez des briques prêtes.

Fonctions en un coup d'œil

Les fonctions métier en un coup d'œil

Du modèle de problème au système en marche.

Modèle de solution
Garde entités, champs, écrans et processus comme une source
Le système et ses documents s'accordent toujours
Catalogue de briques
Liste les briques backend, frontend et règles avec paramètres
Les équipes assemblent à partir de l'existant
Validation du modèle
Contrôle la structure et les références avant génération
Un système incohérent ne peut être assemblé
Génération déterministe
Construit services, écrans, tests et déploiements depuis le modèle
Le même modèle donne le même résultat
Couche de vérification
Lance gardes, audit d'interface et invariants d'argent
Le défaut s'arrête avant la livraison
Métadonnées d'exécution
Change la partie type sans reconstruction
Les changements de routine ne demandent pas de version
Processus et règles
Garde états, transitions, acteurs et calculs en déclaratif
Les processus changent sans code manuel
Interfaces ouvertes
Expose le modèle par MCP, CLI et schéma ouvert
L'IA et les partenaires travaillent sur un contrat

Ce qui tourne déjà

Assembler, pas développer, déjà possible

Assembler, pas développer : le constructeur en marche.

Modèle

Entités, écrans et processus vivent dans un modèle gouverné.

Briques

Le catalogue tient les briques backend et frontend avec schémas.

Génération

Services, écrans et tests sont générés de façon déterministe.

Vérification

Gardes et invariants approuvent ou bloquent chaque exécution.

Exécution

La partie type change par configuration, sans reconstruction.

Interfaces

MCP, CLI et schéma JSON relient l'IA et les outils partenaires.

Description de la solution

Capacités et aperçu

Fonctions clés

  • Modèle de solution : entités, champs, écrans et processus
  • Catalogue de briques avec schémas de paramètres
  • Suggestion de briques par entités et écrans du modèle
  • Validation du modèle et des références croisées
  • Génération déterministe du backend et du frontend
  • Génération de tests avec cas négatifs et bornes
  • Manifestes de déploiement issus du modèle
  • Vérification : gardes, audit d'interface et invariants d'argent
  • Métadonnées d'exécution pour la partie type
  • Moteurs de processus et de règles
  • Serveur MCP, CLI et schéma JSON ouvert
  • Rôles, revue et audit des actions

Aperçu produit

Unifin Architect Builder est un constructeur low-code de nouveaux systèmes pour les places, les banques et leurs équipes IT.

Il transforme un modèle de solution en services, portails, migrations, tests et manifestes de déploiement à partir de briques prêtes.

Le constructeur est déterministe : le même modèle donne le même résultat, et les modifications manuelles survivent via des marqueurs.

Il repose sur la plateforme UniFin, donc le système assemblé réutilise l'identité, l'audit, l'approbation et la colonne d'événements partagées.

Le résultat est un système déployable, pas un prototype : services, écrans et documents viennent d'une seule source.

Ce qu'il apporte

Ce que le constructeur apporte

Du modèle au système en marche, brique par brique.

Modèle de solution

Les systèmes se décrivent d'ordinaire dans des documents dispersés qui divergent du code. Le constructeur garde entités, champs, écrans et processus comme un modèle versionné. Avec la solution le modèle est la source de vérité, et le système s'y accorde. En configuration le modèle est visible, révisable et versionné, et son historique l'accompagne.

Catalogue de briques

Chaque nouvel écran commence d'ordinaire par un fichier vide. Le constructeur propose des briques selon les entités et les écrans du modèle. Avec la solution les équipes assemblent à partir de briques déjà passées par les gardes. En configuration le catalogue, les groupes et les schémas de paramètres sont visibles, et le jeu de briques vient en catalogue.

Génération déterministe

La livraison dépend d'ordinaire de qui écrit le code et quand. Le constructeur génère services, écrans, tests et déploiements depuis le modèle. Avec la solution le même modèle donne le même résultat à chaque exécution. En configuration les marqueurs de génération et l'aperçu des différences sont visibles, donc les modifications manuelles survivent.

Couche de vérification

Le code généré arrive d'ordinaire en revue sans preuve de sûreté. Le constructeur lance gardes, audit d'interface et invariants d'argent sur tout ce qu'il produit. Avec la solution un défaut s'arrête avant la livraison, pas en production. En configuration les verdicts et les preuves sont visibles, et le circuit d'argent reste en code généré.

Métadonnées d'exécution

La partie type d'un système attend d'ordinaire la prochaine version. Le constructeur garde pages, formulaires et listes en métadonnées d'exécution versionnées. Avec la solution un dictionnaire ou une liste change sans reconstruction. En configuration les métadonnées et leurs versions sont visibles, et l'audit des changements note qui a bougé quoi.

Processus et règles

Un changement de processus devient d'ordinaire une tâche de développement. Le constructeur garde états, transitions, acteurs et règles en déclaratif. Avec la solution un parcours change par configuration, sous quatre yeux. En configuration la définition du processus et les tables de décision sont visibles, et les acteurs viennent du canon des rôles.

Interfaces ouvertes

Un constructeur enferme d'ordinaire le client dans ses propres outils. Le constructeur expose le modèle par MCP, CLI et schéma JSON ouvert. Avec la solution assistants IA, CI et outils partenaires travaillent sur un contrat. En configuration le schéma, la CLI et le serveur sont visibles, et le résultat reste du code ordinaire.

Couverture

Ce qu'il couvre

Du modèle aux services, écrans et déploiements.

Modèle de solution

Entités, champs, écrans, processus et rôles dans un modèle versionné.

Catalogue de briques

Briques backend, frontend, règles, rapports et intégration avec schémas.

Génération

Services, migrations, écrans, tests et manifestes de déploiement depuis le modèle.

Vérification

Gardes, audit d'interface, mutation et invariants d'argent avec un verdict.

Exécution

Métadonnées de pages, moteur de processus, règles et audit des changements.

Interfaces

Serveur MCP, CLI et schéma JSON ouvert du modèle.

Stand

Écrans de la solution

Le studio de préréglages, le catalogue de briques et le système assemblé.

Studio de préréglages avec le système assemblé
Studio de préréglages : le système assemblé sur un canevas
Tableau de bord du catalogue de briques
Catalogue de briques avec maturité et couverture
Éditeur du modèle de solution
Éditeur du modèle : entités, champs et écrans
Exécution de génération avec le verdict du vérificateur
Exécution de génération : aperçu des différences et verdict

Comment ça marche

Du modèle de problème au système déployable en cinq étapes

Du modèle de problème au système déployable.

  1. 1

    Le modèle est décrit

    Entités, champs, écrans et processus sont définis une fois.

  2. 2

    Les briques sont suggérées

    Le catalogue propose des briques selon entités et écrans.

  3. 3

    Le résultat est prévisualisé

    Un aperçu des différences montre ce qui sera créé.

  4. 4

    Les artefacts sont générés

    Services, écrans, tests et manifestes sont construits.

  5. 5

    Le vérificateur rend un verdict

    Gardes et invariants approuvent ou bloquent la livraison.

Secteurs

Secteurs servis

Le constructeur sert les places, les banques, les dépositaires et les intégrateurs qui assemblent de nouveaux systèmes financiers à partir de briques prêtes.

Banque / paiements

Règlement, paiements et services de conservation pour le marché autour du cœur de négociation.

Dépositaire central / conservation

Conservation, opérations sur titres et discipline de règlement pour actifs classiques et numériques.

Architecture

Architecture et accès

Le constructeur repose sur la base commune de la plateforme et pilote code, métadonnées et documents depuis un seul modèle.

Sur la base de la plateforme

Identité, audit, approbation et colonne d'événements partagés.

Le modèle comme source

Un modèle versionné pilote code, métadonnées et documents.

Génération déterministe

Le même modèle donne le même résultat ; les marqueurs gardent les modifications.

La vérification d'abord

Le circuit d'argent est en code généré seul, avec gardes et invariants.

Couche IA

Le composeur IA propose le modèle et les briques, et le vérificateur le contrôle.

Schéma d'architecture La même architecture en page autonome. Ouvrir le schéma à part

Maturité

Prêt aujourd'hui, la suite ensuite

Le constructeur tourne sur la plateforme ; ensuite les briques partenaires.

Disponible aujourd'hui

  • Modèle de solution, versionnement et validation
  • Catalogue de briques avec schémas de paramètres
  • Génération déterministe du backend, du frontend et des tests
  • Vérification : gardes, audit d'interface et invariants d'argent

Étape suivante

  • Place de marché de briques partenaires (feuille de route)
  • Variantes d'éditeur visuel du modèle par rôle (feuille de route)
  • Connecteurs d'outils externes par contrat ouvert (feuille de route)

Versions

Historique des versions

Versions trimestrielles depuis la fondation de la plateforme (2020) ; la ligne du constructeur démarre en 2026.

2026 Q2

  • Le modèle de solution, sa validation et son versionnement.

2026 Q3

  • Le catalogue de briques, la génération déterministe et la couche de vérification.

2026 Q4

  • Le studio de préréglages, les métadonnées d'exécution et le contrat ouvert (prévu).

Description détaillée

Description détaillée

La carte des couches, les garanties et le cadre de livraison.

Comment la suite est assemblée

Canaux et clients
FIX 4.2 / 4.4 / 5.0, REST avec mTLS, fichiers SFTP, portails web
Périphérie et accès
Passerelle API avec 126 routes, authentification unique Keycloak, WAF et CSP
Services du cœur de plateforme
solution model brick catalog generator verifier AI agentic layer Services de la suite sur le cœur de plateforme partagé
Données et événements
PostgreSQL 17 par service, Redis 7, files quorum RabbitMQ 3.13, outbox transactionnel
Résultats et reporting
Portails, rapports, canaux régulateur et partenaires

Description détaillée

Laissez vos contacts pour ouvrir la description détaillée et télécharger le PDF avec l'architecture, les cas et les détails de mise en service.

Assemblez un système à partir de briques prêtes

Décrivez le problème : nous apporterons le modèle, le jeu de briques et le vérificateur pour une première solution assemblée.