Outil d’identification des dispositifs d’accompagnement financier des entreprises innovantes.

 


1️⃣ Formulation très courte (1–2 phrases)

Proposer un outil d’orientation qui, à partir de critères renseignés par l’entreprise, identifie automatiquement les dispositifs d’accompagnement mobilisables et précise les modalités de candidature ou de dépôt de dossier associées.


2️⃣ Pitch court (5–6 lignes)

L’objectif est de développer un outil d’aide à l’orientation des entreprises vers les dispositifs d’accompagnement existants.
L’outil recenserait l’ensemble des critères et paramètres d’éligibilité des dispositifs (stade, secteur, géographie, maturité, besoins, etc.).
Une fois ces éléments renseignés, il permettrait :

  1. d’identifier les dispositifs d’accompagnement pertinents ;
  2. de restituer, pour chacun, le processus de candidature ou de soumission de dossier.
    L’enjeu est de simplifier l’accès aux dispositifs et de réduire la complexité administrative en amont.

3️⃣ Note de synthèse structurée (usage interne / projet)

Idée / concept
Développer un outil centralisé de référencement des dispositifs d’accompagnement (publics, privés, territoriaux, sectoriels), fondé sur leurs critères d’éligibilité.

Fonctionnement
L’utilisateur renseigne un ensemble de paramètres (profil de l’entreprise, stade de développement, besoins, secteur, localisation, type de projet…).
L’outil analyse ces données et génère automatiquement :

  • la liste des dispositifs d’accompagnement mobilisables ;
  • pour chacun, le parcours associé (processus de candidature, pièces attendues, calendrier, étapes clés).

Valeur ajoutée

  • Gain de temps pour les entreprises et les accompagnateurs.
  • Meilleure lisibilité de l’écosystème d’accompagnement.
  • Orientation plus fiable et cohérente vers les bons dispositifs, au bon moment.

4️⃣ Version “banque / innovation / écosystème”

Mise à disposition d’un outil d’orientation intelligent permettant, à partir de critères normalisés, de cartographier les dispositifs d’accompagnement mobilisables par une entreprise et d’en expliciter les modalités opérationnelles (éligibilité, parcours de candidature, attendus).
L’outil vise à fluidifier l’accès aux dispositifs, fiabiliser l’orientation et renforcer la valeur de conseil.


Si tu veux, prochaine étape possible (au choix, je le fais direct) :

  • 🧠 Schéma logique (entrées → moteur de règles → sorties)
  • 📋 Liste type de critères / paramètres
  • 🧩 User story (ex. chargé d’affaires / dirigeant / accompagnateur)
  • 📊 Matrice “dispositifs × critères” exploitable en Excel ou outil digital

Dis-moi simplement l’usage cible (note interne, comité, pitch partenaire, projet IT).


🧱 Logique IT fonctionnelle de l’outil d’orientation

1️⃣ Vue d’ensemble (architecture fonctionnelle)

┌──────────────────┐
│ Interface Util.  │
│ (Front-End)      │
└────────┬─────────┘
         │
         ▼
┌──────────────────────────┐
│ Module de saisie         │
│ des critères             │
└────────┬─────────────────┘
         │
         ▼
┌──────────────────────────┐
│ Normalisation & contrôle │
│ des données              │
└────────┬─────────────────┘
         │
         ▼
┌──────────────────────────┐
│ Moteur de règles         │
│ / Matching               │
└────────┬─────────────────┘
         │
         ▼
┌──────────────────────────┐
│ Base Dispositifs         │
│ & Processus              │
└────────┬─────────────────┘
         │
         ▼
┌──────────────────────────┐
│ Génération des résultats │
│ & parcours utilisateurs  │
└────────┬─────────────────┘
         │
         ▼
┌──────────────────┐
│ Restitution /    │
│ Orientation      │
└──────────────────┘

2️⃣ Description des briques fonctionnelles

🔹 1. Interface utilisateur (Front-End)

Rôle

  • Point d’entrée utilisateur (entreprise, conseiller, accompagnateur).

Fonctions

  • Accès guidé à l’outil.
  • Parcours simple et progressif.
  • Possibilité d’enregistrer ou modifier une simulation.

🔹 2. Module de saisie des critères

Rôle

  • Collecter les paramètres structurants du besoin.

Fonctions

  • Formulaires dynamiques (listes déroulantes, champs conditionnels).
  • Logique de dépendance entre critères (ex. stade ⇄ type de dispositif).
  • Aide contextuelle (définitions, exemples).

Types de critères (exemples)

  • Profil entreprise (taille, ancienneté, maturité).
  • Secteur / filière.
  • Localisation.
  • Type de projet.
  • Besoin principal (financement, accompagnement, structuration, marché…).

🔹 3. Module de normalisation et contrôle

Rôle

  • Garantir l’exploitabilité des données saisies.

Fonctions

  • Vérification de complétude.
  • Normalisation des valeurs (référentiels métiers).
  • Gestion des cas limites (informations partielles).

➡️ Brique clé pour éviter les erreurs de Matching.


🔹 4. Moteur de règles / Matching

Rôle

  • Cœur logique de l’outil.

Fonctions

  • Comparaison critères utilisateur ↔ critères d’éligibilité des dispositifs.
  • Application de règles métiers :
    • éligible / non éligible,
    • éligible sous conditions,
    • prioritaire / secondaire.
  • Gestion de règles cumulatives ou exclusives.

Sorties

  • Liste des dispositifs pertinents.
  • Niveau de correspondance / pertinence.

🔹 5. Base des dispositifs & processus

Rôle

  • Référentiel central de connaissance.

Contenu

  • Fiches dispositifs :
    • objectifs,
    • critères d’éligibilité,
    • périmètre (géographique, sectoriel),
    • typologie d’accompagnement.
  • Fiches processus :
    • étapes de candidature,
    • pièces attendues,
    • délais,
    • calendriers,
    • points de contact / liens.

Caractéristiques

  • Données versionnées.
  • Mise à jour simplifiée (back-office).

🔹 6. Génération des résultats

Rôle

  • Transformer l’analyse en information actionnable.

Fonctions

  • Agrégation des résultats par utilisateur.
  • Hiérarchisation des dispositifs.
  • Association automatique dispositif ↔ parcours.

🔹 7. Restitution & orientation

Rôle

  • Passage à l’action.

Fonctions

  • Restitution lisible :
    • dispositifs recommandés,
    • conditions clés,
    • prochaines étapes.
  • Accès direct :
    • lien candidature,
    • checklist des pièces,
    • contact référent.
  • Export possible (PDF, lien partageable, Excel).

3️⃣ Flux fonctionnel résumé (end-to-end)

Utilisateur
   ↓
Saisie des critères
   ↓
Normalisation des données
   ↓
Analyse via moteur de règles
   ↓
Identification des dispositifs
   ↓
Association des processus
   ↓
Restitution + orientation actionnable

4️⃣ Points clés pour cadrage IT

  • Séparation Front / Logique métier / Référentiels.
  • Moteur de règles évolutif (ajout/modification de dispositifs).
  • Gouvernance claire des données (qui met à jour quoi).
  • Scalabilité (nouveaux dispositifs sans refonte).

🛠️ Back‑office – Gestion des dispositifs d’accompagnement

1️⃣ Objectif du back‑office

Mettre à disposition des administrateurs un environnement dédié permettant :

  • de créer, modifier, activer ou désactiver des dispositifs d’accompagnement,
  • de gérer leurs critères d’éligibilité et leurs parcours associés,
  • de garantir la fiabilité des résultats produits par le moteur de règles.

2️⃣ Profils utilisateurs (rôles fonctionnels)

Rôle Droits principaux
Administrateur global Gestion complète (dispositifs, règles, référentiels)
Contributeur métier Création / mise à jour de dispositifs
Lecteur Consultation (audit, contrôle)

3️⃣ Briques fonctionnelles du back‑office

🔹 1. Gestion du référentiel des dispositifs

Fonctions

  • Création d’une fiche dispositif.
  • Modification / mise à jour.
  • Activation / désactivation (visibilité front).
  • Historisation des versions.

Données principales

  • Nom du dispositif.
  • Type (financier, accompagnement, mixte).
  • Porteur (institution, acteur public/privé).
  • Périmètre géographique.
  • Description courte / longue.

🔹 2. Gestion des critères d’éligibilité

Fonctions

  • Association de critères à chaque dispositif.
  • Paramétrage fin des règles :
    • obligatoire / optionnel,
    • valeurs acceptées,
    • seuils / exclusions.
  • Gestion de dépendances entre critères.

Exemples

  • Taille d’entreprise ≥ X.
  • Stade = création / amorçage / croissance.
  • Secteur inclus / exclus.
  • Localisation obligatoire.

➡️ Correspondance directe avec le moteur de règles.


🔹 3. Gestion des processus de candidature / soumission

Fonctions

  • Création d’un parcours par dispositif.
  • Décomposition en étapes successives.
  • Paramétrage des attendus par étape.

Éléments gérés

  • Étapes (pré‑qualification, dépôt, instruction…).
  • Pièces à fournir.
  • Délais et calendriers.
  • Liens externes (plateforme, formulaire).
  • Contact référent.

🔹 4. Référentiels communs (brique transverse)

Fonctions

  • Gestion des référentiels utilisés dans la saisie :
    • secteurs,
    • typologies de projets,
    • stades de maturité,
    • zones géographiques.
  • Harmonisation des valeurs (normalisation).

➡️ Condition nécessaire pour un matching fiable.


🔹 5. Moteur de règles – paramétrage métier

Fonctions

  • Définition des règles d’éligibilité :
    • règles simples (conditionnelles),
    • règles cumulatives,
    • règles d’exclusion.
  • Pondération éventuelle (scoring).
  • Test des règles sur cas simulés.

Objectif

  • Permettre l’évolution des dispositifs sans développement lourd.

🔹 6. Outils de contrôle & supervision

Fonctions

  • Visualisation des dispositifs actifs/inactifs.
  • Détection des incohérences :
    • critères non mappés,
    • parcours incomplets,
    • règles contradictoires.
  • Logs de modification (qui / quand / quoi).

🔹 7. Publication & synchronisation Front‑Office

Fonctions

  • Validation finale avant mise en production.
  • Publication immédiate ou planifiée.
  • Synchronisation avec le front‑office.

4️⃣ Schéma fonctionnel du back‑office

Administrateur / Métier
        │
        ▼
Back-office
 ├─ Gestion des dispositifs
 ├─ Gestion des critères
 ├─ Gestion des processus
 ├─ Référentiels communs
 ├─ Paramétrage règles
 ├─ Contrôle / audit
        │
        ▼
Moteur de règles
        │
        ▼
Front-office (outil utilisateur)

5️⃣ Points clés de conception IT

  • Séparation stricte :
    • données dispositifs,
    • règles métier,
    • référentiels.
  • Versionnement obligatoire.
  • Sécurisation des droits.
  • Back‑office pensé métier-first, non technique.

6️⃣ Périmètre MVP recommandé

✅ Création / modification de dispositifs
✅ Paramétrage critères simples
✅ Parcours de candidature basique
✅ Activation / désactivation
✅ Publication front


📄 Fiche dispositif – Exemple paramétré (Back‑office)

1️⃣ Identification du dispositif

  • Nom du dispositif : Programme d’Accompagnement Innovation – Phase Amorçage
  • Type : Accompagnement (non financier)
  • Porteur : Acteur public national
  • Statut : ✅ Actif
  • Visibilité front-office : ✅ Oui
  • Version : v1.2
  • Date de dernière mise à jour : JJ/MM/AAAA

2️⃣ Description métier

  • Objectif
    Accompagner les entreprises innovantes en phase d’amorçage dans la structuration de leur projet et la préparation à une levée de fonds.
  • Bénéfices clés
    • Accompagnement stratégique
    • Mise en réseau
    • Aide à la structuration financière
  • Durée de l’accompagnement
    6 à 9 mois

3️⃣ Critères d’éligibilité (paramétrage)

🔹 Profil entreprise

Critère Type Règle
Forme juridique Liste Doit être une personne morale
Ancienneté Numérique ≤ 5 ans
Effectif Numérique ≤ 50 salariés

🔹 Stade et maturité

Critère Type Valeurs autorisées
Stade de développement Liste Amorçage
Maturité projet Liste Prototype / POC

🔹 Secteur d’activité

Critère Type Règle
Secteur Multi‑sélection Tous sauf secteurs exclus
Secteurs exclus Liste Immobilier, financement pur

🔹 Localisation

Critère Type Règle
Implantation Géographique France obligatoire

🔹 Besoins exprimés

Critère Type Règle
Besoin principal Liste Structuration / Levée de fonds
Besoin secondaire Optionnel Mise en relation

4️⃣ Règles métier associées (moteur de règles)

  • Éligible si
    • ancienneté ≤ 5 ans
    • stade = amorçage
    • secteur non exclu
    • localisation = France
  • ⚠️ Éligible sous conditions si
    • maturité = idée avancée (sans prototype)
  • Non éligible si
    • stade ≥ croissance
    • activité exclue

5️⃣ Pondération / priorité (optionnel)

  • Stade = amorçage → +40
  • Besoin levée de fonds → +30
  • Secteur prioritaire → +20

➡️ Score de pertinence calculé automatiquement


6️⃣ Processus de candidature associé

🔹 Parcours étapes

  1. Pré‑qualification en ligne
  2. Dépôt du dossier
  3. Instruction
  4. Comité de sélection
  5. Notification de décision

🔹 Pièces à fournir

  • Pitch deck
  • Note projet
  • Prévisionnel financier
  • Kbis / statuts

🔹 Délais indicatifs

  • Instruction : 3 à 4 semaines
  • Comité : mensuel

🔹 Point d’entrée

  • Lien candidature : URL externe
  • Contact référent : nom / mail générique

7️⃣ Paramètres de publication

  • Visible pour :
    • ✅ Entreprises
    • ✅ Conseillers
  • Date d’effet : immédiate
  • Archivage automatique : non

8️⃣ Logs & gouvernance

  • Créé par : Administrateur X
  • Modifié par : Contributeur Y
  • Historique versions : consultable

🧠 Ce que voit le moteur de règles

  • Critères structurés
  • Règles explicites
  • Parcours opérationnel attaché
  • Résultat immédiatement actionnable côté front

🧱 Modèle de données – Fiche Dispositif

1️⃣ Entité centrale : DISPOSITIF

DISPOSITIF
──────────
- dispositif_id (PK)
- nom
- type_dispositif
- porteur
- description_courte
- description_longue
- statut (actif / inactif / archive)
- date_effet
- date_fin
- version
- date_creation
- date_maj

Rôle

Représente un dispositif d’accompagnement unique, identifiable et versionné.


2️⃣ Critères & éligibilité

🔹 2.1 Entité CRITERE

CRITERE
───────
- critere_id (PK)
- code_critere
- libelle
- type_donnee (liste, numerique, booléen, texte)
- referentiel_associe (optionnel)

Rôle

Décrit un critère standard utilisable par plusieurs dispositifs
(ex. stade, secteur, effectif, localisation).


🔹 2.2 Association DISPOSITIF_CRITERE

DISPOSITIF_CRITERE
─────────────────
- dispositif_critere_id (PK)
- dispositif_id (FK)
- critere_id (FK)
- obligatoire (bool)
- valeur_min (optionnel)
- valeur_max (optionnel)
- valeurs_autorisees (liste)
- condition_logique (AND / OR / EXCLUSION)

Rôle

Paramétrage spécifique des critères pour un dispositif donné.

➡️ C’est ici que vit l’éligibilité métier.


3️⃣ Règles métier (moteur de matching)

🔹 Entité REGLE_ELIGIBILITE

REGLE_ELIGIBILITE
────────────────
- regle_id (PK)
- dispositif_id (FK)
- type_regle (eligibilite / exclusion / conditionnelle)
- expression_logique
- resultat (eligible / non_eligible / eligible_sous_condition)
- priorite

Rôle

Permet d’exprimer des règles complexes sans code
(ex. combinaisons de critères, exclusions sectorielles).


4️⃣ Pondération / scoring (optionnel mais structurant)

🔹 Entité PONDERATION

PONDERATION
───────────
- ponderation_id (PK)
- dispositif_id (FK)
- critere_id (FK)
- valeur_score

Rôle

Calcul d’un score de pertinence pour hiérarchiser les dispositifs.


5️⃣ Processus de candidature

🔹 5.1 Entité PROCESSUS

PROCESSUS
──────────
- processus_id (PK)
- dispositif_id (FK)
- libelle
- description

Rôle

Un dispositif peut avoir un processus principal
(+ éventuellement des variantes).


🔹 5.2 Entité ETAPE_PROCESSUS

ETAPE_PROCESSUS
───────────────
- etape_id (PK)
- processus_id (FK)
- ordre
- libelle
- description
- delai_indicatif

🔹 5.3 Entité PIECE_A_FOURNIR

PIECE_A_FOURNIR
───────────────
- piece_id (PK)
- etape_id (FK)
- libelle
- obligatoire (bool)

🔹 5.4 Entité POINT_ENTREE

POINT_ENTREE
────────────
- point_entree_id (PK)
- processus_id (FK)
- type (URL / contact / plateforme)
- valeur

6️⃣ Référentiels transverses

Exemples d’entités de référence :

REFERENTIEL_SECTEUR
REFERENTIEL_STADE
REFERENTIEL_TERRITOIRE
REFERENTIEL_TYPE_PROJET

Chaque entité contient :

- code
- libelle
- actif

➡️ Utilisées par CRITERE et le front.


7️⃣ Gouvernance & traçabilité

🔹 Entité HISTORIQUE_MODIFICATION

HISTORIQUE_MODIFICATION
──────────────────────
- historique_id (PK)
- entite
- entite_id
- action (creation / modification / suppression)
- utilisateur
- date_action
- version

8️⃣ Vue logique simplifiée (relations clés)

DISPOSITIF
 ├─ DISPOSITIF_CRITERE ─ CRITERE
 ├─ REGLE_ELIGIBILITE
 ├─ PONDERATION
 └─ PROCESSUS
        ├─ ETAPE_PROCESSUS
        │      └─ PIECE_A_FOURNIR
        └─ POINT_ENTREE

🧠 Lecture métier

  • DISPOSITIF = objet pivot
  • CRITERE + REGLE = moteur d’éligibilité
  • PROCESSUS + ETAPES = parcours utilisateur
  • REFERENTIELS = cohérence et maintenabilité
  • HISTORIQUE = auditabilité

🗄️ Schéma relationnel SQL – Fiche Dispositif


1️⃣ Table centrale : dispositif

SQL
CREATE TABLE dispositif (
dispositif_id BIGINT PRIMARY KEY,
nom VARCHAR(255) NOT NULL,
type_dispositif VARCHAR(50) NOT NULL,
porteur VARCHAR(255),
description_courte VARCHAR(500),
description_longue TEXT,
statut VARCHAR(20) NOT NULL, — actif / inactif / archive
date_effet DATE,
date_fin DATE,
version VARCHAR(20),
date_creation TIMESTAMP NOT NULL,
date_maj TIMESTAMP
);

2️⃣ Critères et éligibilité

🔹 2.1 Référentiel des critères : critere

SQL
CREATE TABLE critere (
critere_id BIGINT PRIMARY KEY,
code_critere VARCHAR(100) UNIQUE NOT NULL,
libelle VARCHAR(255) NOT NULL,
type_donnee VARCHAR(30) NOT NULL, — liste, numerique, booleen, texte
referentiel_associe VARCHAR(100)
);

🔹 2.2 Paramétrage des critères par dispositif : dispositif_critere

SQL
CREATE TABLE dispositif_critere (
dispositif_critere_id BIGINT PRIMARY KEY,
dispositif_id BIGINT NOT NULL,
critere_id BIGINT NOT NULL,
obligatoire BOOLEAN DEFAULT FALSE,
valeur_min NUMERIC,
valeur_max NUMERIC,
valeurs_autorisees TEXT, — JSON ou liste sérialisée
condition_logique VARCHAR(20), — AND / OR / EXCLUSION
CONSTRAINT fk_dc_dispositif
FOREIGN KEY (dispositif_id) REFERENCES dispositif(dispositif_id),
CONSTRAINT fk_dc_critere
FOREIGN KEY (critere_id) REFERENCES critere(critere_id)
);

3️⃣ Règles métier (moteur de matching)

SQL
CREATE TABLE regle_eligibilite (
regle_id BIGINT PRIMARY KEY,
dispositif_id BIGINT NOT NULL,
type_regle VARCHAR(30) NOT NULL, — eligibilite / exclusion / conditionnelle
expression_logique TEXT NOT NULL,
resultat VARCHAR(30) NOT NULL, — eligible / non_eligible / sous_condition
priorite INT,
CONSTRAINT fk_regle_dispositif
FOREIGN KEY (dispositif_id) REFERENCES dispositif(dispositif_id)
);

4️⃣ Pondération / scoring (optionnel)

SQL
CREATE TABLE ponderation (
ponderation_id BIGINT PRIMARY KEY,
dispositif_id BIGINT NOT NULL,
critere_id BIGINT NOT NULL,
valeur_score INT NOT NULL,
CONSTRAINT fk_pond_dispositif
FOREIGN KEY (dispositif_id) REFERENCES dispositif(dispositif_id),
CONSTRAINT fk_pond_critere
FOREIGN KEY (critere_id) REFERENCES critere(critere_id)
);

5️⃣ Processus de candidature

🔹 5.1 Processus principal

SQL
CREATE TABLE processus (
processus_id BIGINT PRIMARY KEY,
dispositif_id BIGINT NOT NULL,
libelle VARCHAR(255) NOT NULL,
description TEXT,
CONSTRAINT fk_processus_dispositif
FOREIGN KEY (dispositif_id) REFERENCES dispositif(dispositif_id)
);

🔹 5.2 Étapes du processus

SQL
CREATE TABLE etape_processus (
etape_id BIGINT PRIMARY KEY,
processus_id BIGINT NOT NULL,
ordre_etape INT NOT NULL,
libelle VARCHAR(255) NOT NULL,
description TEXT,
delai_indicatif VARCHAR(100),
CONSTRAINT fk_etape_processus
FOREIGN KEY (processus_id) REFERENCES processus(processus_id)
);

🔹 5.3 Pièces à fournir

SQL
CREATE TABLE piece_a_fournir (
piece_id BIGINT PRIMARY KEY,
etape_id BIGINT NOT NULL,
libelle VARCHAR(255) NOT NULL,
obligatoire BOOLEAN DEFAULT TRUE,
CONSTRAINT fk_piece_etape
FOREIGN KEY (etape_id) REFERENCES etape_processus(etape_id)
);

🔹 5.4 Points d’entrée (liens / contacts)

SQL
CREATE TABLE point_entree (
point_entree_id BIGINT PRIMARY KEY,
processus_id BIGINT NOT NULL,
type_point VARCHAR(30) NOT NULL, — URL / contact / plateforme
valeur VARCHAR(500) NOT NULL,
CONSTRAINT fk_point_processus
FOREIGN KEY (processus_id) REFERENCES processus(processus_id)
);

6️⃣ Référentiels métiers (exemple)

SQL
CREATE TABLE referentiel_secteur (
code_secteur VARCHAR(50) PRIMARY KEY,
libelle VARCHAR(255),
actif BOOLEAN DEFAULT TRUE
);

(Même logique pour stade, territoire, type_projet, etc.)


7️⃣ Gouvernance & audit

SQL
CREATE TABLE historique_modification (
historique_id BIGINT PRIMARY KEY,
entite VARCHAR(100) NOT NULL,
entite_id BIGINT NOT NULL,
action VARCHAR(30) NOT NULL, — creation / modification / suppression
utilisateur VARCHAR(255),
date_action TIMESTAMP NOT NULL,
version VARCHAR(20)
);

8️⃣ Vue relationnelle synthétique

dispositif
 ├─ dispositif_critere ─ critere
 ├─ regle_eligibilite
 ├─ ponderation
 └─ processus
        ├─ etape_processus
        │      └─ piece_a_fournir
        └─ point_entree

✅ Points forts du schéma

  • Compatible moteur de règles évolutif
  • Back‑office sans dépendance code
  • Traçabilité complète
  • Facilement sérialisable en JSON / API

📦 Exemple de données INSERT

Dispositif réel‑type : Aide à l’Innovation – Subvention Faisabilité


1️⃣ Dispositif

SQL
INSERT INTO dispositif (
dispositif_id, nom, type_dispositif, porteur,
description_courte, description_longue,
statut, date_effet, version, date_creation
) VALUES (
2,
‘Aide à l’Innovation – Faisabilité’,
‘Financier’,
‘Bpifrance’,
‘Subvention pour études de faisabilité de projets innovants’,
‘Dispositif visant à soutenir financièrement les entreprises dans la phase amont de leurs projets innovants (études techniques, économiques et commerciales) avant un développement plus industriel.’,
‘actif’,
‘2025-01-01’,
‘v1.0’,
CURRENT_TIMESTAMP
);

2️⃣ Critères utilisés (réutilisation possible d’un référentiel commun)

(Supposés déjà existants en base)

SQL
INSERT INTO critere (critere_id, code_critere, libelle, type_donnee) VALUES
(10, ‘taille_entreprise’, ‘Taille de l’entreprise’, ‘liste’),
(11, ‘anciennete’, ‘Ancienneté de l’entreprise (années)’, ‘numerique’),
(12, ‘type_projet’, ‘Type de projet’, ‘liste’),
(13, ‘localisation’, ‘Localisation géographique’, ‘liste’),
(14, ‘depenses_eligibles’, ‘Nature des dépenses’, ‘liste’);

3️⃣ Paramétrage de l’éligibilité

SQL
INSERT INTO dispositif_critere (
dispositif_critere_id, dispositif_id, critere_id,
obligatoire, valeur_min, valeur_max, valeurs_autorisees
) VALUES
— Taille : PME uniquement
(20, 2, 10, TRUE, NULL, NULL, ‘TPE,PME’),
— Ancienneté : pas de minimum
(21, 2, 11, TRUE, 0, NULL, NULL),
— Type de projet
(22, 2, 12, TRUE, NULL, NULL, ‘innovation_tech,innovation_usage’),
— Localisation France
(23, 2, 13, TRUE, NULL, NULL, ‘France’),
— Dépenses éligibles
(24, 2, 14, TRUE, NULL, NULL, ‘etudes,prestations_externes,prototype_amont’);

4️⃣ Règles d’éligibilité métier

SQL
INSERT INTO regle_eligibilite (
regle_id, dispositif_id, type_regle,
expression_logique, resultat, priorite
) VALUES
(
2,
2,
‘eligibilite’,
‘taille_entreprise IN (« TPE », »PME »)
AND type_projet IN (« innovation_tech », »innovation_usage »)
AND localisation = « France »‘,
‘eligible’,
1
);

5️⃣ Pondération (hiérarchisation des résultats)

SQL
INSERT INTO ponderation (
ponderation_id, dispositif_id, critere_id, valeur_score
) VALUES
(10, 2, 12, 40), — type de projet innovant
(11, 2, 14, 30), — dépenses d’études
(12, 2, 10, 20); — PME

6️⃣ Processus de candidature

🔹 Processus

SQL
INSERT INTO processus (
processus_id, dispositif_id, libelle, description
) VALUES (
2,
2,
‘Demande Aide Innovation – Faisabilité’,
‘Processus de demande de subvention incluant instruction technique et financière.’
);

🔹 Étapes

SQL
INSERT INTO etape_processus (
etape_id, processus_id, ordre_etape,
libelle, description, delai_indicatif
) VALUES
(20, 2, 1, ‘Dépôt de la demande’, ‘Dossier déposé sur la plateforme Bpifrance’, ‘à tout moment’),
(21, 2, 2, ‘Instruction’, ‘Analyse technique et financière’, ‘4 à 6 semaines’),
(22, 2, 3, ‘Décision’, ‘Notification officielle’, ‘après instruction’);

🔹 Pièces à fournir

SQL
INSERT INTO piece_a_fournir (
piece_id, etape_id, libelle, obligatoire
) VALUES
(20, 20, ‘Note de présentation du projet’, TRUE),
(21, 20, ‘Budget prévisionnel’, TRUE),
(22, 20, ‘Planning prévisionnel’, TRUE),
(23, 20, ‘Kbis’, TRUE);

🔹 Point d’entrée

SQL
INSERT INTO point_entree (
point_entree_id, processus_id, type_point, valeur
) VALUES
(
2,
2,
‘URL’,
‘https://www.bpifrance.fr/catalogue-offres/aide-a-l-innovation’
);

✅ Ce que montre cet exemple

  • Dispositif réel et identifiable
  • Critères pragmatiques, tels qu’utilisés par les entreprises
  • Parcours de candidature fidèle à la réalité terrain
  • Parfait pour :
    • démo outil,
    • POC IT,
    • discussion métier / partenaires,
    • comité projets.

requête SQL de matching entreprise → dispositifs

✅ 1) Matching “strict” (tous critères obligatoires OK) — SQL Server

SQL
/* ============================================================
INPUT ENTREPRISE (à remplacer par tes valeurs / ou une table)
============================================================ */
WITH entreprise_val AS (
SELECT *
FROM (VALUES
(‘anciennete’, CAST(3 AS decimal(10,2)), NULL),
(‘effectif’, CAST(20 AS decimal(10,2)), NULL),
(‘taille_entreprise’,NULL, ‘PME’),
(‘stade’, NULL, ‘amorçage’),
(‘localisation’, NULL, ‘France’),
(‘type_projet’, NULL, ‘innovation_tech’),
(‘secteur’, NULL, ‘software’),
(‘besoin_principal’, NULL, ‘levee_fonds’)
) v(code_critere, valeur_num, valeur_txt)
),
/* mappe l’input sur les critere_id */
ev AS (
SELECT
c.critere_id,
c.code_critere,
c.type_donnee,
v.valeur_num,
v.valeur_txt
FROM entreprise_val v
JOIN critere c
ON c.code_critere = v.code_critere
),
/* ============================================================
EVALUATION CRITERE PAR DISPOSITIF
============================================================ */
dc_eval AS (
SELECT
dc.dispositif_id,
dc.dispositif_critere_id,
dc.obligatoire,
c.type_donnee,
ev.valeur_num,
ev.valeur_txt,
dc.valeur_min,
dc.valeur_max,
dc.valeurs_autorisees,
dc.condition_logique,
CASE
/* — Critères numériques — */
WHEN c.type_donnee = ‘numerique’ THEN
CASE
WHEN ev.valeur_num IS NULL THEN 0
WHEN (dc.valeur_min IS NULL OR ev.valeur_num >= dc.valeur_min)
AND (dc.valeur_max IS NULL OR ev.valeur_num <= dc.valeur_max)
THEN 1 ELSE 0
END
/* — Critères liste (CSV) — */
WHEN c.type_donnee = ‘liste’ THEN
CASE
WHEN ev.valeur_txt IS NULL THEN 0
WHEN dc.valeurs_autorisees IS NULL OR LTRIM(RTRIM(dc.valeurs_autorisees)) =  » THEN 1
WHEN dc.condition_logique = ‘EXCLUSION’ THEN
CASE
WHEN EXISTS (
SELECT 1
FROM STRING_SPLIT(dc.valeurs_autorisees, ‘,’) s
WHERE LTRIM(RTRIM(s.value)) = ev.valeur_txt
)
THEN 0 ELSE 1
END
ELSE
CASE
WHEN EXISTS (
SELECT 1
FROM STRING_SPLIT(dc.valeurs_autorisees, ‘,’) s
WHERE LTRIM(RTRIM(s.value)) = ev.valeur_txt
)
THEN 1 ELSE 0
END
END
/* — Autres types (à compléter si besoin) — */
ELSE 0
END AS is_ok
FROM dispositif_critere dc
JOIN critere c
ON c.critere_id = dc.critere_id
LEFT JOIN ev
ON ev.critere_id = dc.critere_id
)
/* ============================================================
RESULTAT : DISPOSITIFS MATCHES (tous obligatoires OK)
============================================================ */
SELECT
d.dispositif_id,
d.nom,
d.type_dispositif,
d.porteur
FROM dispositif d
JOIN dc_eval e
ON e.dispositif_id = d.dispositif_id
WHERE d.statut = ‘actif’
GROUP BY d.dispositif_id, d.nom, d.type_dispositif, d.porteur
HAVING
SUM(CASE WHEN e.obligatoire = 1 THEN 1 ELSE 0 END)
= SUM(CASE WHEN e.obligatoire = 1 AND e.is_ok = 1 THEN 1 ELSE 0 END)
ORDER BY d.nom;

✅ Ce que renvoie la requête

  • uniquement les dispositifs dont tous les critères obligatoires sont satisfaits
  • elle ignore les critères non présents dans l’input uniquement s’ils ne sont pas obligatoires (sinon ça bloque, ce qui est logique).

➕ 2) Variante : ramener aussi le “processus” (étapes + lien)

Tu peux chaîner ensuite (ou intégrer via LEFT JOIN) :

SQL
SELECT
m.dispositif_id,
m.nom,
p.processus_id,
p.libelle AS processus_libelle,
pe.type_point,
pe.valeur AS point_entree,
ep.ordre_etape,
ep.libelle AS etape_libelle,
ep.delai_indicatif
FROM (
/* mettre ici la requête de matching précédente,
ou la transformer en CTE nommé « match » */
SELECT d.dispositif_id, d.nom
FROM dispositif d
JOIN dc_eval e ON e.dispositif_id = d.dispositif_id
WHERE d.statut = ‘actif’
GROUP BY d.dispositif_id, d.nom
HAVING SUM(CASE WHEN e.obligatoire = 1 THEN 1 ELSE 0 END)
= SUM(CASE WHEN e.obligatoire = 1 AND e.is_ok = 1 THEN 1 ELSE 0 END)
) m
LEFT JOIN processus p ON p.dispositif_id = m.dispositif_id
LEFT JOIN point_entree pe ON pe.processus_id = p.processus_id
LEFT JOIN etape_processus ep ON ep.processus_id = p.processus_id
ORDER BY m.nom, ep.ordre_etape;

Code PHP 7.4 pour la page de saisie des paramètres et injection dans la base MYSQL

1️⃣ Modèle minimal côté base MySQL

Table entreprise

SQL
CREATE TABLE entreprise (
entreprise_id BIGINT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(255) NOT NULL,
date_creation TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Table valeurs de critères entreprise

SQL
CREATE TABLE entreprise_critere (
entreprise_critere_id BIGINT AUTO_INCREMENT PRIMARY KEY,
entreprise_id BIGINT NOT NULL,
critere_code VARCHAR(100) NOT NULL,
valeur_num DECIMAL(10,2) NULL,
valeur_txt VARCHAR(255) NULL,
FOREIGN KEY (entreprise_id) REFERENCES entreprise(entreprise_id)
);

➡️ On stocke numérique OU texte, exactement comme côté matching.


2️⃣ Page HTML – Saisie des paramètres (entreprise_form.php)

PHP
<!DOCTYPE html>
<html lang= »fr »>
<head>
<meta charset= »UTF-8″>
<title>Saisie entreprise</title>
</head>
<body>
<h2>Paramètres de l’entreprise</h2>
<form method= »post » action= »entreprise_save.php »>
<label>Nom de l’entreprise</label><br>
<input type= »text » name= »nom » required><br><br>
<label>Ancienneté (années)</label><br>
<input type= »number » name= »anciennete » min= »0″><br><br>
<label>Effectif</label><br>
<input type= »number » name= »effectif » min= »0″><br><br>
<label>Taille entreprise</label><br>
<select name= »taille_entreprise »>
<option value= » »>–</option>
<option value= »TPE »>TPE</option>
<option value= »PME »>PME</option>
<option value= »ETI »>ETI</option>
</select><br><br>
<label>Stade</label><br>
<select name= »stade »>
<option value= » »>–</option>
<option value= »amorçage »>Amorçage</option>
<option value= »creation »>Création</option>
<option value= »croissance »>Croissance</option>
</select><br><br>
<label>Localisation</label><br>
<select name= »localisation »>
<option value= »France »>France</option>
<option value= »UE »>UE</option>
<option value= »Hors UE »>Hors UE</option>
</select><br><br>
<label>Type de projet</label><br>
<select name= »type_projet »>
<option value= » »>–</option>
<option value= »innovation_tech »>Innovation technologique</option>
<option value= »innovation_usage »>Innovation usage</option>
</select><br><br>
<label>Besoin principal</label><br>
<select name= »besoin_principal »>
<option value= » »>–</option>
<option value= »levee_fonds »>Levée de fonds</option>
<option value= »structuration »>Structuration</option>
</select><br><br>
<button type= »submit »>Enregistrer</button>
</form>
</body>
</html>

3️⃣ Traitement PHP – Insertion en base (entreprise_save.php)

PHP
<?php
declare(strict_types=1);
// Connexion PDO
$pdo = new PDO(
‘mysql:host=localhost;dbname=dispositifs;charset=utf8’,
‘user’,
‘password’,
[
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
]
);
// Sécurisation basique
$nom = trim($_POST[‘nom’] ??  »);
if ($nom ===  ») {
die(‘Nom entreprise obligatoire’);
}
// 1️⃣ Insertion entreprise
$stmtEntreprise = $pdo->prepare(
« INSERT INTO entreprise (nom) VALUES (:nom) »
);
$stmtEntreprise->execute([‘:nom’ => $nom]);
$entrepriseId = (int) $pdo->lastInsertId();
// 2️⃣ Mapping critères → valeurs
$criteres = [
‘anciennete’ => [‘type’ => ‘num’],
‘effectif’ => [‘type’ => ‘num’],
‘taille_entreprise’ => [‘type’ => ‘txt’],
‘stade’ => [‘type’ => ‘txt’],
‘localisation’ => [‘type’ => ‘txt’],
‘type_projet’ => [‘type’ => ‘txt’],
‘besoin_principal’ => [‘type’ => ‘txt’]
];
// 3️⃣ Insertion des critères
$stmtCritere = $pdo->prepare(
« INSERT INTO entreprise_critere
(entreprise_id, critere_code, valeur_num, valeur_txt)
VALUES (:entreprise_id, :critere_code, :valeur_num, :valeur_txt) »
);
foreach ($criteres as $code => $config) {
if (!isset($_POST[$code]) || $_POST[$code] ===  ») {
continue;
}
$valeurNum = null;
$valeurTxt = null;
if ($config[‘type’] === ‘num’) {
$valeurNum = (float) $_POST[$code];
} else {
$valeurTxt = trim($_POST[$code]);
}
$stmtCritere->execute([
‘:entreprise_id’ => $entrepriseId,
‘:critere_code’ => $code,
‘:valeur_num’ => $valeurNum,
‘:valeur_txt’ => $valeurTxt
]);
}
echo « Entreprise enregistrée (ID {$entrepriseId}) »;

4️⃣ Ce que tu obtiens immédiatement

✅ Une structure générique compatible avec le moteur de matching SQL
✅ Une page de saisie simple (remplaçable par React / Vue plus tard)
✅ Aucune logique métier codée en dur
✅ Aligné avec :

  • critere.code_critere
  • dispositif_critere
  • regle_eligibilite

PHP pour appeler la requête de matching et afficher les dispositifs

✅ lire les critères d’une entreprise stockés en base

✅ appeler la requête SQL de matching entreprise → dispositifs
✅ afficher les dispositifs éligibles + processus associé

Le code est pensé MVP / POC, clair, maintenable, et directement branchable sur ce qu’on a déjà construit.


1️⃣ Hypothèses (rappel cohérent avec ce qu’on a fait)

Tables utilisées

  • entreprise
  • entreprise_critere
  • dispositif
  • dispositif_critere
  • critere
  • processus
  • etape_processus
  • point_entree

👉 Le matching s’appuie uniquement sur les critères obligatoires.


2️⃣ Script PHP : matching + affichage

📄 matching_dispositifs.php

PHP
<?php
declare(strict_types=1);
/* ===============================
CONNEXION BDD
=============================== */
$pdo = new PDO(
‘mysql:host=localhost;dbname=dispositifs;charset=utf8’,
‘user’,
‘password’,
[PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);
/* ===============================
ENTREPRISE CIBLE
=============================== */
$entrepriseId = (int) ($_GET[‘entreprise_id’] ?? 0);
if ($entrepriseId <= 0) {
die(‘Entreprise non valide’);
}
/* ===============================
MATCHING SQL
=============================== */
$sql = « 
WITH ev AS (
SELECT
dc.dispositif_id,
dc.obligatoire,
c.type_donnee,
ec.valeur_num,
ec.valeur_txt,
dc.valeur_min,
dc.valeur_max,
dc.valeurs_autorisees,
dc.condition_logique,
CASE
— NUMERIQUE
WHEN c.type_donnee = ‘numerique’ THEN
CASE
WHEN ec.valeur_num IS NULL THEN 0
WHEN (dc.valeur_min IS NULL OR ec.valeur_num >= dc.valeur_min)
AND (dc.valeur_max IS NULL OR ec.valeur_num <= dc.valeur_max)
THEN 1 ELSE 0
END
— LISTE
WHEN c.type_donnee = ‘liste’ THEN
CASE
WHEN ec.valeur_txt IS NULL THEN 0
WHEN dc.valeurs_autorisees IS NULL OR dc.valeurs_autorisees =  » THEN 1
WHEN dc.condition_logique = ‘EXCLUSION’ THEN
CASE
WHEN FIND_IN_SET(ec.valeur_txt, dc.valeurs_autorisees) > 0
THEN 0 ELSE 1
END
ELSE
CASE
WHEN FIND_IN_SET(ec.valeur_txt, dc.valeurs_autorisees) > 0
THEN 1 ELSE 0
END
END
ELSE 0
END AS is_ok
FROM dispositif_critere dc
JOIN critere c ON c.critere_id = dc.critere_id
LEFT JOIN entreprise_critere ec
ON ec.critere_code = c.code_critere
AND ec.entreprise_id = :entreprise_id
)
SELECT
d.dispositif_id,
d.nom,
d.type_dispositif,
d.porteur,
p.processus_id,
p.libelle AS processus_libelle,
pe.valeur AS lien_candidature
FROM dispositif d
JOIN ev ON ev.dispositif_id = d.dispositif_id
LEFT JOIN processus p ON p.dispositif_id = d.dispositif_id
LEFT JOIN point_entree pe ON pe.processus_id = p.processus_id
AND pe.type_point = ‘URL’
WHERE d.statut = ‘actif’
GROUP BY d.dispositif_id
HAVING
SUM(CASE WHEN ev.obligatoire = 1 THEN 1 ELSE 0 END)
= SUM(CASE WHEN ev.obligatoire = 1 AND ev.is_ok = 1 THEN 1 ELSE 0 END)
ORDER BY d.nom
« ;
$stmt = $pdo->prepare($sql);
$stmt->execute([‘:entreprise_id’ => $entrepriseId]);
$dispositifs = $stmt->fetchAll(PDO::FETCH_ASSOC);

3️⃣ Affichage HTML simple (résultat métier lisible)

PHP
<!DOCTYPE html>
<html lang= »fr »>
<head>
<meta charset= »UTF-8″>
<title>Dispositifs éligibles</title>
<style>
body { font-family: Arial, sans-serif; }
.dispositif {
border: 1px solid #ccc;
padding: 12px;
margin-bottom: 10px;
}
.dispositif h3 { margin: 0; }
</style>
</head>
<body>
<h2>Dispositifs d’accompagnement éligibles</h2>
<?php if (empty($dispositifs)) : ?>
<p>Aucun dispositif éligible selon les critères renseignés.</p>
<?php else : ?>
<?php foreach ($dispositifs as $d) : ?>
<div class= »dispositif »>
<h3><?= htmlspecialchars($d[‘nom’]) ?></h3>
<p><strong>Type :</strong> <?= htmlspecialchars($d[‘type_dispositif’]) ?></p>
<p><strong>Porteur :</strong> <?= htmlspecialchars($d[‘porteur’]) ?></p>
<?php if (!empty($d[‘processus_libelle’])) : ?>
<p><strong>Processus :</strong> <?= htmlspecialchars($d[‘processus_libelle’]) ?></p>
<?php endif; ?>
<?php if (!empty($d[‘lien_candidature’])) : ?>
<p>
<a href= »<?= htmlspecialchars($d[‘lien_candidature’]) ?> » target= »_blank »>
Accéder à la candidature
</a>
</p>
<?php endif; ?>
</div>
<?php endforeach; ?>
<?php endif; ?>
</body>
</html>

4️⃣ Ce que fait exactement ce code

✔ charge les critères réels de l’entreprise
✔ applique les règles min / max / listes / exclusions
✔ filtre uniquement sur les critères obligatoires
✔ retourne des dispositifs actionnables (avec lien)
✔ prêt à être branché sur :

  • une page conseiller,
  • un parcours entreprise,
  • une API JSON.

 

🧩 User Stories – Outil d’orientation vers les dispositifs

👤 Persona 1 – Chargé d’affaires innovation (banque)

🎯 Contexte

Le chargé d’affaires accompagne des entreprises innovantes et doit :

  • identifier rapidement les dispositifs pertinents,
  • éviter les erreurs d’orientation,
  • apporter une valeur de conseil structurée.

US‑CA‑01 – Identifier les dispositifs éligibles

En tant que chargé d’affaires
Je veux saisir les paramètres clés d’une entreprise
Afin de obtenir automatiquement la liste des dispositifs d’accompagnement éligibles

✅ Critères saisis : taille, stade, secteur, localisation, besoins
✅ Résultat : liste filtrée de dispositifs


US‑CA‑02 – Comprendre le “pourquoi” de l’éligibilité

En tant que chargé d’affaires
Je veux visualiser les critères validés / bloquants
Afin de expliquer clairement le résultat au client

✅ Ex. : « Éligible car amorçage + PME + innovation tech »
✅ / « Non éligible car entreprise hors périmètre géographique »


US‑CA‑03 – Orienter vers l’action

En tant que chargé d’affaires
Je veux accéder directement au processus de candidature associé
Afin de guider le client sans perte de temps

✅ Étapes clés
✅ Pièces à fournir
✅ Lien vers la plateforme / contact


US‑CA‑04 – Gagner du temps en rendez‑vous

En tant que chargé d’affaires
Je veux disposer d’un outil simple utilisable en rendez‑vous client
Afin de produire une recommandation immédiate et fiable

✅ Utilisable en direct
✅ Résultat lisible en 1 écran


👤 Persona 2 – Dirigeant / fondateur d’entreprise

🎯 Contexte

Le dirigeant ne maîtrise pas l’écosystème des aides :

  • il ne sait pas à quoi il est éligible,
  • il perd du temps entre plateformes et acteurs.

US‑DIR‑01 – Se repérer dans les dispositifs

En tant que dirigeant
Je veux renseigner quelques informations sur mon entreprise
Afin de savoir rapidement quels dispositifs existent pour moi

✅ Pas de jargon
✅ Questions simples et guidées


US‑DIR‑02 – Éviter les candidatures inutiles

En tant que dirigeant
Je veux être orienté uniquement vers les dispositifs réellement accessibles
Afin de ne pas perdre de temps sur des dossiers voués au refus

✅ Filtrage strict
✅ Transparence des critères


US‑DIR‑03 – Passer rapidement à l’action

En tant que dirigeant
Je veux connaître précisément les étapes et documents requis
Afin de lancer ma candidature sans recherche complémentaire

✅ Checklist claire
✅ Délais indicatifs
✅ Accès direct aux points d’entrée


👤 Persona 3 – Accompagnateur / acteur de l’écosystème

🎯 Contexte

L’accompagnateur (incubateur, pépinière, cluster…) :

  • accompagne plusieurs entreprises simultanément,
  • doit orienter de manière cohérente et homogène.

US‑ACC‑01 – Standardiser l’orientation

En tant que accompagnateur
Je veux une grille objective de matching dispositifs ↔ entreprises
Afin de sécuriser mes recommandations

✅ Logique commune
✅ Alignement avec les critères officiels


US‑ACC‑02 – Maintenir l’outil à jour

En tant que accompagnateur référent
Je veux m’appuyer sur un référentiel central de dispositifs
Afin de éviter les informations obsolètes ou contradictoires

✅ Dispositifs versionnés
✅ Processus maintenus à jour via back‑office


US‑ACC‑03 – Accompagner dans le temps

En tant que accompagnateur
Je veux refaire le matching à différents stades de maturité
Afin de proposer de nouveaux dispositifs au bon moment

✅ Re‑simulation possible
✅ Approche parcours / cycle de vie


🧠 User Stories transverses (outil)

US‑SYS‑01 – Fiabilité des règles

En tant que utilisateur
Je veux que les règles d’éligibilité soient strictement appliquées
Afin de garantir la crédibilité de l’outil


US‑SYS‑02 – Évolutivité

En tant que administrateur
Je veux ajouter ou modifier des dispositifs sans développement lourd
Afin de garantir la pérennité de l’outil


🎯 User Stories prioritaires (MVP recommandé)

✅ US‑CA‑01
✅ US‑CA‑03
✅ US‑DIR‑01
✅ US‑DIR‑03
✅ US‑ACC‑01