Version intégrale, plus lourde à charger. Elle reste là pour imprimer le cours d’un seul tenant ou le lire linéairement. Revenir au sommaire.

Notes de terrain · édition 2026

L’Automatisation & Le Low-Code

Ce mémo vient d’un besoin simple : garder une trace utilisable de ce que j’apprends en construisant des automatisations, des agents et des outils internes. Il n’a pas la prétention d’être exhaustif. Il rassemble des explications, des exemples et des erreurs fréquentes, avec des chiffres et des licences datés pour que vous puissiez vérifier.

Les sujets bougent vite. Prenez ce qui vous sert, adaptez-le à votre contexte, et gardez un doute sur ce qui semble trop facile. Le but n’est pas de tout savoir, mais de savoir quoi regarder, quoi tester et quand demander de l’aide.

Les encadrés signalent une erreur fréquente, une nuance ou un point à vérifier. Les chiffres et les licences sont datés : recontrôlez-les avant une décision.

01

L’Écosystème 2026

No-Code, Low-Code & Vibe Coding

La première difficulté n’est pas de choisir un outil, c’est de comprendre ce que l’on essaie de faire. Un tableur, un formulaire et une API peuvent déjà résoudre une grande partie du problème. Le no-code et le low-code ne remplacent pas cette réflexion : ils changent le temps nécessaire pour la mettre à l’épreuve.

Ce module prend le temps de définir les mots et de montrer ce que chaque approche fait bien et ce qu’elle coûte. À la fin, vous devriez pouvoir regarder une demande et dire : voilà ce qui peut être automatisé simplement, voilà ce qui demande du code, et voilà ce qu’il vaut mieux ne pas automatiser.

Trois approches, trois compromis :
Le marché a mûri. On ne dit plus juste "No-Code". On distingue trois manières de construire, selon le besoin : la vitesse, le contrôle, ou l’assistance. Ce ne sont pas des niveaux de maturité, et l’un n’est pas "meilleur" que l’autre.

Prenons une association qui gère trois salles de réunion. Un formulaire no-code relié à une base Airtable ou NocoDB couvre probablement 80 % du besoin en une après-midi. Si les règles se compliquent (conflits de créneaux, tarifs selon les adhérents, facturation), il faudra peut-être passer à un workflow n8n et à une vraie base PostgreSQL. Si l’association veut ensuite une interface sur mesure, un développement assisté par IA peut devenir pertinent. Le bon outil dépend du lendemain, pas seulement de la démonstration.

Quatre questions suffisent souvent à trancher : à quelle fréquence la tâche se répète-t-elle ? combien de personnes doivent la maintenir ? quelles données sont manipulées, et où peuvent-elles vivre ? que se passe-t-il si l’outil disparaît ou augmente ses prix ?

A. Le No-Code (Visual First)

Philosophie : "Je vois ce que je construis." Idéal pour le Marketing, le Design et les MVP rapides. La barrière technique est nulle.

🛠 Quelques outils no-code représentatifs :

Webflow / Framer

Sites vitrines soignés, très utilisés par les designers.

Bubble

Applications web complètes : base de données, frontend et workflows tout-en-un.

Softr / Glide

Transformez un Airtable/Google Sheet en appli en 5 minutes.

Make / Zapier

Connecte des applications entre elles par des scénarios visuels.

VOCABULAIRE CLICABLE :

Ce que le no-code fait bien : livrer vite une interface claire, brancher des outils existants, faire tester une idée à de vraies personnes. Ce qu’il fait moins bien : les règles métier tordues, les volumes importants, les migrations de données et les intégrations qui doivent survivre à une panne. Le coût caché est souvent le prix par utilisateur, l’export limité et la dépendance à la plateforme.

B. Le Low-Code (Logic First)

Philosophie : "Je ne réinvente pas la roue, mais je veux du custom." Pour les DSI, les outils internes et le Backend robuste.

🛠 Quelques outils low-code représentatifs :

Appsmith / Retool

Dashboards admin & outils internes. On peut injecter du JS partout.

Supabase / Xano

"Backend as a Service". Base de données + Auth + API prêtes à l’emploi.

n8n

Automation complexe avec code Python/JS. Dockerisable.

FlutterFlow

Créez de vraies apps mobiles natives (iOS/Android) avec export de code.

VOCABULAIRE CLICABLE :

Ce que le low-code change : vous gardez la main sur le modèle de données et sur une partie du code, mais vous héritez aussi des mises à jour, des sauvegardes et des tests. C’est un bon compromis quand l’équipe a des compétences techniques, même limitées. Sans personne pour relire les scripts et les permissions, le low-code devient du code non maintenu avec une interface graphique.

C. Le Vibe Coding (AI First)

Philosophie : "L’anglais est le nouveau langage de programmation." Vous êtes l’architecte, l’IA est l’ouvrier.

🛠 Quelques outils de génération et d’assistance :

AI IDEs

• Cursor (très répandu)
• Devin Desktop (ex-Windsurf)
• Trae (autre option)
• Google Antigravity (Google)

Generators

• bolt.new (Full Stack)
• lovable.dev (SaaS fast)
• v0.dev (UI React/Tailwind)

Agents

• Claude Code (CLI Refactor)
• Replit Agent (Zero to Cloud)

VOCABULAIRE CLICABLE :

Ce que le vibe coding ne remplace pas : la spécification, la revue et les tests. Un modèle peut produire une application qui démarre et qui échoue sur les cas limites. Plus le code est généré vite, plus il faut un moyen de vérifier ce qu’il fait : jeu de tests, relecture, environnement de préproduction, sauvegarde. L’assistance accélère l’écriture, pas la responsabilité.

Les Harnais IA (l’agent qui code dans votre terminal)

Un harnais pilote VOTRE dépôt : il lit le code, édite, lance les tests, en boucle. Libre et local, l’inverse du générateur SaaS qui garde vos fichiers sur son cloud.

OpenCode (MIT)

Terminal, des dizaines de fournisseurs de modèles, sessions partageables sur le web. Le plus ouvert du lot.

Aider (Apache 2.0)

Le vétéran git-natif : édite vos fichiers et commite proprement. Sobre, scriptable, fiable.

Codex CLI (Apache 2.0)

Le harnais d’OpenAI : sandbox et approbations intégrées, sûr par défaut.

Gemini CLI + Ollama

Gemini CLI pour son quota gratuit généreux ; Ollama pour tourner 100 % local, sans cloud.

Spec-driven vs vibe : le vibe improvise au fil du prompt, le spec-driven écrit d’abord la spécification puis fait valider chaque étape. Une boucle agentique codée pas à pas : voir le module 14.
02

Intelligence Artificielle

Fondations & Concepts

Un modèle de langage n’est pas une base de connaissances : c’est une machine à produire une suite probable de mots à partir d’un contexte. Cette nuance explique la plupart des réussites et des déceptions.

Nous allons voir comment un modèle apprend, ce que le RAG ajoute, pourquoi un prompt bien écrit ne compense pas un mauvais corpus, et comment lire un prix sans comparer des chiffres qui ne parlent pas de la même chose. Les benchmarks servent de repère, pas de verdict.

Objectif : Comprendre la mécanique réelle pour mieux orchestrer les Agents.
Public : Product Builders avancés. Pas de maths complexes, juste de la logique métier.

⚠️ Erreur Fréquente

Ne confondez pas Intelligence Biologique (Compréhension, Sens, Conscience) et Intelligence Statistique (Corrélation, Prédiction, Probabilité).

🧠 L’Analogie

"L’IA sait expliquer la gravité avec une précision Nobel, sans jamais avoir ressenti le poids de son propre corps."

A. Machine Learning & Deep Learning

Le Pipeline ML Simplifié

  1. Data : Le carburant (Images, Textes, Logs).
  2. Training : L’entraînement (Calculs massifs sur GPU).
  3. Model : Le moteur figé (Le fichier "poids").
  4. Inference : La prédiction (L’usage quotidien).

Les Types d’Apprentissage

Supervisé
On donne l’exemple. Input: Photo Chat -> Output: "Chat".
Usage: Spam, Fraude.
Non-Supervisé
On laisse chercher les patterns. Input: Clients -> Output: Clusters.
Usage: Segmentation.
Renforcement (RL)
Punition / Récompense. Input: Mario -> Output: Score.
Usage: Robotique, AlphaGo, ChatGPT (post-entraînement RLHF, puis RLAIF).

Ce qu’il faut retenir de ce pipeline : l’entraînement produit un fichier de poids, puis s’arrête. À l’usage, le modèle ne fait qu’une chose : calculer la suite la plus probable pour le contexte qu’on lui donne. Il n’apprend pas de votre conversation, il ne se souvient pas de la précédente, et il n’a pas accès à vos fichiers sauf si un programme les lui injecte. C’est pour cela qu’un même modèle peut être excellent sur une question et se tromper sur la suivante : la différence vient du contexte, pas d’une humeur.

B. Architectures Clés

CNN

Vision & Pixels. "Voit" les bords, puis les formes, puis les objets.

Transformers

Langage & Séquences. Gère l’Attention (Le contexte entre les mots lointains).

Vectors / Embeddings

La clé du RAG. Transforme du texte en liste de nombres (coordonnées GPS du sens).

Chat = [0.1, 0.9, 0.3]
Chien = [0.1, 0.8, 0.4]

Ces architectures ne sont pas des boîtes noires interchangeables. Un CNN regarde des pixels, un transformer regarde des relations entre unités de texte, un embedding transforme un contenu en coordonnées. La similarité entre deux embeddings indique une proximité statistique, pas une vérité : deux passages peuvent se ressembler sans que l’un réponde à la question. C’est une boussole, pas un juge.

C. Le RAG (Retrieval Augmented Generation)

Le LLM a une "mémoire figée" (sa date de training). Le RAG lui donne une "mémoire vive" (VOS documents).

Le Pipeline RAG :

Question User -> Recherche Vectorielle (Base de connaissance) -> Récupération des chunks pertinents -> Injection dans le Prompt -> Réponse du LLM

Le RAG ne rend pas un modèle fiable par magie. Trois choses doivent tenir : le document doit être retrouvé, le passage doit contenir la réponse, et le modèle doit l’utiliser sans inventer le reste. Si le découpage coupe une phrase au mauvais endroit, si la base contient une version ancienne, ou si la question demande une synthèse que le passage ne contient pas, la réponse peut être fausse avec beaucoup d’assurance.

Avant de promettre un RAG : mesurez le rappel sur vingt questions réelles. Comptez combien de fois le bon document arrive dans les premiers résultats. Si le rappel est mauvais, changer de modèle ne servira à rien : il faut revoir le découpage, les métadonnées ou la qualité du corpus.

D. Prompt Engineering : La Méthode

Framework "CRISPE"

  • Context : "Tu es un expert Sr..."
  • Role : "Agis comme un CTO..."
  • Intent : "Le but est de..."
  • Specifics : "Pas de jargon..."
  • Parameters : "Tableau Markdown..."
  • Example : "Comme ceci..." (Few-Shot)

Techniques Avancées

Chain of Thought (CoT)
"Pense étape par étape". Force le modèle à décomposer la logique.
Few-Shot
Donner 2 ou 3 exemples de couples (Input -> Output) dans le prompt.
System Prompt
Les instructions prioritaires, invisibles pour l’utilisateur final. Puissantes mais contournables (injection de prompt).

Un prompt n’est pas un sort. Il décrit une tâche, un contexte, un format de sortie et parfois des exemples. Si la demande est ambiguë, le modèle comblera les trous avec ce qui lui semble probable. Les techniques ci-dessus aident à réduire l’ambiguïté ; elles ne remplacent ni une bonne source, ni une validation de la sortie, ni un test sur des cas réels.

⚙️ Specs Techniques

  • Tokens : Unité de facturation. (IN + OUT).
  • Window : Mémoire à court terme (200k à plus d’1M de tokens en 2026).
  • Temperature : Créativité (0 = déterministe, valeurs hautes = créatif, échelle selon modèle).

⚠️ Risques & Mitigation

  • Hallucinations : Le modèle invente pour combler.
    -> Solution : RAG + "Si tu ne sais pas, dis-le".
  • Biais : Reflet d’Internet.
  • Oubli : Dépassement de fenêtre.

E. Choisir son modèle : repères tarifaires (relevé le 06/10/2026)

Prix par million de tokens, relevés sur les grilles officielles le 06/10/2026. Ils bougent vite : vérifiez la grille du jour avant de budgéter. Règle : l’output coûte 2 à 10 fois l’input, donc demandez des réponses courtes et structurées.

Gemini 3.5 Flash-Lite : l’économe polyvalent

Repères : environ 0,30 $ l’input et 2,50 $ l’output, fenêtre large (1M), multimodal (texte, image, audio, PDF).

Usage : gros volumes, classification, RAG simple, prototypes.

Claude Haiku 4.5 : l’économe qui raisonne

Repères : environ 1 $ l’input et 5 $ l’output, fenêtre 200K.

Usage : agents rapides, support client, tâches répétitives soignées.

Mistral Medium 3.5 : l’option UE

Repères : environ 1,50 $ l’input et 7,50 $ l’output, fenêtre 256K, multimodal, poids ouverts.

Usage : contrainte RGPD ou souveraineté (acteur français, données UE).

Claude Sonnet 5.5 : le puissant raisonnable

Repères : environ 2 $ l’input et 10 $ l’output, fenêtre 1M.

Usage : code, agents complexes, raisonnement métier.

GPT-6 Sol : l’écosystème

Repères : environ 2 $ l’input et 10 $ l’output en contexte court (la gamme 6.x bouge vite).

Usage : outillage et intégrations les plus larges, alternative à Sonnet.

Alternative ultra-éco : DeepSeek Flash V4.1 (environ 0,15 $ l’input et 0,60 $ l’output en heures creuses, double en pointe, fenêtre 1M, vision incluse). Prix imbattable, mais hébergement hors UE : à cadrer avec la section Gouvernance (m6) avant usage pro.

Comparer un prix au million de tokens ne suffit pas. Il faut regarder le ratio entrée/sortie, le prix du cache, la taille du contexte réellement envoyé, le nombre de tentatives et le coût des évaluations. Un modèle deux fois moins cher qui échoue une fois sur trois peut coûter plus cher qu’un modèle stable. Le bon indicateur est le coût par tâche réussie, pas le tarif affiché.

F. Modèles dédiés, tailles et routage (relevé le 10/11/2026)

Un LLM généraliste n’est pas toujours le bon outil. En 2026, trois familles rendent service au builder : le modèle qui décide, celui qui tient sur l’appareil, et le petit modèle qui absorbe le volume.

Décider plutôt que rédiger

LFM d1 (Liquid AI) et Jev (TypeSafe AI) ne produisent pas du texte : ils rendent une décision typée avec une probabilité calibrée.

Usage : router un ticket, prioriser une demande, trier un email, décider si un humain doit reprendre la main.

Repère : Jev est annoncé à 42 $ le milliard de tokens d’entrée, et disponible dans n8n depuis le 30 septembre 2026.

Tourner sur l’appareil

Gemma 4 existe en E2B, E4B, 12B, 31B et 26B A4B. Les petits modèles visent le mobile et le navigateur, avec 128K de contexte (256K pour les moyens).

Repères : E2B en Q4_0 demande environ 2,9 Go, E4B 4,5 Go ; les versions mobiles via LiteRT-LM tombent à 1,1 et 2,5 Go.

Usage : classification hors ligne, extraction locale, assistant embarqué, données qui ne sortent pas du poste.

Absorber le volume

LFM3-1.7B, LFM2.5-24B-A2B et la série LFM2.5-230M / 350M couvrent du routage simple au raisonnement compact, en GGUF, MLX, ONNX, Ollama, llama.cpp, LM Studio, vLLM ou SGLang.

Licence : gratuite pour un usage commercial jusqu’à 10 M$ de revenu annuel, ensuite contrat.

Usage : premier filtre d’une cascade, résumé, tags, extraction de champs.

Exécuter partout

LiteRT-LM (Google) est la couche d’exécution qui porte ces modèles sur Android, iOS, Web, desktop et IoT, avec accélération GPU et NPU.

À jour : SDK Web, modèles ASR et TTS (Qwen3-ASR, Kokoro, Qwen3-TTS), masquage de logits accéléré, API C 1.0.0.

Usage : une seule base de code pour le poste, le téléphone et le navigateur, sans serveur intermédiaire.

La cascade, motif de routage de 2026

Le bon réflexe n’est pas de choisir un modèle unique, mais d’ordonner trois étages : un petit modèle décide, un modèle moyen rédige, un modèle fort arbitre les cas difficiles. La confiance sert de signal de passage, pas le hasard.

routage_pseudo.txt
decision = jev.classify(ticket, ["critique", "haute", "moyenne", "basse"])

si decision.confidence < 0.8      -> revue humaine
sinon si decision.label == "critique" -> agent + approbation
sinon                                 -> file standard (petit modele)
Ce que ça change pour le budget : un ticket traité par un modèle de décision coûte une fraction d’un appel à un modèle généraliste, et l’escalade devient un choix explicite. Mesurez le taux d’escalade avant de promettre un coût par ticket : c’est lui qui décide de la facture réelle.
Pourquoi maîtriser ça pour l’automatisation ?
Si vous ne comprenez pas les Tokens, vous exploserez votre budget API. Si vous ne comprenez pas le RAG, vos bots de support diront n’importe quoi. Si vous ne structurez pas vos Prompts, n8n ne pourra pas parser le JSON de réponse.
03

Architecture n8n

Comprendre les items, les erreurs et les sous-workflows

n8n devient plus simple quand on cesse de le regarder comme une collection de nœuds. Un workflow transporte des items, chaque nœud les transforme, et les expressions servent à retrouver une donnée précise dans ce flux.

Ce module part de cette mécanique. Nous allons suivre un item de l’entrée à la sortie, regarder ce qui se passe quand une branche échoue, et voir quand il faut écrire du code plutôt que d’empiler des nœuds. Les captures d’écran viendront plus tard : d’abord le modèle mental.

Le Piège Classique :
n8n n’est pas "juste" un Zapier moins cher. C’est un environnement de développement visuel. Si vous ne comprenez pas le passage des données (Items), vous serez bloqué au premier IF.

n8n 3 et les agents natifs

Relevé du 10 novembre 2026 : la version stable est 2.47.3, la bêta 2.48.0. n8n 3.0 est en accès anticipé, avec une 3.2.0 en préversion. Deux changements de fond à retenir avant de planifier une montée de version.

La rupture 3.0

  • L’auto-hébergement passe par Docker : plus de paquet npm exécutable.
  • Les nœuds hérités disparaissent (Function, Item Lists, Cron, Interval, Read PDF, HTML Extract). Function devient Code.
  • $getPairedItem est retiré au profit de $('Nœud').item.
  • La rotation des clés de chiffrement est active par défaut, le Slack Trigger exige désormais un signing secret.
  • Le rapport de migration (Settings puis Migration Report) liste les workflows à reprendre avant la bascule.

Les agents intégrés

  • Onglet Agents (2.40, en preview) : un modèle, des instructions, des outils.
  • Un agent appelle des nœuds, des serveurs MCP et des workflows entiers comme outils.
  • Skills, sous-agents, fichiers de connaissance, mémoire et session par conversation.
  • Un tour d’agent compte une exécution, les appels d’outils ne sont pas refacturés séparément.
  • Les outils sensibles peuvent exiger une approbation humaine avant exécution.
Lecture de builder : n8n devient une plateforme d’agents en plus d’un orchestrateur. La valeur se déplace du branchement de nœuds vers la définition du cadre : outils autorisés, approbations, journal et politique de nœuds. Les politiques de types de nœuds (2.44) sont réservées à l’offre Enterprise, à prendre en compte avant de bâtir une flotte.

1. La Structure "Item"

Tout tourne autour du JSON. Un nœud reçoit un Tableau et renvoie un Tableau.

[ { "json": { "email": "alice@corp.com", "id": 1 }, "pairedItem": { "item": 0 } }, { "json": { "email": "bob@corp.com", "id": 2 }, "pairedItem": { "item": 1 } } ]

2. L’Expression Language

Pour rendre les nœuds dynamiques, on utilise des expressions JavaScript (doubles accolades).

{{ $json.email }}
Accède à la propriété "email" de l’item courant.
{{ $now.plus({ days: 1 }) }}
Ajoute 1 jour à la date courante (librairie Luxon intégrée).
{{ $('NomDuNoeud').first().json.id }}
Va chercher une donnée dans un nœud précédent (remplacez NomDuNoeud par son vrai nom).

Suivons une commande simple. Le Webhook reçoit un item avec un identifiant et un montant. Le nœud Set ajoute un champ statut. Le nœud IF sépare les commandes supérieures à 100 euros. Le nœud HTTP appelle la comptabilité, puis Respond renvoie une réponse. À chaque étape, le nœud reçoit un tableau et renvoie un tableau : il peut le filtrer, le trier, le dupliquer ou le vider. Un filtre qui ne laisse rien passer ne produit pas une erreur, il produit zéro item. C’est une distinction importante quand on cherche pourquoi la suite du workflow ne s’exécute pas.

{{ $json.email }} lit le champ de l’item courant. {{ $('Nom du nœud').item.json.email }} lit un item précis d’un nœud précédent. pairedItem conserve le lien entre une sortie et l’item d’entrée qui l’a produite. Sans ce lien, un nœud qui fusionne ou transforme des données ne peut plus dire à quelle ligne d’origine appartient le résultat.

Atelier : inspecter un tableau d’items

Collez un tableau JSON. Le premier objet peut être un item n8n ({"json": {...}, "pairedItem": {...}}) ou un objet simple. L’atelier montre les clés, les valeurs absentes et la présence de pairedItem.

Le tableau est traité localement dans votre navigateur. Aucune donnée n’est envoyée.

🛠 Debugging & Optimisation

🔍 Lire les Logs

Dans l’historique d’exécution :

  • Input : Ce qui est rentré dans le nœud.
  • Output : Ce qui en est sorti.
  • Si Output est vide, le nœud a filtré toutes les données.

📌 Pin Data

Ne rejouez pas tout le workflow à chaque test API !

Cliquez sur l’épingle d’un nœud pour figer ses données de sortie. Le nœud suivant utilisera ces données "mockées" sans rappeler l’API précédente.

Quand un workflow « ne fait rien », trois causes reviennent. Un filtre en amont a renvoyé zéro item. Un nœud a échoué et la branche d’erreur n’est pas branchée. Ou une expression pointe vers un champ qui n’existe pas, et le nœud reçoit undefined. Dans les trois cas, le réflexe utile est de cliquer sur le dernier nœud vert, de regarder son output, puis de remonter d’un nœud à la fois. Le journal d’exécution raconte l’histoire ; le canvas ne montre que le chemin prévu.

🧩 Les Nœuds Indispensables

Merge Node

• Append : Met les tableaux bout à bout.
• Wait (Mode "Pass-through") : Attend que la branche A soit finie avant de lancer la B. Vital pour séquencer les actions.

Switch / If

Dirige le trafic. Le "Switch" est plus propre que des "If" en cascade.
Ex: Routez par "Type de Client" (VIP, Standard, Prospect).

Loop Over Items (ex-Split In Batches)

Pour ne pas faire exploser la RAM ou les limites API. Le nœud boucle sur chaque lot puis continue via sa sortie "done".
"Traite ces 1000 emails par paquets de 10."

Code Node

L’échappatoire. Quand le No-Code est trop lourd, 5 lignes de JS résolvent le problème. Manipulation complexe d’Arrays ou Regex.

Nœud natif ou nœud Code ? La question n’est pas idéologique. Un nœud natif est plus lisible pour la personne qui reprend le workflow, et souvent plus simple à tester. Un nœud Code devient utile quand la transformation est difficile à exprimer visuellement, quand il faut appeler une bibliothèque, ou quand dix nœuds font le travail de cinq lignes. Dans les deux cas, le critère est le même : est-ce qu’une autre personne peut comprendre et modifier sans vous appeler ?

Les sous-workflows servent à découper une logique réutilisée, à isoler une partie qui doit être testée seule, ou à contenir une erreur. Ils ont un coût : il faut documenter leurs entrées et sorties, versionner les deux workflows, et se souvenir qu’une modification dans le sous-workflow affecte tous ses appelants. Un sous-workflow mal nommé devient une boîte noire de plus.

Règle simple : si vous devez expliquer un nœud à voix haute pendant plus de trente secondes, il manque soit un commentaire, soit un découpage. Le workflow doit rester lisible six mois plus tard, pas seulement le jour de la démonstration.

Cas Pratique : Lead Enrichment Machine

1. Webhook : Reçoit l'email depuis Typeform.
⬇️
2. API d'enrichissement (Apollo...) : "Qui est ce prospect ?" (Job, Taille boîte). Clearbit : offre gratuite arrêtée en 2025, prévoyez une alternative payante.
⬇️
3. IF : Est-ce un CEO de +50 employés ?
├── OUI :
│ ├── AI Agent : Rédige une intro personnalisée LinkedIn.
│ ├── HubSpot : Crée le deal "Hot Lead".
│ └── Slack : Notifie l'équipe Sales 🔥.
└── NON :
└── Mailchimp : Ajoute à la newsletter classique.
Version 0 € : remplacez l’API payante par le quota gratuit de Hunter.io (vérification d’emails, environ 25 par mois au moment de la rédaction) ou par les données déjà dans votre CRM. Au-delà, Apollo et consorts sont payants : chiffrez le coût par lead avant la prod. Starter importable : wf-lead-enrichment.json (Webhook → HTTP Request → IF → Set → Respond).
Astuce Pro : Nommez TOUJOURS vos nœuds (ex: "Get_User_Data" au lieu de "HTTP Request 1"). Votre "Future You" (dans 3 mois) vous remerciera quand il faudra déboguer $('HTTP Request 43').first().

Workflows prêts à importer (JSON)

Quatre starters à importer dans n8n (menu → Import from File), puis adaptez URL et clés. Reconnectez vos credentials : ils ne sont jamais inclus dans un export partagé.

1. Stripe vers Supabase : wf-stripe-supabase.json (Webhook → Set → HTTP Request).

2. Pagination API : wf-api-pagination.json (Schedule → HTTP Request → Code → Set).

3. Retry sur 429 : wf-retry-429.json (Webhook → HTTP Request avec réessais → Respond).

4. Lead Enrichment : wf-lead-enrichment.json (Webhook → HTTP Request → IF → Set → Respond).

Non testés à l’import : schémas calqués sur des exports réels, mais validez dans votre version de n8n avant la prod.

TP : Réservation de salles (100 % libre)

Le cas d’école des conflits de créneaux, sans rien payer : NocoDB pour les tables, n8n pour la logique, Resend gratuit pour les emails (voir module 5).

chaine_noeuds.txt
Form (n8n) -> NocoDB (lire Réservations) -> Code (chevauchement, motif m14)
  -> IF libre ? -> NocoDB (créer) -> SMTP (confirmation)
Pas à pas : 1. NocoDB : tables Salles et Réservations (salle, début, fin, email). 2. n8n : Form Trigger (salle, créneau, email). 3. Lire les réservations de la salle. 4. Nœud Code : motif chevauchement du module 14, puis IF. 5. Conflit : répondre "créneau pris" ; sinon créer la réservation. 6. SMTP : confirmation immédiate + rappel J-1 via Schedule.
04

Agents & MCP

Ce qu’un agent fait, et ce qu’il ne fait pas

Un agent n’est pas un chatbot avec des boutons. C’est une boucle qui observe un état, choisit une action, l’exécute, puis regarde le résultat. Cette boucle est puissante quand le chemin n’est pas connu à l’avance, et coûteuse quand une règle simple suffisait.

Nous allons voir où placer les garde-fous, comment un serveur MCP expose des outils, pourquoi la mémoire longue accumule les erreurs, et comment évaluer un agent sans se raconter d’histoires. Le module se termine par les topologies de flotte et les méthodes qui tiennent en production.

Une analogie utile :
Une IA classique (ChatGPT) est un Encyclopédiste paralysé dans un bocal. Il sait tout, mais ne peut rien toucher.
Un Agent IA est ce même encyclopédiste à qui on a greffé des bras (Tools) et donné un accès internet.

🧠 La mécanique de base

Agent = LLM + Tools + ReAct Loop

ReAct (Reasoning + Acting) est la boucle, bornée par un nombre max d’itérations :

  1. OBSERVE : "L’utilisateur veut la météo."
  2. REASON : "Je ne connais pas la météo. J’ai un outil météo."
  3. ACT : "J’appelle `get_weather(Paris)`."
  4. OBSERVE : "L’outil a répondu 15°C."
  5. ACT : "Je réponds à l’utilisateur."

🤖 Les Types d’Agents

Single Agent
Un seul cerveau avec plusieurs outils (ex: Le bot Support Client).
Multi-Agent (Swarm)
Une équipe de spécialistes. Un "Manager" délègue à un "Coder", un "Reviewer" et un "Designer".
Outils : CrewAI, AutoGen, LangGraph.

La boucle ReAct échoue de trois manières prévisibles. L’agent peut inventer un outil qui n’existe pas, appeler le bon outil avec de mauvais arguments, ou tourner en rond parce que le résultat ne correspond pas à ce qu’il attendait. Elle coûte aussi de l’argent à chaque tour : chaque observation et chaque raisonnement repartent dans le contexte. C’est pourquoi une règle déterministe ou un workflow n8n classique reste souvent préférable pour une tâche connue. L’agent est intéressant quand le chemin doit être découvert, pas quand il est déjà écrit.

Le Standard MCP (Model Context Protocol)

MCP ressemble à un connecteur standard : il décrit les outils et le transport entre un hôte et un serveur. Avant, chaque connexion demandait son propre code. MCP réduit ce travail, mais ne garantit ni la qualité de l’outil, ni la sécurité des données qu’il expose.

Host (L’Hôte)

L’application où vous chattez (Claude Desktop, Cursor, n8n).

Server (L’Outil)

Le connecteur qui "parle" à la donnée (Google Drive MCP, Slack MCP, GitHub MCP).

Client

Le connecteur local qui relie l’hôte au serveur (transport STDIO ou HTTP).

MCP standardise le transport et la description des outils, pas la confiance. Un serveur MCP peut exposer un outil qui lit vos fichiers, envoie des emails ou modifie une base. Il faut donc décider quels serveurs sont autorisés, quels outils sont accessibles, avec quels identifiants, et ce que l’agent fait du résultat. Une réponse d’outil est une donnée non fiable : elle peut contenir une instruction injectée. Le modèle ne doit pas confondre le contenu d’un document avec un ordre.

🆚 Trois façons de connecter

  • API (Classique) :
    Complexe. Demande d’apprendre la doc par cœur. Code manuel.
  • Webhook :
    Passif. "Si X arrive, fais Y". L’IA subit l’événement, elle ne peut pas "chercher".
  • MCP (Agentic) :
    Actif & Découvrable. L’outil dit "Hey, je sais envoyer des mails !". L’IA répond "Cool, je t’utiliserai si besoin".

Vocabulaire Agentique

Le critère de choix n’est pas la mode, c’est la variabilité de la tâche. Si vous pouvez dessiner le chemin sur une feuille, un workflow déterministe sera plus simple à tester, à auditer et à réparer. Si le chemin change à chaque demande, qu’il faut chercher dans plusieurs sources et décider quoi faire ensuite, un agent peut aider. Entre les deux, le semi-IA consiste à laisser le modèle proposer et à garder une règle ou un humain pour disposer.

Quel pilotage pour quel besoin ?

100 % déterministe : même entrée, même sortie, toujours. Paie, facturation, conformité : aucune IA sur le chemin critique. Voir modules 3 et 14.
Semi-IA (le réglage recommandé) : l’IA propose, une règle ou un humain dispose. Un nœud de validation bloque toute action irréversible (paiement, suppression, envoi client). Voir module 3.
Full-IA supervisé : l’agent tourne seul mais en sandbox, avec budget tokens et journal d’actions relu a posteriori. Jamais d’écriture irréversible sans filet. Voir module 1 (les harnais en local).

Le harnais : ce qui transforme un modèle en agent

Un modèle seul répond. Le harnais lui donne une boucle, des outils, du contexte, une mémoire, des permissions et un budget. À modèle égal, deux harnais ne produisent pas les mêmes résultats : c’est pourquoi les comparaisons sérieuses de 2026 portent sur le couple modèle et harnais, pas sur le modèle isolé.

Boucle bornée

Un nombre de tours maximal, un budget de tokens et une limite de temps. Sans borne, un agent qui échoue tourne jusqu’à la facture.

Contexte

Ce qui entre dans la fenêtre : consigne, documents, résultats d’outils. On le compresse au lieu de l’empiler.

Outils

Schéma typé, idempotence, mode simulation. Un outil qui écrit doit pouvoir être rejoué sans doubler l’effet.

Mémoire

Session courte, mémoire longue, skills. La mémoire longue se relit et se corrige, sinon elle accumule les erreurs.

Permissions

Sandbox, liste d’autorisation, approbation humaine sur toute action irréversible. Le droit d’agir se donne outil par outil.

Trace

Chaque tour journalisé : entrée, décision, outil, sortie, coût. Rejouable pour l’audit et pour la mise au point.

boucle_bornee.txt
tour = 0
tant que tour < 8 :
    action = modele.decide(contexte, outils)
    si action.type == "reponse"      -> sortir
    si action.outil est sensible     -> demander approbation
    resultat = outil.executer(action)
    contexte = compresser(contexte + resultat)
    tour = tour + 1
sinon                                -> escalader a un humain
Le harnais est un produit, pas un script : gardez le modèle derrière une interface. Changer de fournisseur doit être une ligne de configuration, pas une réécriture de la boucle. C’est ce qui rend une flotte durable quand les prix bougent.

Flottes d’agents : quatre topologies, un seul critère

Le multi-agent est souvent vendu comme un essaim. En pratique, quatre topologies couvrent le besoin. Le critère de choix est simple : chaque saut entre deux agents ajoute des tokens, de la latence et un point de panne. On n’ajoute un agent que si le découpage apporte une compétence ou une permission différente.

Superviseur

Un agent chef découpe la demande, délègue à des spécialistes, puis agrège. Bon pour un livrable unique et long.

Risque : le chef résume l’état de ses sous-agents au lieu de le vérifier.

Routeur

Une décision oriente vers un spécialiste, sans retour. Bon pour le support, le tri, la priorisation.

Risque : une mauvaise route produit une bonne réponse à la mauvaise question.

Pipeline

Des étages séquentiels avec un contrat d’entrée et de sortie. Bon pour la production : chaque étage se teste seul.

Risque : rigide quand la demande sort du chemin prévu.

Essaim

Des agents pairs qui se parlent jusqu’à converger. Bon pour explorer, coûteux et difficile à auditer en production.

Risque : la conversation tourne sans qu’aucun agent ne tranche.

Runtimes libres pour tenir une flotte

Hermes Agent (MIT)

Le runtime de Nous Research : boucle qui apprend, skills créés après une tâche complexe, sous-agents, tâches planifiées, passerelle Telegram, Discord, Slack, WhatsApp, Signal et email.

Six backends de terminal : local, Docker, SSH, Modal, Daytona, Vercel Sandbox. MCP intégré. Plus de 260 000 étoiles au 10 novembre 2026.

OpenMausBot (Apache 2.0)

Une alternative libre avec une machine virtuelle par bot : l’agent agit dans un environnement jetable, pas sur votre poste.

TypeScript et Electron, auto-hébergé, orienté computer use. Environ 20 500 étoiles au 10 novembre 2026.

Et en visuel ? Les agents n8n (module 3) couvrent le besoin sans code : un modèle, des instructions, des outils, des approbations et un journal. Pour une flotte de plus de trois agents, le runtime dédié reste plus lisible qu’un canvas.

Six méthodes qui séparent un prototype d’un système

Spec-driven

Écrire la spécification et les critères d’acceptation avant de générer. Sans critère, on évalue au feeling.

Eval-driven

Dix à cinquante cas de test avant de toucher au prompt. Chaque régression observée devient un test permanent.

Context engineering

Choisir ce qui entre dans la fenêtre. Un contexte propre bat un prompt astucieux chargé de bruit.

RAG ou fine-tuning

RAG pour la connaissance qui bouge et les sources citables. Fine-tuning pour le style et le format stables.

Observabilité

Trace, coût par exécution, taux d’escalade, taux d’échec par outil. Sans mesure, pas d’amélioration.

Garde-fous

Validation de sortie, plafond de dépense, approbation, coupe-circuit. Un garde-fou se teste en le déclenchant.

Ordre de mise en œuvre : 1. une règle écrite si elle suffit, 2. du RAG pour la connaissance, 3. un petit modèle dédié pour les décisions, 4. le fine-tuning en dernier, car c’est le plus cher à maintenir. La plupart des projets s’arrêtent à l’étape 2 et s’en portent bien.
TP

Atelier Pratique

Objectif : Agent Interne

Créer un workflow n8n qui reçoit une demande, active un Agent IA, qui consulte un outil via MCP (Brave Search) et répond.

Trigger (Webhook) -> OpenAI (Tool Calling) -> Router -> MCP Client -> OpenAI (Synthèse) -> Response
XP

Mise en pratique : MCP et n8n

Le "Bridge" (Pour Claude)

Exposer vos workflows n8n comme des outils locaux pour Claude Desktop, via un serveur MCP communautaire. Aucun paquet officiel n’existe sous ce nom : vérifiez le paquet actif au moment de l’atelier.

Webhook n8n -> Serveur MCP -> Claude Desktop

Le Schema Sticky Note

Décrivez vos outils directement dans le canvas n8n pour que le Bridge les détecte.

@mcp-tool: search_client inputSchema: { "email": "string" }

Serveur MCP minimal : 15 lignes qui exposent un outil

Exemple Python avec le SDK officiel (paquet mcp). Ce serveur expose une recherche client à n’importe quel client MCP (Claude Desktop, Cursor, n8n).

serveur_mcp.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("clients")

@mcp.tool()
def chercher_client(email: str) -> str:
    """Retrouve un client par son email."""
    return "Client " + email + " : statut VIP, 12 commandes."

if __name__ == "__main__":
    mcp.run()

Function Calling

Le modèle appelle VOS fonctions, décrites en schéma JSON. Vous codez tout, couplage fort au modèle.

MCP

Le modèle découvre des OUTILS externes standardisés. Un serveur, tous les clients compatibles.

A2A (Agent2Agent)

Des AGENTS qui dialoguent entre eux (protocole de Google). Utile en essaim, overkill pour exposer un simple outil.

Repère 2026 : en local le transport STDIO domine, en distant c’est le HTTP streamable. Vérifiez la doc de votre client avant l’atelier, ça bouge vite.
05

Construire sa stack

Vitesse, contrôle et coût de maintenance

Il n’y a pas de meilleure stack. Il y a des compromis : le temps de mise en route, le coût mensuel, la liberté de changer d’outil, la compétence nécessaire pour réparer ce qui casse. Un choix excellent pour un prototype peut devenir une dette pour une équipe.

Ce module propose une grille de lecture plutôt qu’un classement. Nous allons comparer les approches, calculer un coût total avec le temps de maintenance, et regarder ce qui se passe quand le projet grandit. Le bon choix est souvent le plus ennuyeux.

Le Dilemme : Il n’y a pas de "Meilleure Stack". Il y a la bonne stack pour le bon stade de projet.
Attention : Passer du "Tout SaaS" au "Self-Hosted" change votre métier de "Marketer" à "DevOps". Arbitrez sur le coût total, l’hébergement UE (RGPD) et le verrouillage fournisseur.

A. Trois situations de départ

Ces trois profils sont des raccourcis, pas des cases. Votre situation est probablement un mélange : une équipe de deux personnes qui veut garder ses données, un service marketing qui a besoin d’une landing page sans attendre la DSI, une PME qui doit brancher un logiciel métier ancien. Les outils ci-dessous donnent une direction ; ils ne remplacent pas l’inventaire de vos contraintes.

🚀 1. Solo Starter

"Je veux lancer mon MVP en 48h."

Front
Softr (Portail Client) ou Framer (Landing).
Back
Airtable (Visuel, simple).
Logic
Make (Intuitif, pay-per-op).
À surveiller : le coût par opération quand le volume augmente.

🛠️ 2. Product Builder

"Je veux scaler et posséder ma donnée."

Front
Appsmith (Outils Internes) ou FlutterFlow (Mobile App).
Back
Supabase (Postgres Open Source).
Logic
n8n (Self-Hosted, illimité).
Un bon compromis quand une personne sait administrer les outils.

🏢 3. Enterprise

"Sécurité, SSO, Compliance."

Front
Retool (orienté grandes équipes).
Back
Xano (Certifié, Scalable).
Logic
n8n Enterprise ou Custom Code.
À prévoir : facturation par utilisateur et contrat.

Ce que le choix change vraiment : le temps de mise en route, le coût mensuel, la possession des données, la facilité de migration et la compétence nécessaire pour réparer. Un outil SaaS peut être parfait pour démarrer et devenir un piège quand le prix dépend du nombre d’utilisateurs ou quand l’export est incomplet. Un outil auto-hébergé peut coûter moins cher en licence et plus cher en temps, en sauvegardes et en astreinte. Le calcul honnête inclut ces trois lignes.

B. Deep Dive : Les Piliers

⚡ Supabase (Backend)

Open Source

L’alternative à Firebase. C’est une vraie base PostgreSQL avec une couche d’API automatique.

  • Auth : Gestion utilisateurs (Magic Link, Google, Apple) incluse.
  • Realtime : Écouter les changements de la base en direct.
  • Storage : Hébergement de fichiers (Images, PDF).

🎨 Appsmith (Frontend)

JS Power

Pour construire des Dashboards Admin, CRM, et outils internes.

  • Drag & Drop : Boutons, Tableaux, Graphiques.
  • JS Everywhere : {{ Table1.selectedRow.email }}. Tout est connectable.
  • Git Sync : Versionnez vos apps comme du code.

📧 Resend (Transactional)

Dev Friend

Un service courant pour envoyer des emails transactionnels (bienvenue, Reset Password). Souvent comparé à SendGrid ou Mailgun. API simple et templates React.

C. Le "Glue Pattern" (Exemple d’Architecture)

Comment tout connecter pour un flux d’inscription utilisateur :

1. Front (FlutterFlow) : L'user remplit le formulaire.
⬇️ API Call
2. Back (Supabase Auth) : Crée l'user et sécurise le mot de passe.
⬇️ Webhook (Trigger)
3. Logic (n8n) : Reçoit l'ID du nouvel user.
⬇️ Enrichissement
4. Agent IA : "Génère un message de bienvenue personnalisé".
⬇️ API Call
5. Email (Resend) : Envoie le mail.
⬇️ Notification
6. Slack : "Nouveau client inscrit !"

Le « Glue Pattern » n’est pas une architecture idéale : c’est un compromis lisible. Chaque flèche est un point de panne, une latence et un endroit où les données peuvent se perdre. Il est utile pour démarrer parce qu’il sépare les responsabilités, mais il devient fragile quand personne ne sait qui possède le webhook, quand un ancien compte reste actif, ou quand une mise à jour change le format d’un message. La documentation des contrats entre étapes compte autant que le choix des outils.

D. Grille de décision : rester, hybrider ou tout héberger ?

Trois repères, du moins au plus engageant. Il n’y a pas de bon choix absolu, seulement un bon choix pour votre stade.

1. Rester en SaaS

Choisissez si : MVP à valider en jours, zéro compétence serveur, budget mensuel accepté.

Limite : facture proportionnelle au volume, hébergement parfois hors UE, sortie coûteuse (verrouillage).

2. Hybride (recommandé pour débuter)

Principe : self-hoster la logique (n8n) et garder le SaaS là où il excelle (emails, auth, base de démarrage).

Limite : deux mondes à maintenir, deux factures à surveiller.

3. Tout self-hosté

Choisissez si : volume élevé et prévisible, exigence RGPD stricte, Docker et Coolify maîtrisés en interne.

Limite : vous devenez l’hébergeur (sauvegardes, mises à jour, astreinte).

Repère : Posez le calcul sur 12 mois : additionnez vos factures SaaS et comparez au coût d’un VPS plus votre temps de maintenance. Tant que le SaaS gagne, restez.

Calculateur : SaaS ou self-hosté ?

Renseignez vos chiffres, le verdict se calcule en local (rien ne quitte votre navigateur).

Vos coûts actuels



Votre temps



Renseignez vos chiffres puis cliquez sur Calculer.

Le calculateur compare des coûts directs. Il n’intègre ni la migration, ni la formation, ni le risque d’indisponibilité, ni la valeur de votre temps hors maintenance. Il sert à rendre le compromis visible, pas à trancher à votre place.

💰 Free Tiers (2026)

  • Supabase : 500MB Data (Généreux).
  • Resend : 3000 mails/mois, max 100/jour (Suffisant MVP).
  • n8n : Auto-hébergé (gratuit, Docker) ou Cloud (dès 20 €/mois).
  • Appsmith : Cloud Community (Gratuit).

📚 Ressources

06

Gouvernance & Standards

Les règles qui évitent les incidents

La gouvernance n’est pas un document que l’on écrit pour rassurer. C’est ce qui reste quand la personne qui a construit le workflow s’en va, quand une clé fuite, ou quand un client demande la suppression de ses données.

Nous allons parler de nommage, de secrets, de sauvegardes, de droits et de journal. Pas pour ajouter de la bureaucratie, mais pour réduire le nombre de choses qui peuvent mal tourner sans que personne ne le voie. Une règle utile tient en une phrase et se vérifie.

Le Scénario Catastrophe :
Le freelance part. Le workflow critique plante. Personne ne sait ce qu’il fait, il n’y a pas de documentation, et la clé API est sur le compte personnel Gmail de l’ancien stagiaire.

La gouvernance commence par une question simple : que se passe-t-il si je disparais demain ? Si la réponse est « personne ne peut reprendre », le problème n’est pas la personne qui part, c’est l’organisation qui n’a rien prévu. Les règles qui suivent ne demandent pas de comité ni d’outil coûteux. Elles demandent une décision écrite, un endroit où la trouver, et une personne qui vérifie de temps en temps.

A. Conventions de Nommage (Naming)

La première règle de la maintenance : tout doit être lisible sans ouvrir le code.

Workflows

[ENV] - [DEPT] - [ACTION]

  • PROD - SALES - Enrich Leads
  • DEV - MKT - Sync Newsletter
  • TEST - IT - Sandbox Stripe

Nodes (Nœuds)

[Verbe] [Objet]

  • Create Airtable Record
  • Get User Email
  • Format Date
  • HTTP Request 2 ❌

Le nommage n’est pas cosmétique. Il permet de retrouver un workflow dans une liste, de comprendre une alerte à deux heures du matin et d’éviter de modifier la production en croyant toucher au test. Le préfixe d’environnement est la partie la plus utile : il rend visible le risque avant l’ouverture du workflow. Le reste peut être imparfait, tant qu’il est cohérent.

B. La Documentation "Sticky Note"

Dans n8n/Make, ajoutez une "Note" visible au début du workflow avec ce template :

# Titre du Workflow **Owner:** @Geoffroy **Last Updated:** 2025-02-02 **But:** Synchroniser les nouveaux clients Stripe vers Airtable. **Inputs:** Webhook Stripe (payment.succeeded) **Outputs:** Ligne Airtable + Notif Slack **Dépendances:** API Stripe, Table 'Clients'

C. Checklists de Sécurité & RGPD

🔐 Gestion des Secrets

  • ❌ Jamais de clé API dans le JSON du workflow.
  • ✅ Utiliser le système "Credentials" de n8n.
  • ✅ Utiliser des Variables d’Environnement pour les URL/Tokens globaux.
  • ✅ Créer des clés API "Service Account" (pas liées à une personne physique).

🇪🇺 Checklist RGPD

  • Minimisation : Ne transférez que les champs nécessaires (pas tout le JSON User).
  • Droit à l’oubli : Si un user est supprimé en base, avez-vous un workflow pour le supprimer de Mailchimp/Slack ?
  • Hébergement : Vos serveurs n8n/Supabase sont-ils en UE ?

Le moindre privilège, en pratique : une clé API qui peut lire, écrire et supprimer toutes les données n’est pas nécessaire pour un workflow qui ne fait que lire un champ. Créez une clé par usage, limitée aux droits utiles, et révoquez-la quand le workflow change. Le jour où la clé fuite, le périmètre du dégât dépend de ce que vous lui avez donné, pas de la chance.

Une sauvegarde non testée n’est pas une sauvegarde. Vérifiez trois choses : où sont les copies, qui peut les restaurer, et combien de temps prend la restauration. Une copie sur le même disque que la production ne protège pas d’une panne matérielle. Une copie jamais restaurée ne protège pas d’une erreur de manipulation.

D. Patterns de Robustesse

Warning Node

Si une branche critique échoue (ex: Paiement), ne la laissez pas "juste" planter. Activez l’option "On Error" (poursuite sur la sortie d’erreur) et connectez un nœud d’alerte.

Idempotence

Si le workflow tourne 2 fois par erreur, que se passe-t-il ?
Bonne pratique : "Upsert" (Update si existe, Create sinon) au lieu de "Create".

Un workflow robuste a trois issues : il continue quand l’erreur est récupérable, il alerte quand elle ne l’est pas, et il conserve la donnée pour rejouer plus tard. Une erreur silencieuse est plus dangereuse qu’une erreur bruyante. Le minimum est un nœud d’erreur qui envoie un message avec l’identifiant de l’exécution, le nom du workflow et la donnée d’entrée. Sans cela, la panne est découverte par le client.

E. Registre des traitements et note de cadrage

Trois réflexes que la check-list C ne couvrait pas : tenez un registre des traitements (quoi, pourquoi, combien de temps), signez un contrat de sous-traitance (DPA) avec chaque outil qui touche des données perso, et fixez des durées de conservation (exemple : prospects 3 ans max en France). Ceci est de l’information, pas du conseil juridique : en cas de doute, faites valider par un pro.

note de cadrage : 5 lignes avant tout workflow
1. Données manipulées (champs exacts, pas "tout le JSON")
2. Base légale (contrat, consentement, intérêt légitime)
3. Hébergement (pays, UE ou non)
4. Durée de conservation et suppression (droit à l'oubli)
5. Owner et date de revue

F. Gouverner l’IA et les changements

Un workflow qui appelle un modèle n’est pas un workflow comme les autres : la sortie varie, le fournisseur change, le coût dépend de l’usage. Quatre artefacts suffisent à le tenir.

Inventaire des modèles

Pour chaque appel : fournisseur, modèle, version, température, taille de contexte, coût unitaire, données envoyées. Sans cet inventaire, une dépréciation devient un incident.

Approbations

Lister les actions irréversibles : paiement, suppression, envoi client, changement de droit. Elles passent par une confirmation humaine ou une file de validation, jamais par la seule confiance du modèle.

Évaluations

Un jeu de cas figé, relu à chaque changement de prompt ou de modèle. Mesurer exactitude, taux d’escalade, latence et coût par exécution. Un prompt sans test est une opinion.

Versionnement et revue

Export JSON dans Git, revue avant mise en production, environnement de test séparé. Le workflow doit pouvoir revenir à la version précédente en une commande.

checklist avant production
[ ] owner, documentation et note de cadrage à jour
[ ] secrets dans le coffre, aucune clé dans le JSON
[ ] environnement de test séparé et jeu de cas d'évaluation
[ ] erreurs, retries et coupe-circuit testés en les déclenchant
[ ] sauvegarde et restauration essayées, pas seulement planifiées
[ ] journal d'audit conservé et coût par exécution mesuré
[ ] procédure d'incident : qui appelle, qui décide, comment on revient
Le test de la panne : débranchez le fournisseur de modèle, puis rejouez un cas réel. Si l’outil ne dit pas clairement ce qui s’est passé et quoi faire, la gouvernance est sur le papier, pas dans le système.
07

🧱 Apps Open Source Self-Hostables

Ce qui s’auto-héberge, ce que ça coûte, ce que ça implique

L’open source est souvent présenté comme une réponse à tout. En pratique, un logiciel libre peut être archivé, mal maintenu, ou publié sous une licence qui interdit exactement l’usage que vous envisagez.

Ce module apprend à lire un dépôt avant de l’installer : licence, dernier commit, issues, taille de la communauté, coût d’exploitation. Les chiffres sont datés et les projets archivés sont signalés. Un outil libre n’est pas gratuit ; il déplace la dépense vers le temps et l’infrastructure.

Pourquoi Self-Hosted ? Souveraineté des données, zéro limite de lignes/exécutions, coût maîtrisé (VPS + Docker + Coolify).
Logiciels libres et auto-hébergement : 100% Contrôle. Vérifiez chaque licence (Apache-2.0, AGPL, fair-code type n8n) avant usage commercial.

🧩 1. Construction d’Apps Internes (CRUD, Dashboards)

NocoBase (Référence 2026)

Plateforme no-code/low-code très complète, pensée comme un framework d’apps métiers.

  • ✅ Modélisation de données visuelle
  • ✅ CRUD avancé (tables, formulaires, kanban, calendar)
  • ✅ Permissions fines, rôles
  • ✅ Automatisations internes
  • ✅ Système de plugins très puissant
👉 Idéal pour CRM, ERP légers, outils internes complexes.

⭐ Appsmith

Builder open-source pour apps internes data-driven.

  • ✅ UI riche (tables, charts, forms)
  • ✅ Connexion directe aux BDD & APIs
  • ✅ JavaScript pour logique avancée
  • ✅ Très populaire, très stable
👉 Idéal comme "front universel" sur Strapi / Directus / Supabase.

Budibase

Low-code orienté équipes IT.

  • ✅ Très rapide à prendre en main
  • ✅ Bon compromis no-code / low-code
  • ✅ Formulaires, portails internes
👉 Moins extensible que NocoBase, mais plus simple.

ToolJet

Builder open-source orienté dashboards & formulaires data.

  • ✅ Simple, rapide
  • ✅ Bon pour prototypes et outils légers
👉 Moins structurant pour des apps complexes long terme.

🔁 2. Automation No-Code (Zapier / Make Self-Hostés)

n8n (Standard de Facto)

Workflow automation open-source et extensible.

  • ✅ Visuel + JavaScript
  • ✅ Grande communauté
  • ✅ APIs, BDD, IA, Webhooks
  • ✅ Orchestration complexe
👉 Pilier central de toute stack no-code moderne.

Activepieces

Alternative "Zapier-like" plus simple.

  • ✅ UX claire
  • ✅ Courbe d’apprentissage douce
  • ✅ Self-hostable
👉 Moins puissant que n8n, mais plus accessible.

Windmill (Bonus)

Plus low-code / dev-oriented.

  • ✅ Scripts + Workflows
  • ✅ Pour publics techniques

Automatisch (Bonus UE)

Automatisation simple, pensée RGPD (éditeur européen).

  • ✅ Open source, self-host gratuit
  • ✅ Données en UE, cloud ~20 €/mois
  • ✅ Prise en main rapide
👉 L’option contrainte réglementaire forte.

Node-RED (Bonus)

Flux événementiels et objets connectés (ex-IBM, Apache 2.0).

  • ✅ Léger, parfait en edge et domotique
  • ✅ Écosystème de nœuds immense
  • ✅ Self-host gratuit, zéro ambiguïté de licence
👉 Capteurs, MQTT, automatismes maison.

Kestra (Bonus)

Orchestration déclarative (YAML), pipelines de données.

  • ✅ Open source, event-driven
  • ✅ Pensé production (logs, reprises)
  • ✅ Self-host gratuit
👉 ETL et batches sérieux, pas du Zapier-like.
Quel orchestrateur quand ?
n8n par défaut (polyvalent + IA, grosse communauté) ; Activepieces pour les publics non techniques (MIT, simple) ; Automatisch si la donnée doit rester en UE ; Windmill pour coder les flux (Python, TS, Go) ; Kestra ou Airflow pour les pipelines de données en production.

🗄️ 3. Bases de Données No-Code (Type Airtable)

NocoDB

Transforme Postgres/MySQL en Airtable-like.

  • ✅ Garde ta vraie base SQL
  • ✅ API auto-générée
  • ✅ Équipes mixtes (Tech + Métier)
👉 Très solide pour projets sérieux.

APITable

Base no-code collaborative "clé en main". Édition communautaire (AGPL) toujours disponible, l’éditeur se concentre sur son cloud.

  • ✅ UX proche d’Airtable
  • ✅ Collaboration native
  • ✅ Simple à déployer
👉 Plus "produit fini", moins flexible que NocoDB.

Baserow (Bonus)

L’Airtable OSS le plus simple.

  • ✅ Très bonne UX
  • ✅ Réputé pour sa simplicité

🌐 4. Backend / CMS Headless (API-First)

Directus (Préféré en 2026)

CMS + Data Platform API-first.

  • ✅ Se connecte à une DB existante
  • ✅ REST + GraphQL
  • ✅ Permissions fines
  • ✅ Parfait pour stacks no-code / IA
👉 Excellent pour Appsmith / n8n / automatisation.

Strapi

CMS headless historique.

  • ✅ Très populaire
  • ✅ Bon pour contenu éditorial
👉 Moins flexible que Directus pour data métier.

🎨 5. Sites Web, Formulaires, Front "Vibe Code"

Webstudio

Builder visuel open-source orienté web moderne.

  • ✅ HTML/CSS propre
  • ✅ Alternative OSS à Webflow

Plasmic (modèle hybride, offre commerciale)

Front React visuel.

  • ✅ Low-code frontend avancé

Appsmith / ToolJet (Réutilisés)

Très efficaces pour portails internes.

  • ✅ Admin, dashboards
  • ✅ "Vibe code" rapide

🤖 6. No-Code + IA (Workflows Augmentés)

n8n + IA

  • ✅ Appels LLM (GPT, Claude, Local)
  • ✅ RAG Pipelines
  • ✅ Agents simples
  • ✅ Orchestration IA + Métier
👉 Un point de départ courant pour orchestrer des appels LLM.

NocoBase + Plugins IA

  • ✅ "AI Employees"
  • ✅ Génération, classification
  • ✅ IA intégrée aux apps métiers
👉 Fort pour entreprises.

Flowise (dépôt archivé)

Builder visuel pour LLM / Agents / RAG.

  • ⚠️ Dépôt archivé le 13 août 2026 : plus de mises à jour.
  • À remplacer par Dify ou n8n pour un nouveau projet.

Comment évaluer un projet en dix minutes

Avant d’installer un outil, ouvrez son dépôt et regardez cinq choses. Le nombre d’étoiles vient en dernier : il mesure l’attention, pas la santé du projet.

  • Dernière activité : commits, releases et réponses aux issues. Un dépôt archivé ou silencieux depuis un an est un musée, même avec beaucoup d’étoiles.
  • Licence : lisez le fichier LICENSE, pas seulement le badge GitHub. Vérifiez ce que vous pouvez faire en interne, en SaaS et en revente.
  • Maintenance : qui répond aux issues ? Combien de mainteneurs actifs ? Les correctifs de sécurité sortent-ils ?
  • Coût d’exploitation : RAM, disque, sauvegardes, mises à jour, dépendances. Un outil gratuit qui demande deux heures de maintenance par mois n’est pas gratuit.
  • Sortie : pouvez-vous exporter vos données dans un format utilisable ? Si la réponse est non, le verrouillage est déjà là.

Un projet de 2 000 étoiles avec des releases régulières et une licence claire peut être plus sûr qu’un projet de 60 000 étoiles sans mainteneur. La taille de la communauté aide à trouver de l’aide, elle ne remplace pas la vérification.

Radar 2026 : ce qui compte, avec licence et étoiles

Relevé le 10 novembre 2026 sur les dépôts officiels. Les étoiles mesurent l’attention, pas la qualité ni la pérennité : un projet très suivi peut être archivé sans préavis. La licence, elle, décide de votre droit d’usage. Quatre familles à ne pas confondre :

  • Open source OSI : MIT, Apache-2.0, AGPL-3.0, PostgreSQL. Droits d’usage, de modification et de redistribution définis par la licence.
  • Open weights : les poids sont téléchargeables, la licence d’usage est propre à l’éditeur (Gemma, LFM). Ce n’est pas la même chose que le code source.
  • Fair-code ou source-available : code visible, self-host souvent libre, revente et service hébergé encadrés (n8n, NocoDB, NocoBase, Directus).
  • Commercial : aucun droit au-delà de ce que le contrat accorde. Le prix affiché n’est pas une licence.

Orchestration

  • n8n : fair-code SUL, 210 000 étoiles.
  • Kestra : Apache-2.0, 30 200. YAML, orienté data.
  • Windmill : Apache-2.0 ou AGPL-3.0 selon les fichiers, modules entreprise à part, 18 500.
  • Activepieces : MIT hors dossier enterprise, 25 500.

Applications internes

  • NocoBase : licence maison (accord NocoBase 3), 24 900. À lire avant un usage commercial.
  • Appsmith : Apache-2.0, 41 200.
  • NocoDB : SUL depuis janvier 2026, 65 500.
  • Baserow : MIT hors premium et enterprise, 6 300.

Données et stockage

  • Directus : MSCL, tier core gratuit en self-host, 38 700.
  • Qdrant : Apache-2.0, 35 500. Base vectorielle.
  • pgvector : licence PostgreSQL, 23 600. Vecteurs dans Postgres.
  • Garage : AGPL-3.0, 4 900. Stockage objet S3 pour petit self-host.

Interfaces IA et RAG

  • Dify : Apache-2.0 modifiée, 160 900. Lire les conditions additionnelles.
  • Open WebUI : licence maison dérivée de BSD, 158 300.
  • Flowise : Apache-2.0 hors enterprise, 55 600. Dépôt archivé le 13 août 2026.

Runtime local

  • Ollama : MIT, 186 600. Le plus simple pour démarrer.
  • llama.cpp : MIT, 133 900. Le moteur qui porte les GGUF.
  • LiteRT-LM : Apache-2.0, 6 900. Mobile, Web, desktop, IoT.

Agents et harnais

  • OpenCode : MIT, 225 900.
  • Hermes Agent : MIT, 262 000.
  • OpenMausBot : Apache-2.0, 20 500.
  • CrewAI : MIT, 60 700. LangGraph : MIT, 44 800.

Observabilité et exploitation

  • Langfuse : MIT hors dossier ee, 37 300.
  • OpenTelemetry Collector : Apache-2.0, 7 800.
  • Uptime Kuma : MIT, 93 500.
Deux dépôts à ne plus recommander : MinIO (AGPL-3.0, 61 300 étoiles) est archivé depuis le 24 avril 2026 ; Flowise depuis le 13 août 2026. Pour un stockage objet S3, regardez Garage (AGPL-3.0, 4 900), SeaweedFS (Apache-2.0, 36 000) ou RustFS (Apache-2.0, 35 900). Pour un builder RAG, Dify ou n8n couvrent le besoin.

Une combinaison possible, à adapter

Directus (data & API)
↓
NocoDB (édition no-code si besoin)
↓
n8n (automatisation + IA)
↓
Appsmith / NocoBase (apps internes)
Majoritairement libre • 100% Self-Hostable • VPS + Docker + Coolify

Quelques combinaisons qui fonctionnent

🧩 Apps Internes
NocoBase
Alt: Appsmith
🔁 Automatisation
n8n
Alt: Activepieces
🗄️ Base Airtable
NocoDB
Alt: APITable
🌐 Backend / API
Directus
Alt: Strapi
🤖 IA Workflows
n8n
Alt: Dify

Licences et besoins : ce qui a bougé en 2026

Deux infos à vérifier avant de déployer : la licence (ça bouge vite) et la RAM (pour dimensionner le VPS).

Licences : le fair-code gagne

NocoDB : passé de AGPL à SUL (Sustainable Use License) en janvier 2026. Self-host interne libre, licence payante si vous revendez l’accès.

Directus : licence maison MSCL en 2026, tier core gratuit en self-host. Usage interne sans souci, contrat au-delà d’un certain seuil.

n8n : fair-code (Sustainable Use License) : self-host libre, revente d’hébergement interdite sans accord.

Les autres : vérifiez le dépôt officiel le jour J (APITable reste AGPL en édition communautaire). Règle : open source ne veut pas dire réutilisation commerciale libre.

Besoins indicatifs (~ RAM, confortable)

Ordres de grandeur pour un usage confortable, à ajuster à votre charge réelle : n8n ~500 Mo, NocoDB et Directus ~1 Go, Baserow ~1 Go, Appsmith et ToolJet ~1 Go, NocoBase ~1 Go, Supabase (stack complète) ~2 Go et plus, Coolify ~2 Go.

Repère : un VPS de 4 Go absorbe n8n, une base et un builder pour démarrer. Mesurez, puis ajustez.

La licence en pratique : trois usages, trois réponses

Usage interne

Vous installez l’outil pour votre équipe, sans le revendre. La plupart des licences fair-code et open source le permettent, à condition de respecter les obligations de conservation des mentions et, pour l’AGPL, de fournir le code modifié aux utilisateurs du service.

Service hébergé pour des clients

C’est le cas qui change tout. Une licence SUL peut interdire la revente de l’accès sans accord. L’AGPL impose de rendre le code disponible. Le MIT et l’Apache-2.0 sont plus permissifs, mais il faut vérifier les modules enterprise et les marques.

Intégration dans un produit

Embeder un composant dans une application distribuée peut déclencher des obligations différentes. Lisez la licence du composant, pas seulement celle du produit principal. En cas de doute, demandez une validation juridique avant de livrer.

Règle : lisez la licence sur le dépôt officiel avant tout usage commercial, surtout si vous facturez l’accès à l’outil (SaaS, portail client). En cas de doute, écrivez à l’éditeur.
08

Data Modeling 101

La colonne vertébrale de tout projet

Une base de données se juge à la qualité des questions qu’elle permet de poser. Si vous devez dupliquer un email dans cinquante lignes, le problème n’est pas l’interface : il est dans le modèle.

Nous allons partir d’un cas simple, une association qui réserve des salles, et regarder les tables, les relations, les contraintes et les index. L’objectif n’est pas de normaliser pour le plaisir, mais d’éviter les données contradictoires et les requêtes qui deviennent impossibles.

Le principe :
Une mauvaise application avec une bonne base de données peut être sauvée.
Une belle application avec une mauvaise base de données devra être entièrement reconstruite.

A. Concepts Relationnels (SQL)

1. Tables & Records

Oubliez Excel. Une base de données n’est pas une "feuille unique". C’est une collection de Tables (Clients, Commandes, Produits).

Primary Key (PK)
L’ID unique d’une ligne. (ex: user_id: 42). Évitez de la modifier : préférez un id technique sans signification métier.
Foreign Key (FK)
La référence vers une autre table. (ex: Dans la table Commandes, j’ai customer_id: 42).

2. Les Relations

  • One-to-Many (1:N)
    Un Client a plusieurs Commandes. Une Commande appartient à un seul Client.
    C’est 90% des cas.
  • Many-to-Many (N:N)
    Un Étudiant a plusieurs Cours. Un Cours a plusieurs Étudiants.
    Nécessite une "Table de Jonction" (ex: Inscriptions).
  • One-to-One (1:1)
    Rare. Un User a un seul Profil. Souvent, une seule table suffit.

Une table, un sujet. Une table `clients` décrit des clients ; une table `commandes` décrit des commandes. Si vous mettez l’email du client dans chaque commande, vous décrivez deux sujets dans la même table. La règle pratique : une colonne ne doit dépendre que de la clé de sa table. Quand une information dépend d’une autre ligne, elle mérite sa propre table ou une clé étrangère.

B. La Normalisation (Sanity Check)

❌ Erreur de Débutant (Flat Data)

Table Commandes:
- ID: 1
- Client: "Jean Dupont"
- Email: "jean@email.com"  <-- DUPLICATION !
- Produit: "Smartphone"
                    

Si Jean change d'email, vous devez modifier 50 commandes. Risque d'erreur : 100%.

✅ Donnée Normalisée

Table Clients:
- ID: 42, Nom: "Jean", Email: "jean@new.com"

Table Commandes:
- ID: 1, client_id: 42, product: "Smartphone"
                    

On change l'email à un seul endroit. Tout se met à jour par magie (via la relation).

Normaliser n’est pas une religion. L’objectif est d’éviter les contradictions, pas de supprimer toute duplication. Pour un tableau de bord qui lit des millions de lignes, une copie calculée peut être légitime si elle est reconstruite par un processus fiable. La différence entre une dénormalisation assumée et une erreur de débutant : dans le premier cas, on sait quelle donnée fait autorité et comment la recalculer ; dans le second, deux copies divergent sans que personne ne sache laquelle est vraie.

Atelier : voir une jointure

Deux tables, quatre jointures. Choisissez le type et observez les lignes conservées, complétées par null quand la correspondance manque.

clients
idnom
1Ada
2Bruno
3Chloé
commandes
idclient_idtotal
1011120
102180
103250
104930

C. Les Types de Données (Typage)

En No-Code comme en Code, soyez stricts. Pensez aussi aux dates, aux décimaux pour les prix, aux UUID et aux emails (texte + validation).

String
Texte ("Hello")
Integer
Entier (42)
Boolean
Oui/Non (true)
JSON B
Donnée flexible ({...})
Pourquoi c'est important ? Vous ne pouvez pas faire une somme sur du texte "12€". Vous devez stocker 12 (Int) et EUR (String) séparément.

D. Mini-TP : modéliser une réservation de salles

Énoncé (cas fictif) : Une association gère 3 salles. Les adhérents réservent un créneau via un formulaire. On veut éviter les doublons et savoir qui a réservé quoi. Proposez les tables, leurs clés et leurs relations avant d'ouvrir le corrigé.

Questions à trancher

1. Faut-il une table Salles séparée, ou un simple champ texte dans Réservations ?

2. Un adhérent réserve plusieurs créneaux, un créneau concerne un seul adhérent : quelle relation ?

3. Où stocker l'email de l'adhérent pour ne jamais le dupliquer ?

Voir le corrigé
corrigé : 3 tables
Table Salles : id (PK), nom, capacité
Table Adhérents : id (PK), nom, email (unique)
Table Réservations : id (PK), salle_id (FK),
adhérent_id (FK), début (datetime), fin (datetime)

Relations : Salles 1:N Réservations,
Adhérents 1:N Réservations.
L'email vit dans Adhérents uniquement.

E. Index, contraintes et migrations

Un schéma juste ne suffit pas : il faut empêcher les mauvaises données d'entrer et garantir que les requêtes restent rapides quand la table grossit. Trois mécanismes, un seul ordre : contraintes d'abord, index ensuite, migrations toujours.

Contraintes

  • PRIMARY KEY : identifiant technique, jamais un email ou un nom.
  • FOREIGN KEY : interdit une commande sans client. Choisissez explicitement le comportement en cas de suppression.
  • UNIQUE : un email, une référence de facture, un slug.
  • NOT NULL : un champ obligatoire se déclare, il ne se suppose pas.
  • CHECK : une date de fin après la date de début, un montant positif.

Index et migrations

  • Indexez les clés étrangères et les colonnes de filtre ou de tri fréquentes.
  • Un index accélère la lecture et ralentit l'écriture : mesurez avant d'en ajouter.
  • Chaque changement de schéma passe par une migration versionnée, jamais à la main en production.
  • Une migration se teste sur une copie, avec un retour arrière prévu.
  • Ajoutez created_at, updated_at et, si besoin, deleted_at pour la suppression douce.
reservations.sql
CREATE TABLE salles (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    nom text NOT NULL,
    capacite int NOT NULL CHECK (capacite > 0)
);

CREATE TABLE adherents (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    email text NOT NULL UNIQUE,
    nom text NOT NULL,
    cree_le timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE reservations (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    salle_id bigint NOT NULL REFERENCES salles(id),
    adherent_id bigint NOT NULL REFERENCES adherents(id),
    debut timestamptz NOT NULL,
    fin timestamptz NOT NULL,
    CHECK (fin > debut)
);

CREATE INDEX idx_reservations_salle ON reservations (salle_id, debut);

F. Le test des dix requêtes

Avant de créer la première table, listez les dix questions auxquelles l'outil devra répondre. Si le modèle ne permet pas d'y répondre sans dupliquer une donnée, il manque une table ou une relation. Les questions typiques :

  • Quelles réservations pour cette salle la semaine prochaine, triées par heure ?
  • Combien de réservations annulées par adhérent ce trimestre ?
  • Quels créneaux sont libres demain entre 9 h et 18 h ?
  • Qui a modifié cette réservation, et quand ?
  • Que se passe-t-il si un adhérent demande la suppression de ses données ?
Règle de nommage : tables au pluriel, colonnes au singulier, clés étrangères <table>_id. Un modèle lisible vaut mieux qu'un modèle élégant que personne ne comprend. Et si une colonne JSONB contient des champs que vous filtrez souvent, ils méritent peut-être leur propre colonne.

Cinq erreurs de modélisation qui coûtent cher

  • Utiliser un email ou un nom comme clé primaire. Ces valeurs changent. Une clé technique sans signification métier ne change pas.
  • Stocker plusieurs valeurs dans un champ (« téléphone1, téléphone2 »). Cela rend les recherches et les mises à jour fragiles. Une table de téléphones règle le problème.
  • Stocker une date en texte. Le tri, les fuseaux et les calculs deviennent approximatifs. Utilisez un type date ou timestamp.
  • Compter sur l’application pour valider. Une contrainte en base protège aussi les imports, les scripts et les erreurs d’un autre service.
  • Modeler l’écran au lieu du métier. Un formulaire change plus vite qu’une relation. Partez des entités et des règles, pas de la disposition des champs.
12

Comprendre les API

Lire, tester et gérer les erreurs

Une API est un contrat. Elle dit ce qu’elle attend, ce qu’elle renvoie et ce qui se passe quand quelque chose ne va pas. La plupart des intégrations cassent parce que ce contrat a été lu en diagonale.

Nous allons décortiquer une requête, parler d’authentification, de pagination, de limites de débit et d’idempotence. Puis nous construirons une requête à la main pour voir ce que les bibliothèques cachent. Tester petit avant de brancher la production.

A. Anatomie d’une Requête HTTP

POST https://api.stripe.com/v1/payment_intents
Authorization: Bearer sk_test_4eC39H...
Content-Type: application/x-www-form-urlencoded

amount=2000&currency=eur&automatic_payment_methods[enabled]=true
1. Method (Verbe)

GET (Lire), POST (Écrire), PUT/PATCH (Modifier), DELETE (Supprimer).

2. Endpoint (URL)

L’adresse du guichet unique.

3. Headers

Les métadonnées (Auth, Format). Le "sticker sur l’enveloppe".

4. Body (Payload)

Le contenu du colis (souvent en JSON, parfois en formulaire comme Stripe ci-dessus).

Une manière simple de lire une requête : la méthode dit ce que l’on veut faire, l’URL dit à qui, les en-têtes donnent les instructions de service, le corps contient la commande. La réponse a la même structure : un statut, des en-têtes, un corps. Un 200 ne garantit pas que le contenu est correct ; un 400 ne dit pas toujours quel champ est fautif. Lisez le corps d’erreur, pas seulement le code.

Les en-têtes de réponse contiennent souvent des informations précieuses : limite de débit restante, identifiant de requête, pagination suivante, type de contenu. Les ignorer, c’est perdre la moitié du contrat. En cas d’incident, l’identifiant de requête est ce qui permet au fournisseur de retrouver l’appel exact.

B. Les Types d’Authentification

Basic Auth / API Key

Simple & Rapide.

Authorization: Api-Key 12345

Souvent passé en Header ou en Query Param (?key=123).

OAuth2 (Le Cauchemar nécessaire)

Sécurisé & Temporaire.

  • 1. Redirection vers Google ("Accepter ?").
  • 2. Reçoit un code.
  • 3. Échange code contre Access Token (valide 1h).
  • 4. Utilise Refresh Token pour renouveler.
Heureusement, n8n gère ça pour vous !

Un token est un mot de passe qui porte des droits. Trois règles évitent la plupart des incidents : stockez-le dans un coffre, pas dans le JSON du workflow ; donnez-lui le plus petit périmètre possible ; prévoyez son expiration et son renouvellement. Un jeton de test n’a rien à faire en production, même « pour aller plus vite ». La rotation d’un secret doit être une procédure testée, pas une improvisation le jour où il fuite.

Polling vs Webhooks :
  • Polling (L’enfant impatient) : "On est arrivé ? On est arrivé ?" (Demande toutes les 5min). Gaspille des ressources.
  • Webhook (Le coup de fil) : "Appelle-moi quand tu arrives." Le serveur vous notifie instantanément.
Préférez toujours les Webhooks quand c’est possible.

C. Traduire le "cURL"

Les docs donnent souvent des exemples en ligne de commande (cURL). Vous devez savoir les lire pour les mettre dans n8n.

curl -X POST https://api.site.com/users \
-H "Authorization: Bearer 123" \
-H "Content-Type: application/json" \
-d '{"name":"Bob"}'
  • -X POST -> Méthode
  • -H "..." -> Header
  • -d '...' -> Body (Data)

Atelier : construire une requête HTTP

Remplissez les champs, puis lisez la requête brute. Aucun appel réseau n’est effectué : l’atelier sert à comprendre la méthode, l’URL, les en-têtes et le corps.

Réflexes doc API

Avant de brancher le premier nœud HTTP, repérez : les statuts (200, 400, 429), la pagination, les limites de débit et l’idempotence. C’est ce qui sépare une démo d’une intégration qui tient en prod.

Tester sans casser

  • Commencer par une lecture : un GET sur une seule ligne, avec une clé de test.
  • Limiter le volume : limit=1 ou per_page=1 avant de boucler sur mille éléments.
  • Utiliser un bac à sable : beaucoup d’API proposent un environnement de test. Vérifiez qu’il ne pointe pas vers les données de production.
  • Éviter les DELETE en production pendant la mise au point. Si vous devez tester une suppression, créez d’abord un enregistrement jetable.
  • Journaliser l’identifiant de requête : c’est la première chose que le support demandera.
  • Prévoir l’idempotence : une écriture rejouée après un timeout ne doit pas créer deux fois la même ressource.

D. Pagination : offset ou curseur

Une API ne renvoie jamais tout. Deux conventions coexistent, et le choix change la fiabilité de votre synchronisation.

Offset / limit

?limit=100&offset=200. Simple, lisible, adapté à un export ponctuel. Si une ligne est insérée pendant la boucle, vous pouvez en sauter ou en voir deux fois.

Curseur

?limit=100&starting_after=cli_123. Stable quand les données bougent, préféré pour une synchronisation régulière. Le curseur est opaque : ne le construisez pas vous-même.

boucle_de_pagination.txt
curseur = null
repeter :
    page = api.lister(limite=100, apres=curseur)
    traiter(page.items)
    curseur = page.next_cursor
    si curseur est null       -> sortir
    si pages > 200           -> alerter et sortir
Le garde-fou : plafonnez toujours le nombre de pages. Une API qui renvoie le même curseur, ou une erreur transformée en page vide, peut faire tourner une boucle toute la nuit.

E. Erreurs, retries et idempotence

Toutes les erreurs ne se rejouent pas. Réessayer un 400 ou un 422 ne sert à rien ; réessayer un 429 ou un 503 est souvent la bonne réponse. Encore faut-il ne pas doubler l’effet.

Statuts à connaître

  • 200, 201, 204 : succès, création, succès sans contenu.
  • 400, 422 : requête ou données invalides. Corriger, ne pas rejouer.
  • 401, 403 : authentification ou droit. Vérifier le secret et le rôle.
  • 404, 409 : ressource absente, conflit (doublon).
  • 429 : trop de requêtes. Respecter Retry-After.
  • 500, 502, 503 : côté serveur. Retry avec backoff possible.

Retry propre

  • Backoff exponentiel avec un peu d’aléatoire, plafonné.
  • Un nombre maximal de tentatives, puis alerte et mise en file.
  • Jamais de retry sur une écriture sans clé d’idempotence.
  • Idempotency-Key : un identifiant unique par intention, réutilisé lors des tentatives.
  • Journaliser le statut, le corps d’erreur et l’identifiant de requête.

F. Webhooks et contrats d’API

Un webhook est une requête entrante non sollicitée : traitez-la comme une entrée utilisateur, pas comme une vérité. Vérifiez la signature, l’horodatage et la forme du payload avant d’agir.

Vérifier un webhook

  • Calculer le HMAC du corps brut avec le secret partagé.
  • Comparer en temps constant, pas avec ==.
  • Refuser un horodatage trop ancien pour limiter le rejeu.
  • Répondre 2xx vite, puis traiter en file : un webhook lent se fait réessayer.
  • Ne jamais faire confiance à un payload non signé, même s’il vient d’une IP connue.

Lire un contrat OpenAPI

  • Chercher servers, security et les schémas de requête.
  • Repérer les paramètres obligatoires et les formats de date.
  • Regarder les réponses d’erreur documentées, pas seulement le 200.
  • Un fichier OpenAPI permet de générer un client et des tests, au lieu de deviner.
Une intégration tient si elle échoue proprement : message clair, données conservées, reprise possible. Un workflow qui ne sait pas échouer finit par perdre des données sans que personne ne le remarque.
13

UI/UX des outils internes

Rendre vos outils utilisables

Un outil interne n’échoue pas parce qu’il est laid. Il échoue parce qu’il demande plus d’effort que l’ancienne méthode, parce qu’il ne dit pas ce qui se passe, ou parce qu’une action irréversible est trop facile à déclencher.

Ce module parle de densité, de hiérarchie, d’états et d’accessibilité. Pas pour faire du design décoratif, mais pour réduire les erreurs et les questions. Un bon écran se comprend sans mode d’emploi ; un bon formulaire empêche l’erreur avant de la signaler.

La Loi du Moindre Effort :
Si votre outil interne est moche et compliqué, vos collègues continueront d’utiliser Excel.
L’adoption est le seul KPI qui compte.

A. Une grille maison : D.A.S.H.

D - Density (Densité)

Ne bourrez pas l’écran. Laissez de l’espace blanc. Une info importante doit respirer.

A - Actionable

Un Dashboard sans boutons ne sert à rien. Ajoutez "Valider", "Refuser", "Éditer" à côté des données.

S - Status

L’utilisateur doit toujours savoir ce qui se passe. (Spinners de chargement, Toasts de succès).

H - Hierarchy

Le titre en gros, le détail en petit. La couleur rouge pour l’urgence.

Prenons un écran de support : une liste de tickets, un filtre par statut, un bouton « prendre en charge », un bouton « fermer ». La densité consiste à afficher l’essentiel sans noyer la ligne ; la hiérarchie met le titre et le statut en avant ; l’action est au bon endroit ; le statut se voit sans ouvrir le ticket. D.A.S.H. n’est pas un score à obtenir, c’est une liste de questions à se poser devant chaque écran.

B. Les Feedbacks (Dialoguer avec l’User)

✅ Happy Path (Succès)

Quand l’action marche, affichez un "Toast" vert : "Client sauvegardé avec succès !".

Ne laissez pas l’utilisateur deviner si le clic a fonctionné.

❌ Unhappy Path (Erreur)

Ne dites pas "Error 500".

Dites : "Impossible de sauvegarder car l’email existe déjà."

Guidez la correction de l’erreur.

Un message d’erreur utile répond à trois questions : que s’est-il passé, pourquoi, et que faire maintenant ? « Erreur 500 » ne répond à aucune des trois. « L’email existe déjà, utilisez la fiche existante ou modifiez l’adresse » répond aux trois. Le feedback ne doit pas seulement confirmer que le clic a été reçu ; il doit aider à terminer la tâche.

C. Check-list Formulaires

  • ✅ Labels clairs : Pas de "Champ 1". Mettez "Numéro de Facture".
  • ✅ Placeholders : Donnez un exemple (ex: "J.dupont@email.com").
  • ✅ Validation temps réel : Dites que l’email est invalide avant le clic sur "Envoyer".
  • ✅ Valeurs par défaut : Pré-remplissez ce que vous savez déjà (Date d’aujourd’hui, User courant).

Les labels et la validation ne suffisent pas sur un formulaire long. Découpez en étapes si le parcours dépasse une quinzaine de champs, indiquez clairement ce qui est obligatoire, et sauvegardez un brouillon si la saisie peut être interrompue. Un champ optionnel mal signalé devient une source d’erreur ; un bouton « Envoyer » qui échoue sans conserver les données fait perdre la confiance.

Le test "Maman" : Si vous montrez votre outil à quelqu’un qui ne connaît pas le projet, comprend-il en 5 secondes sur quel bouton cliquer ? Si non, simplifiez.

D. Avant / Après : le même formulaire, deux destins

La version de gauche part en production telle quelle dans beaucoup d’outils internes. Celle de droite applique la check-list C. Aucune librairie, juste du HTML propre.

avant : à corriger
<form>
  <input type="text" placeholder="Nom">
  <input type="text" placeholder="Email">
  <input type="submit" value="OK">
</form>

3 problèmes : pas de labels (lecteur d’écran perdu), type "text" partout (pas de clavier email sur mobile, pas de validation native), bouton "OK" qui ne dit rien.

après : propre
<form>
  <label for="nom">Nom du client</label>
  <input id="nom" type="text"
    placeholder="Ex : Marie Dupont">
  <label for="email">Email pro</label>
  <input id="email" type="email"
    placeholder="marie@entreprise.fr">
  <button type="submit">
    Enregistrer le client
  </button>
</form>

Corrigé : labels liés aux champs, type "email" (clavier adapté + validation native), bouton qui dit ce qu’il fait.

E. Accessibilité et états d’interface

Un outil interne est utilisé huit heures par jour, parfois au clavier, parfois sur un écran minuscule. L’accessibilité n’est pas une case à cocher : c’est ce qui rend l’outil supportable.

Les bases

  • Contraste d’au moins 4,5:1 pour le texte courant.
  • Jamais la couleur seule pour porter une information : ajoutez un libellé ou une icône.
  • Focus visible, ordre de tabulation logique, navigation clavier complète.
  • Chaque champ a un <label> lié, chaque erreur est annoncée.
  • Cibles tactiles d’au moins 44 px sur mobile.
  • Respecter prefers-reduced-motion pour les animations.

Les états oubliés

  • Vide : expliquer quoi faire, pas seulement "aucun résultat".
  • Chargement : squelette ou indicateur, jamais un écran figé.
  • Erreur : cause, conséquence, action de reprise.
  • Succès : confirmation discrète, qui ne bloque pas le travail.
  • Droits insuffisants : masquer ou désactiver avec une explication.
Test rapide : débranchez la souris, puis accomplissez la tâche principale au clavier. Si vous ne pouvez pas, une partie de vos utilisateurs ne peut pas non plus.

F. Tableaux et actions risquées

La majorité des outils internes sont des tableaux avec des boutons. C’est là que se jouent l’efficacité et les erreurs irréversibles.

Un tableau lisible

  • En-têtes fixes, tri explicite, filtres visibles et réinitialisables.
  • Colonnes alignées : texte à gauche, nombres à droite.
  • Pagination ou chargement progressif, jamais 5 000 lignes d’un coup.
  • Une ligne cliquable doit ressembler à une ligne cliquable.
  • État vide et état de recherche sans résultat sont deux messages différents.

Actions irréversibles

  • Confirmation explicite avec le nom de l’objet, pas "Êtes-vous sûr ?".
  • Préférer l’annulation (undo) à la confirmation quand c’est possible.
  • Le bouton destructeur n’est jamais l’action par défaut ni au même endroit que "Enregistrer".
  • Désactiver le bouton pendant l’envoi pour éviter le double clic.
  • Journaliser qui a supprimé quoi, et permettre la restauration.
Le coût d’un mauvais tableau : une colonne mal nommée ou un filtre caché provoque des erreurs de saisie que personne ne déclare. La qualité d’un outil interne se mesure au nombre de questions que l’utilisateur ne pose plus.
14

Extraits de code (JS)

Les extraits que je réutilise le plus souvent

Le code dans n8n n’est pas un concours d’élégance. C’est un outil pour transformer un item, appeler une API ou contourner une limite. La bonne question n’est pas « puis-je l’écrire en JavaScript ? », mais « est-ce que ce sera plus lisible qu’avec des nœuds ? ».

Ce module rassemble les extraits que je réutilise le plus : tableaux, dates, regex, transformations d’items. Chaque extrait est accompagné de ce qu’il fait et de ce qu’il ne fait pas. Copiez, testez, puis adaptez.

Pourquoi coder ?
Parfois, un nœud Code de quelques lignes est plus lisible et plus rapide qu’une chaîne de quinze nœuds. Ce n’est pas une règle générale : un nœud natif reste préférable quand il suffit. Le code devient utile quand la transformation est difficile à exprimer visuellement, ou quand il faut traiter un cas limite que les nœuds ne couvrent pas proprement.

Trois règles avant de coller un extrait : comprenez ce qu’il fait, testez-le sur un seul item avant de le lancer sur mille, et prévoyez ce qui se passe si une valeur est null ou absente. Un code qui fonctionne sur l’exemple du tutoriel peut échouer sur la première ligne réelle.

A. Arrays (Listes)

.map()

Transformer une liste. (ex: Garder juste les emails).

const users = [ {name: "A", email: "a@test.com"}, {name: "B", email: "b@test.com"} ]; // Résultat: ["a@test.com", "b@test.com"] const emails = users.map(u => u.email);

.filter()

Garder ce qui matche une condition.

const nums = [1, 5, 10, 2]; // Résultat: [5, 10] const big = nums.filter(n => n > 4);

B. Strings (Texte)

.split()

Couper du texte.

const name = "Jean Dupont"; // Résultat: "Jean" const firstname = name.split(" ")[0];

Template Literals

Injecter des variables proprement.

const item = "Pomme"; const price = 10; // "Le prix de Pomme est 10€" const msg = `Le prix de ${item} est ${price}€`;

C. Dates (L’Enfer)

ISO 8601 (Le standard)
2025-02-02T14:00:00.000Z

Utilisez toujours ce format en interne dans n8n.

Format (Luxon)

Dans n8n expressions :

{{ $now.toFormat('dd/MM/yyyy') }}

-> 02/02/2025

D. Regex (Expressions Régulières)

Pour extraire des motifs complexes.

const text = "Contactez-moi au 06 12 34 56 78 merci.";
// D’abord retirer les espaces, puis chercher 10 chiffres d’affilée
const phone = text.replace(/\s/g, "").match(/\d{10}/);
// Résultat: "0612345678"
Outil indispensable : Utilisez Regex101.com pour tester vos regex avant de les mettre en prod. L’IA (ChatGPT) est aussi excellente pour générer des Regex. Dans n8n, $json.email lit un champ de l’item courant et $('NomDuNoeud').first().json lit le premier item d’un nœud précédent : préférez ces expressions à un nœud Code quand c’est possible.

E. n8n en pratique : 3 motifs

Quatre recettes qui reviennent dans presque tous les projets. Nœud Code en mode "Run Once for All Items", sauf mention contraire.

Paginer une API

pagination.js
let page = 1;
let tous = [];
let suite = true;
while (suite) {
  const r = await $http.request({
    method: 'GET',
    url: 'https://api.exemple.fr/items?page=' + page
  });
  tous = tous.concat(r.data);
  suite = r.next_page === true;
  page = page + 1;
}
return tous.map(x => ({ json: x }));

Dédupliquer par email

dedupe.js
const vus = new Set();
return items.filter(i => {
  const mail = (i.json.email || '').toLowerCase();
  if (!mail || vus.has(mail)) return false;
  vus.add(mail);
  return true;
}).map(i => ({ json: i.json }));

Échéance +30 jours, format FR

expression Luxon
{{ $now.plus({ days: 30 }).toFormat('dd/MM/yyyy') }}

Variante du motif C : on ajoute 30 jours avant de formater.

Détecter un chevauchement de créneaux

items[0] = créneau demandé, suivants = réservations existantes. Utilisé par le TP salles du module 3.

overlap.js
const demande = items[0].json;
const debut = new Date(demande.debut).getTime();
const fin = new Date(demande.fin).getTime();
const clash = items.slice(1).some(r => {
  const d = new Date(r.json.debut).getTime();
  const f = new Date(r.json.fin).getTime();
  return debut < f && d < fin;
});
return [{ json: { libre: !clash } }];

Lire une erreur JavaScript sans paniquer

Une erreur dit rarement « voici la cause ». Elle donne un type, un message et une ligne. Les plus fréquentes dans n8n : TypeError: Cannot read properties of undefined (un champ n’existe pas), SyntaxError: Unexpected token (une parenthèse, une virgule ou une quote manque), et ReferenceError: x is not defined (une variable mal nommée ou déclarée dans un autre bloc). Lisez la première ligne de la pile, pas la dernière : c’est souvent là que se trouve l’appel fautif.

Réflexe : reproduisez l’erreur sur un seul item, ajoutez un console.log temporaire ou un nœud Set pour voir la valeur réelle, puis corrigez. Si vous ne comprenez pas l’erreur, ne la contournez pas avec un try/catch qui avale tout : vous déplacez le problème plus loin.
15

Étude de cas : les salles de l’association

De la demande floue au service qui tourne, avec ses compromis

Une demande réelle arrive rarement sous la forme d’un cahier des charges. Elle arrive sous la forme d’une phrase : « on perd du temps avec les réservations de salles ». Le travail consiste à transformer cette phrase en périmètre, en modèle, en workflow, puis en service que quelqu’un utilise vraiment.

Ce cas est reconstitué pour l’exercice. L’association, les chiffres et les incidents sont plausibles, pas réels. Les montants sont des hypothèses de travail à remplacer par les vôtres. L’objectif n’est pas de copier la solution, mais de voir l’ordre des décisions et ce qui aurait pu être évité.

1. La demande, telle qu’elle arrive

Objet : gestion des salles

Bonjour, nous sommes une association de 120 adhérents. Nous avons trois salles et un tableau Excel partagé. Les gens nous écrivent, on répond quand on peut, et il arrive que deux personnes réservent la même salle. Est-ce que vous pouvez nous faire un site ?

La demande contient déjà une solution : « un site ». Si on l’accepte sans discuter, on risque de construire une interface avant d’avoir compris le problème. Les trois difficultés réelles sont ailleurs : les conflits de créneaux, le délai de réponse et la trace de qui a confirmé quoi.

La première décision est donc de ne pas répondre tout de suite par une technologie. On reformule : « Vous voulez que les adhérents puissent demander une salle, que personne ne confirme deux fois le même créneau, et que le bureau puisse retrouver l’historique. C’est bien cela ? » Cette reformulation permet de distinguer le besoin du moyen.

2. Cadrage : ce qui est dans le périmètre, ce qui n’y est pas

Le cadrage tient sur une page. Il nomme les utilisateurs, les contraintes et les critères de réussite. Il dit aussi ce qui ne sera pas fait, ce qui est la partie la plus difficile à écrire et la plus utile pour la suite.

Dans la version 1

  • Formulaire de demande avec créneaux et salle.
  • Vérification de disponibilité dans la base.
  • Confirmation par email avec référence.
  • Rappel automatique la veille.
  • Planning administrateur et export CSV.
  • Journal des confirmations et annulations.

Hors périmètre

  • Paiement et facturation.
  • Application mobile native.
  • Compte adhérent complet avec mot de passe.
  • Gestion des clés physiques.
  • Réservation de matériel.
  • Connexion avec le logiciel comptable.

Critères de réussite

  • Zéro double réservation sur trois mois.
  • Réponse sous un jour ouvré.
  • 80 % des demandes sans échange manuel.
  • Une restauration testée avant la mise en ligne.
  • Le bureau retrouve qui a confirmé, et quand.
Ce que le cadrage évite : une réunion où chacun projette des fonctionnalités différentes. Il permet aussi de refuser proprement : « le paiement n’est pas dans cette version, voici ce qu’il faudrait pour l’ajouter ».

3. Le modèle de données

Trois tables suffisent pour la version 1 : les salles, les adhérents et les réservations. Le point délicat n’est pas le nombre de tables, c’est le chevauchement des créneaux. Une vérification dans l’interface ne protège pas de deux demandes simultanées. La base doit trancher.

CREATE EXTENSION IF NOT EXISTS btree_gist;

CREATE TYPE reservation_statut AS ENUM ('demandee', 'confirmee', 'annulee', 'refusee');

CREATE TABLE salles (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    nom text NOT NULL UNIQUE,
    capacite int NOT NULL CHECK (capacite > 0),
    active boolean NOT NULL DEFAULT true
);

CREATE TABLE adherents (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    nom text NOT NULL,
    email text NOT NULL,
    actif boolean NOT NULL DEFAULT true,
    consentement_le timestamptz
);

CREATE UNIQUE INDEX idx_adherents_email ON adherents (lower(email));

CREATE TABLE reservations (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    salle_id bigint NOT NULL REFERENCES salles(id),
    adherent_id bigint NOT NULL REFERENCES adherents(id),
    debut timestamptz NOT NULL,
    fin timestamptz NOT NULL,
    statut reservation_statut NOT NULL DEFAULT 'demandee',
    cle_idempotence text NOT NULL UNIQUE,
    cree_le timestamptz NOT NULL DEFAULT now(),
    CHECK (fin > debut),
    CHECK (fin - debut <= interval '4 hours')
);

ALTER TABLE reservations
    ADD CONSTRAINT reservations_sans_chevauchement
    EXCLUDE USING gist (
        salle_id WITH =,
        tstzrange(debut, fin, '[)') WITH &&
    ) WHERE (statut IN ('demandee', 'confirmee'));

CREATE INDEX idx_reservations_salle_debut ON reservations (salle_id, debut);

Pourquoi une contrainte EXCLUDE : le CHECK empêche une fin avant le début. Il n’empêche pas deux réservations qui se chevauchent. Si l’application vérifie puis insère, deux demandes peuvent passer entre les deux étapes. La contrainte EXCLUDE fait le contrôle dans la base, au moment de l’écriture. La deuxième transaction échoue, et l’API peut répondre proprement.

Pourquoi une clé d’idempotence : un formulaire renvoyé deux fois, ou un retry après un timeout, ne doit pas créer deux réservations. La clé est générée par le formulaire, transmise dans l’en-tête, puis stockée avec une contrainte d’unicité. Si elle existe déjà, l’API renvoie la réservation existante au lieu d’en créer une seconde.

Ce que le modèle ne règle pas : les réservations récurrentes, les listes d’attente et les annulations avec remboursement. Ce sont des besoins de la version 2. Les ajouter maintenant ralentirait la livraison sans preuve qu’ils servent.

4. Le workflow, étape par étape

Le workflow n’est pas le cerveau du système. Il coordonne des opérations qui doivent rester simples et vérifiables. La disponibilité est calculée par la base, pas par une accumulation de nœuds.

Étape Où Ce qui peut échouer
Recevoir la demande Webhook n8n JSON invalide, appel en double, tentative de spam.
Valider les champs Nœud Code ou IF Date passée, durée supérieure à quatre heures, email absent.
Vérifier la disponibilité Requête PostgreSQL Conflit, base indisponible, lenteur.
Créer la réservation Insertion avec clé d’idempotence Doublon, violation de la contrainte de chevauchement.
Notifier le bureau Email ou canal interne Boîte pleine, quota, adresse invalide.
Confirmer Écran admin puis mise à jour Deux personnes cliquent en même temps.
Envoyer le rappel Tâche planifiée, veille à 18 h Double envoi après un retry, fuseau horaire.
Exporter Requête mensuelle Format CSV, accents, séparateur, données manquantes.

La validation humaine reste en version 1. Le volume est faible, les cas limites sont nombreux, et le bureau a besoin de garder la main sur les exceptions. Automatiser la confirmation tout de suite donnerait l’impression d’un système magique jusqu’au premier cas bizarre. Une fois que les règles sont stables, la confirmation peut devenir automatique.

Le chemin d’erreur compte autant que le chemin heureux : si l’email de confirmation échoue, la réservation ne doit pas être annulée. Elle reste en base, une alerte est envoyée, et une nouvelle tentative est planifiée. Le client ne doit pas recevoir un message qui dit « échec » alors que la salle est réservée.

5. L’API : quatre routes suffisent

Une API n’a pas besoin d’être grande pour être claire. Quatre routes couvrent le besoin, avec des statuts explicites et une séparation entre l’accès public et l’accès administrateur.

Méthode et route Accès Réponses utiles
POST /api/demandes Public, limité en débit 201 créé, 400 invalide, 409 conflit, 429 trop d’appels.
GET /api/salles/{id}/disponibilites Public 200 avec créneaux libres, 400 plage invalide.
POST /api/reservations/{id}/confirmer Administrateur 200 confirmée, 404 absente, 409 déjà annulée.
POST /api/reservations/{id}/annuler Administrateur ou lien signé 200 annulée, 404 absente, 409 déjà annulée.

Un 409 n’est pas une panne : c’est le contrat qui dit que l’état a changé. Le formulaire doit proposer des alternatives, pas afficher « une erreur est survenue ». Exemple de réponse :

{
  "erreur": "creneau_indisponible",
  "message": "La salle est déjà réservée sur ce créneau.",
  "alternatives": [
    { "debut": "2026-11-18T14:00:00+01:00", "fin": "2026-11-18T16:00:00+01:00" },
    { "debut": "2026-11-19T09:00:00+01:00", "fin": "2026-11-19T11:00:00+01:00" }
  ]
}

Authentification : le formulaire public n’a pas de compte. Il est protégé par une limitation de débit, un champ piège et une validation serveur. L’administration utilise une session avec second facteur. Le workflow utilise un compte de service dont les droits se limitent aux tables nécessaires.

Idempotence : l’en-tête Idempotency-Key est généré par le formulaire. La clé est unique en base. Si la même demande revient, l’API renvoie la réservation existante avec un 200, pas une deuxième ligne.

6. L’interface : trois écrans, pas plus

Le formulaire

Six champs : nom, email, salle, date, créneau, message. Les créneaux déjà pris ne sont pas proposés. Les erreurs s’affichent à côté du champ. La confirmation donne une référence courte, pas un identifiant technique illisible.

Le planning

Une vue semaine par salle. Les statuts se distinguent sans ouvrir la fiche. Un clic confirme, un second clic annule après confirmation. L’état vide dit « aucune réservation cette semaine », pas un grand blanc.

L’administration

Liste filtrable, export CSV, journal des actions. Les actions irréversibles demandent une confirmation. Le bouton « annuler » n’est pas collé au bouton « confirmer ».

Le formulaire affiche les créneaux libres avant l’envoi. C’est la meilleure prévention du conflit : on ne propose pas ce qui n’existe pas. La contrainte en base reste nécessaire, car l’affichage peut être périmé de quelques secondes.

7. Gouvernance : les décisions qui tiennent après le départ

Rôles et accès

  • Adhérent : dépose une demande, reçoit un lien signé pour annuler.
  • Bureau : confirme, annule, exporte.
  • Service : lit et écrit uniquement les tables utiles.
  • Lecture seule : consulte le planning sans modifier.

Secrets et journal

  • Mot de passe base, SMTP et jeton admin dans un coffre.
  • Rotation tous les six mois et au départ d’une personne.
  • Journal : identifiant d’exécution, action, auteur, date.
  • Pas de contenu de message ni de donnée personnelle inutile dans les logs.

Sauvegardes

  • Dump quotidien de la base.
  • Copie hebdomadaire hors site.
  • Restauration testée une fois par trimestre.
  • Durée de restauration notée dans le runbook.

Données personnelles

  • Nom et email seulement, pas de date de naissance.
  • Durée de conservation à valider avec le bureau, par exemple treize mois après la dernière réservation.
  • Procédure de suppression sur demande.
  • Contrat de sous-traitance avec l’hébergeur et le service d’email.

Ce n’est pas de la bureaucratie. C’est ce qui permet de répondre à « qui a confirmé cette réservation ? » six mois plus tard, et de restaurer le service sans chercher un mot de passe dans une boîte mail personnelle.

8. Le coût, avec des hypothèses

Les montants ci-dessous sont des hypothèses de travail datées de novembre 2026. Ils servent à rendre le compromis visible, pas à servir de devis.

Poste Hypothèse Coût mensuel
VPS2 vCPU, 4 Go, hébergé dans l’Union européenne12 €
Nom de domaine15 € par an1,25 €
Email transactionnel0 à 15 € selon le volume0 à 15 €
Sauvegarde hors sitePetit volume3 €
Total direct16,25 à 31,25 €
Maintenance2 heures par moisà valoriser

Comparaison avec la situation actuelle : huit heures par mois de saisie et de relances, valorisées 20 € par heure, soit 160 €. Après le projet : deux heures de maintenance, soit 40 €, plus 16 à 31 € de services. Le gain théorique est de 89 à 104 € par mois.

Construction : quatre jours, soit 640 € si on valorise le temps à 20 € par heure, ou 1 600 € si on facture 400 € par jour. Le délai de retour se situe donc entre 6 et 18 mois selon la valorisation. Ce n’est pas spectaculaire, et c’est normal.

Ce que le calcul ne dit pas : le gain financier seul ne justifie pas toujours le projet. Ici, l’argument principal est la réduction des doubles réservations, la traçabilité et la tranquillité du bureau. Si ces trois éléments n’ont pas de valeur pour vous, ne construisez pas.

9. La mise en production : la checklist

  • Une restauration a été testée sur une base vide, chronomètre en main.
  • Les chemins d’erreur ont été provoqués : email indisponible, base lente, double soumission.
  • La limitation de débit et la clé d’idempotence sont actives.
  • Les secrets ne sont ni dans le workflow exporté, ni dans le dépôt Git.
  • L’accès administrateur utilise le second facteur.
  • Une sonde surveille le service et la dernière exécution réussie.
  • Le runbook tient sur une page, avec contacts et procédures.
  • Le bureau a été formé en trente minutes, avec un cas réel.
  • La durée de conservation des données est configurée ou documentée.
  • L’export CSV a été ouvert dans un tableur, accents et dates compris.

10. Trois mois plus tard : ce qui a cassé

Le service a reçu 118 demandes. 96 % ont été traitées sans échange manuel. Quatre conflits ont été détectés par la contrainte, et un doublon a été évité par la clé d’idempotence. Deux incidents méritent d’être racontés, car ils ressemblent à ceux que vous rencontrerez.

Le rappel envoyé deux fois

Le service d’email a dépassé le délai d’attente. Le workflow a réessayé et le rappel est parti une seconde fois. Cause : la nouvelle tentative a repris avant que le statut d’envoi soit enregistré. Correction : vérifier le statut et journaliser l’envoi avant de réessayer.

Le changement d’heure

Une réservation à cheval sur le changement d’heure a été décalée d’une heure. Cause : une conversion en heure locale avant stockage. Correction : stocker en timestamptz, afficher en Europe/Paris, et tester les dates de changement.

Ce qui a été reporté : le paiement, l’application mobile et la connexion unique. Ils ne manquent pas. Ce que je ferais autrement : écrire le runbook avant la mise en production, ajouter un lien d’annulation dans l’email de confirmation, limiter les données personnelles dans les journaux et tester la restauration plus tôt.

Aucun de ces incidents n’est spectaculaire. C’est le quotidien d’un outil qui sert : des erreurs prévisibles, des corrections documentées et des décisions qu’on assume.

11. À vous de jouer

Prenez le cas et modifiez-le. Les exercices ci-dessous ont un livrable et un critère de réussite. Ils peuvent se faire sans écrire de code pour les deux premiers.

Exercice Livrable Critère de réussite
Écrire les dix questions du bureau. Une liste numérotée. Aucune question n’oblige à dupliquer une donnée pour y répondre.
Ajouter la contrainte de chevauchement. Une migration SQL. Deux insertions simultanées sur le même créneau : une seule passe.
Gérer l’annulation et la liste d’attente. Un modèle et trois règles. Une place libérée est proposée au premier de la liste, avec une échéance.
Écrire la réponse 409 et le message affiché. Un exemple JSON et un texte utilisateur. La personne comprend qu’elle n’a pas fait d’erreur et voit une alternative.
Rédiger le runbook. Une page, trois scénarios de panne. Une personne qui ne connaît pas le projet peut agir sans appeler l’auteur.
Refaire le calcul de coût avec vos chiffres. Un tableau à 12 et 36 mois. La conclusion assume ce qui n’est pas monétisé.

12. Journal de décisions

Les décisions importantes sont écrites, avec l’alternative écartée et la date de réexamen. C’est ce document qui évite de rediscuter les mêmes choix tous les trois mois.

Décision Alternative écartée Raison À revoir
PostgreSQL pour les réservations Airtable seul La contrainte de chevauchement doit être dans la base. Si le volume reste sous 20 demandes par mois et que personne ne peut administrer la base.
n8n pour les intégrations Tout écrire en code Les emails, les rappels et les exports sont plus rapides à brancher. Si le volume dépasse 1 000 réservations par mois.
Validation humaine en version 1 Confirmation automatique Les cas limites sont nombreux et le volume est faible. Après trois mois, si moins de 5 % des demandes demandent une correction.
Email seulement SMS Le budget ne le justifie pas et les adhérents lisent leurs emails. Si les rappels ne sont pas lus.
VPS dans l’Union européenne Service managé hors UE Coût, maîtrise et simplicité pour ce volume. Si les contraintes légales ou le budget changent.
Pas de compte adhérent Mot de passe et espace personnel Un lien signé suffit pour demander et annuler. Si le self-service devient le mode principal.
Ce que ce cas ne prouve pas : il ne prouve pas que n8n ou PostgreSQL sont toujours le bon choix. Il montre un enchaînement de décisions pour un volume, une équipe et une contrainte donnés. Changez le volume, les compétences ou la contrainte légale, et la réponse change. Le réflexe à garder est la question, pas la recette.
09

Progression & Ressources

Un plan de progression réaliste

Apprendre l’automatisation ressemble moins à suivre un cursus qu’à réparer des choses réelles. Les tutoriels donnent des idées ; les projets donnent des compétences. La difficulté est de choisir un projet assez petit pour être fini, et assez utile pour mériter l’effort.

Ce module propose un chemin en cinq niveaux, un plan de trente jours et des ressources. Il ne promet pas un métier en un mois. Il aide à savoir quoi faire ensuite, comment montrer ce que vous savez faire, et quand ralentir pour consolider.

Comment apprendre sans se perdre

Un tutoriel donne une carte ; un projet donne le territoire. La compétence se construit dans la boucle suivante : choisir un livrable petit, buter sur un problème réel, chercher juste ce qu’il faut, tester, puis noter ce qui a marché. Les vidéos et les cours restent utiles, mais ils ne remplacent pas cette boucle.

Le piège classique est d’enchaîner les tutoriels sans jamais finir. Si vous ne pouvez pas montrer le résultat à quelqu’un, ce n’est pas encore un projet. Fixez une date, un périmètre et une personne qui utilisera le résultat. Même imparfait, un outil terminé apprend plus qu’une démonstration abandonnée.

1

Niveau 1 : regarder la donnée

Comprendre comment la donnée voyage.

Projet de fin de niveau

Créer un formulaire Typeform qui remplit automatiquement un Google Sheet PROPREMENT (bonnes colonnes, format date).

📚 Ressources
  • YouTube : tutoriels Airtable pour débutants
  • Concept: Bases de données relationnelles
2

Niveau 2 : connecter deux outils

APIs & Webhooks. Make/Zapier.

Projet de fin de niveau

Un bot Slack qui notifie l’équipe quand une ligne Airtable passe en statut "Gagné", via Make.

📚 Ressources
  • Doc: "Introduction to REST APIs"
  • Outil : Postman (postman.com) pour tester les APIs
3

Niveau 3 : construire un système

Self-Hosting & Logic. n8n & SQL.

Projet de fin de niveau

Installer n8n sur Docker. Créer un Dashboard Clients sur Appsmith connecté à Supabase.

📚 Ressources
  • Chaînes YouTube spécialisées n8n
  • Cours : SQLBolt (sqlbolt.com, apprendre SQL en 1h)
4

Niveau 4 : ajouter de l’IA avec discernement

Agents, RAG & Embeddings.

Projet de fin de niveau

Un Chatbot Telegram qui peut répondre à des questions sur vos PDF personnels (RAG via Vector Store).

📚 Ressources
  • LangChain Documentation
  • Anthropic Prompt Engineering Guide
5

Niveau 5 : exploiter dans la durée

Ops, Scalability, Team.

Projet de fin de niveau

Déployer une stack HA (Haute Dispo). Mettre en place Git Sync pour n8n. Passer un audit de sécurité.

📚 Ressources
  • Book: "The Phoenix Project" (DevOps culture)
  • Docker & Kubernetes Mastery

Choisir un projet qui tient

Un bon projet d’apprentissage n’est pas le plus ambitieux. Il est assez petit pour être fini, assez réel pour avoir un utilisateur, et assez inconfortable pour vous obliger à apprendre. Quelques critères :

  • Un utilisateur identifiable : une personne, pas « les entreprises ».
  • Un périmètre de deux à quatre semaines : un formulaire, un export, une notification, un tableau de bord simple.
  • Des données accessibles : si vous passez trois semaines à obtenir un accès, choisissez un autre sujet.
  • Un retour rapide : l’utilisateur doit pouvoir essayer et dire ce qui bloque.
  • Une démonstration possible : avant/après, temps gagné, erreurs évitées.

Évitez le projet vitrine qui demande une authentification, un paiement, une application mobile et une IA le même mois. La tentation de tout mettre dans la première version est le meilleur moyen de ne rien livrer.

Durées et prérequis (ordres de grandeur)

À rythme libre, quelques heures par semaine. Des repères, pas des promesses : chacun avance à son pas.

Level 1 : 1 à 2 semaines. Prérequis : aucun, juste un tableur.

Level 2 : 2 à 4 semaines. Prérequis : Level 1 (lire une donnée, comprendre une API).

Level 3 : 1 à 2 mois. Prérequis : Level 2, plus un Docker local ou un VPS pour n8n.

Level 4 : 1 à 2 mois. Prérequis : Level 3 (workflows et SQL de base).

Level 5 : en continu. Prérequis : Level 4 et des projets réels à industrialiser.

Un plan de 30 jours, un livrable par semaine

La théorie ne tient pas sans livrable. Quatre semaines, quatre preuves à montrer, pas quatre tutoriels de plus.

Semaine 1 : un workflow utile

Un formulaire, une table, une notification. Livrable : le workflow exporté, sa note de cadrage et une capture du résultat.

Semaine 2 : une intégration API

Lecture de doc, authentification, pagination, gestion des erreurs. Livrable : un workflow qui traite 100 lignes sans doublon.

Semaine 3 : un agent borné

Un modèle, deux outils, un jeu de dix cas, une approbation humaine. Livrable : le taux de réussite et le coût par exécution.

Semaine 4 : la mise en production

Docker, sauvegarde, supervision, journal. Livrable : une panne provoquée et un retour arrière réussi.

Ressources à jour (2026)

Documentation et protocoles

Outils à installer

  • Postman ou Hoppscotch pour tester une API.
  • OpenCode (MIT) pour un harnais de code local.
  • LiteRT-LM (Apache-2.0) pour exécuter un modèle sur mobile ou dans le navigateur.
Portfolio : trois projets suffisent, à condition de montrer la décision autant que le résultat. Pour chacun : le problème, la contrainte, le choix technique, la mesure avant et après, et ce que vous feriez autrement. Un recruteur retient une décision argumentée, pas une capture d’écran de canvas.

Ce que l’on cherche à savoir faire

Regarder un problème, choisir l’outil le plus simple qui peut le résoudre, construire quelque chose de vérifiable, puis expliquer ses limites. Le reste s’apprend sur des projets réels, avec des personnes qui utilisent le résultat.

10

Business & Vente de Services

Vendre un travail utile, sans promettre l’impossible

Vendre de l’automatisation, ce n’est pas vendre des nœuds. C’est promettre un résultat observable : moins de saisie, un délai plus court, une erreur en moins. Le prix dépend de la valeur de ce résultat, pas du nombre d’heures passées à cliquer.

Nous allons voir comment cadrer une mission, formuler une offre, chiffrer le risque et écrire ce qui n’est pas inclus. Une prestation tient moins par la démonstration que par le périmètre et les conditions d’arrêt.

La Réalité du Marché :
Personne ne veut acheter "un script Python" ou "un scénario Make".
Les clients achètent : Du Temps, De la Sérénité, ou Du Cash (Leads).

Le piège de la valeur, c’est de l’inventer. « Ce système va vous faire gagner 100 000 euros » ne vaut rien si le client ne peut pas vérifier le chiffre. Une promesse crédible commence par une mesure actuelle : combien d’heures sont passées, combien d’erreurs sont constatées, quel délai est subi. Vous pouvez alors proposer un objectif, pas une garantie. Et si la mesure n’existe pas, le premier livrable est souvent de la créer.

A. Comment Facturer ?

❌ Taux Horaire (Hourly)

"Je coûte 500€ / jour."

Pourquoi ça échoue : Plus vous êtes rapide (via l’IA), moins vous gagnez d’argent. Vous êtes puni pour votre compétence.

✅ Value Based Pricing

"Ce système vous rapporte 100k€/an. Je le vends 10k€."

L’idéal : Déconnecte le temps passé du revenu. Demande de savoir chiffrer la douleur du client.

📦 Productized Service

"Pack Scraping LinkedIn : 500€."

Le Scalable : Périmètre fixe, Prix fixe, Livraison standardisée. Vente facile.

Le taux horaire n’est pas toujours une erreur. Il est honnête pour une mission d’exploration dont le périmètre est inconnu, ou pour un accompagnement ponctuel. Le problème commence quand il récompense la lenteur et punit l’expérience. La sortie est progressive : mesurer le temps réel sur deux ou trois missions, construire un forfait sur un périmètre stable, puis proposer un prix de valeur quand le gain est mesurable. Le forfait sans périmètre est plus dangereux que le taux horaire.

B. Le Pitch Deck (Convaincre)

1. Le "Cost of Inaction" (COI)

Ne dites pas "ça coûte 5000€".

Dites : "Chaque mois sans ce système, vous perdez 40h de salaire commercial, soit ~2000€. En 3 mois, ne rien faire vous coûte plus cher que ma solution."

2. Scalabilité sans Recrutement

"Voulez-vous doubler votre activité ? Si oui, voulez-vous devoir doubler vos effectifs et la gestion RH associée ?"

"L’automatisation permet de doubler le volume sans doubler la masse salariale."

Le coût de l’inaction se calcule avec le client, pas contre lui. Demandez les volumes, les salaires chargés, le temps de traitement, le taux d’erreur. Faites valider les hypothèses par écrit. Une estimation honnête avec une fourchette vaut mieux qu’un chiffre rond qui impressionne et qu’il faudra défendre plus tard. La crédibilité se construit sur la méthode, pas sur le pourcentage.

C. Clauses Contractuelles Vitales

⚠️ API Breaking Changes

"Le Prestataire ne peut être tenu responsable si une API tierce (ex: LinkedIn) change ses règles et casse le workflow."

Solution : Forfait Maintenance Obligatoire (15-20% du setup / an).
🔐 Propriété Intellectuelle

Le client est-il propriétaire du scénario Make ? Ou lui louez-vous l’usage ?

(En général : Le client paye pour le setup, il est propriétaire, mais vous gardez le droit de réutiliser vos briques génériques).

Les clauses que l’on oublie : qui fournit les accès et dans quel délai, ce qui se passe à la fin du contrat, si vous pouvez sous-traiter, jusqu’où va votre responsabilité en cas de perte de données, et comment le client récupère ses workflows et ses identifiants. Une clause de réversibilité honnête rassure plus qu’elle ne fragilise. Elle montre que vous n’enfermez pas le client.

D. Exemples de grilles (montants fictifs)

Les montants ci-dessous sont fictifs : ils montrent comment structurer une offre, pas ce que vaut le marché. Adaptez à votre pays, votre profil et la douleur du client.

Pack cadrage (productisé)

Audit des processus et plan d’automatisation chiffré, livré en une semaine. Exemple fictif : 900 € fixes.

Pack mise en place (valeur)

Workflow livré, documenté, testé. Prix indexé sur le gain client (exemple fictif : 10 % du gain annuel estimé, plancher 2 500 €).

Maintenance (récurrent)

Surveillance, correctifs, petites évolutions. Exemple fictif : 15 à 20 % du setup par an, comme rappelé en section C.

E. Trame de devis minimal

devis type : 7 lignes indispensables
1. Périmètre exact (ce qui est inclus, ce qui ne l'est pas)
2. Livrables (workflows, doc, accès, formation)
3. Prix fixe et modalités (30 % commande, 70 % livraison)
4. Délai et révisions incluses (exemple : 2)
5. Maintenance : incluse 30 jours, puis forfait annuel
6. Responsabilités si une API tierce casse (voir section C)
7. Propriété : client propriétaire, briques génériques réutilisables
Règle : tout ce qui n’est pas écrit sera négocié après, à vos dépens. Faites relire par un pro avant usage réel.
Conseil de fin : Ne commencez jamais un projet sans "Cahier des Charges" validé et signé. Sinon, vous ferez 20 révisions gratuites. Vérifiez aussi que toute collecte de données respecte les CGU des plateformes et le RGPD (pas de scraping LinkedIn sans base légale, préférez les API officielles).
11

🎁 Bonus Ressources

Les briques utiles d’un serveur personnel

Un service auto-hébergé n’est pas un fichier que l’on pose sur un serveur. Il a besoin d’un volume, d’une sauvegarde, d’une mise à jour, d’une supervision et de quelqu’un qui répond quand il tombe.

Ce module rassemble les briques utiles : Docker, stockage, notes, supervision. Nous allons regarder l’ordre de mise en place et les questions à poser avant d’ajouter un service. Le but n’est pas d’héberger trente outils, mais de faire tourner ceux dont vous avez vraiment besoin.

Au-delà du No-Code : Les outils essentiels pour bâtir un écosystème IT complet, souverain et professionnel.
Chaque catégorie = une brique de votre infrastructure.

Docker en deux minutes. Une image est une recette figée ; un conteneur est le plat préparé à partir de cette recette. Un volume est l’endroit où l’on garde les données quand le conteneur est recréé. Un réseau est la salle dans laquelle les conteneurs se parlent. Retenir ces quatre mots évite la plupart des confusions : supprimer un conteneur ne supprime pas ses volumes, et recréer une image ne met pas à jour les données.

⚙️ 1. Gestion de Services, Docker & Infra

⭐ Portainer

Tableau de bord web pour gérer Docker / Compose.

  • ✅ Containers, images, volumes, réseaux
  • ✅ Stacks applicatives
  • ✅ Permissions multi-utilisateurs
👉 Indispensable pour gérer un VPS sans CLI permanente.
Alt: Dockge (moderne, docker-compose), Rancher (K8s)

⭐ Homarr / Dashy / Heimdall

Dashboards "Homepage" pour lister tous vos services.

  • ✅ Liens, statuts, icônes
  • ✅ Homarr : moderne, self-hosting
  • ✅ Dashy : ultra personnalisable (YAML)
👉 Point d’entrée unique vers votre écosystème.

L’ordre de mise en place

L’ordre compte plus que la liste. Un service installé avant les sauvegardes est un service qui peut disparaître. Une procédure proposée, du plus structurant au plus visible :

  1. Nom de domaine, reverse proxy et TLS : une seule porte d’entrée, des certificats renouvelés automatiquement.
  2. Coffre à secrets : les mots de passe ne vivent pas dans un fichier docker-compose.yml versionné.
  3. Sauvegardes et test de restauration : avant d’ajouter la première application qui compte.
  4. Supervision : une sonde qui prévient avant que l’utilisateur ne découvre la panne.
  5. Applications : une par une, avec un volume et une sauvegarde documentés.

💾 2. Stockage & Synchronisation de Fichiers

⭐ Nextcloud

Alternative complète à Google Drive / Workspace.

  • ✅ Fichiers, partage
  • ✅ Calendrier, contacts, tâches
  • ✅ Collaboration (OnlyOffice)
👉 Très polyvalent, mais lourd.

⭐ Seafile

Stockage & synchro ultra performant.

  • ✅ Clients desktop & mobile
  • ✅ Chiffrement, sync rapide
👉 Plus léger que Nextcloud.

ownCloud

Plus orienté entreprises / conformité.

Stockage objet S3 : MinIO n’est plus un bon choix par défaut : son dépôt est archivé depuis le 24 avril 2026. Pour un petit hôte, Garage (AGPL-3.0) suffit ; pour un cluster, SeaweedFS ou RustFS (Apache-2.0) sont des alternatives suivies. Vérifiez la compatibilité S3 de votre client avant de migrer.

Une sauvegarde, trois copies. La règle 3-2-1 reste un bon repère : trois copies, deux supports différents, une copie hors site. Une sauvegarde sur le même serveur ne protège ni d’une panne disque, ni d’un rançongiciel, ni d’une suppression accidentelle. Et une sauvegarde jamais restaurée est une hypothèse. Testez la restauration sur un dossier vide, notez la durée, puis corrigez la procédure.

📝 3. Notes, Documentation, Wikis

⭐ Wiki.js

Wiki moderne et propre.

  • ✅ Markdown + éditeur visuel
  • ✅ Permissions avancées
  • ✅ Stockage Git, DB, S3
👉 Excellent pour docs internes & projets IT.

⭐ HedgeDoc

Notes collaboratives Markdown temps réel.

  • ✅ Brainstorming, docs rapides
Alt: Outline (Notion-like), BookStack (wiki hiérarchique)

💬 4. Communication & Chat

⭐ Matrix (Synapse) + Element

Messagerie décentralisée.

  • ✅ Salons, messages privés
  • ✅ Ponts Slack/WhatsApp/Telegram
👉 Standard open-source du chat moderne.

⭐ Rocket.Chat / Mattermost

Alternatives Slack auto-hébergées.

  • ✅ Chat équipe, intégrations, bots
  • ✅ Mattermost : très utilisé DevOps

Mumble

Serveur voix basse latence.

  • ✅ Réunions, gaming, usage pro
👉 Simple, robuste, efficace.

📧 5. Emails & Newsletters

⭐ Mailcow

Stack mail complète clé en main.

  • ✅ SMTP / IMAP / Webmail
  • ✅ Antispam, Antivirus
  • ✅ Admin UI complète
👉 Une solution complète pour le mail auto-hébergé.
Alt: Mailu (plus léger/modulaire)

⭐ Listmonk

Gestion de newsletters et mailing lists.

  • ✅ Très rapide, API
  • ✅ Interface moderne
  • ✅ Scaling élevé
👉 Bien meilleur que beaucoup de SaaS.

🔁 6. Automatisation & No-Code (Rappel)

⭐ n8n

Pilier central : APIs, BDD, SaaS, Webhooks, IA.

Activepieces

Alternative Zapier-like plus simple.

Apache Airflow

Orchestrateur data/ETL (plus technique).

🎬 7. Médias (Photos, Vidéos, Musique)

⭐ Jellyfin

Serveur multimédia open-source.

  • ✅ Films, séries, musique
  • ✅ Clients TV, mobile, web
👉 Alternative libre à Plex.

⭐ PhotoPrism

Gestion de photos type Google Photos.

  • ✅ Classement, tags, recherche

⭐ Immich

Alternative moderne à Google Photos.

  • ✅ UX très soignée
  • ✅ Synchro mobile
  • ✅ Reconnaissance faciale
👉 Très populaire en 2026.

🧠 8. Productivité Personnelle & Collaboration

⭐ Joplin

Prise de notes chiffrée, synchro auto-hébergeable (alt. Evernote).

⭐ WBO / Excalidraw

Tableaux blancs collaboratifs (schémas, ateliers).

Radicale

Serveur CalDAV/CardDAV (agenda, contacts).

👉 Remplace Google Calendar/Contacts.

Vikunja

Gestion de tâches / Kanban open-source. (Focalboard : passé en maintenance communautaire, déconseillé pour un nouveau déploiement.)

🧩 9. Bonus IT / Vibe Coding Moderne

🔐 Auth & Identité

  • ⭐ Keycloak
  • Authelia
  • Ory (Hydra, Kratos)

📊 Monitoring & Logs

  • ⭐ Grafana + Prometheus
  • ⭐ Uptime Kuma
  • Netdata
  • Loki (logs)

🧠 IA Self-Hostée

  • ⭐ Ollama
  • LocalAI
  • Dify
  • Qdrant / Milvus (Vector DB)

Ce que je n’hébergerais pas sans nécessité : le serveur de mail entrant, le DNS critique, le paiement et les sauvegardes hors site. Ces briques ont un coût de panne très supérieur à leur abonnement, et demandent une expertise qui ne s’improvise pas. L’auto-hébergement est un moyen, pas un concours de pureté.

Conseil de départ : commencez petit (Portainer, un dashboard, n8n), puis ajoutez les briques selon vos besoins réels. Un VPS modeste peut déjà rendre service ; il ne devient pas une infrastructure robuste par le seul nombre de conteneurs.
16

Fiches mémo

Quatorze résumés d’une page, à relire avant de construire

Une fiche n’est pas un résumé du cours : c’est une liste de vérification pour le jour où vous construisez. Elle dit ce qu’il faut retenir, ce qui casse le plus souvent et ce qu’il faut regarder avant de livrer. Si une fiche vous suffit pour agir, tant mieux. Si elle révèle un doute, le module correspondant est là pour ça.

Les fiches sont datées du 11 novembre 2026. Elles vieilliront, comme le reste. Imprimez-les, annotez-les, corrigez-les avec votre contexte. Une fiche qui n’est jamais contredite par la pratique est probablement une fiche qu’on ne lit pas.

La version imprimée masque la navigation et les bannières. Chaque fiche évite d’être coupée entre deux pages quand le navigateur le permet.

Module 01

No-code, low-code, vibe coding

À retenir

  • No-code : livrer vite une interface ou un branchement, souvent avec un abonnement par utilisateur.
  • Low-code : garder la main sur les données et une partie du code, en acceptant des mises à jour et de la maintenance.
  • Vibe coding : accélérer l’écriture avec un modèle, sans supprimer la spécification, la revue et les tests.
  • Le choix dépend de la fréquence, du volume, des compétences et de la sortie possible.
  • Un outil qui ne permet pas d’exporter ses données est déjà un piège.

Pièges fréquents

  • Choisir l’outil avant d’avoir écrit le problème.
  • Confondre démonstration réussie et système maintenable.
  • Oublier le coût par utilisateur et le temps de migration.

Checklist

  • Le problème tient en une phrase.
  • Une personne non technique peut tester le résultat.
  • Les données peuvent sortir dans un format lisible.
  • Le coût mensuel est connu à douze mois.

Relire le module 1

Module 02

Intelligence artificielle

À retenir

  • Entraînement : ajuster des poids sur des données. Inférence : calculer une réponse à partir d’un contexte.
  • Un modèle de langage ne mémorise pas la conversation : ce qu’il « sait » doit être dans le contexte envoyé.
  • Le RAG ajoute des documents retrouvés. Le fine-tuning change un comportement. Ni l’un ni l’autre ne corrige un mauvais corpus.
  • Un embedding mesure une proximité statistique, pas une vérité.
  • Le bon indicateur est le coût par tâche réussie, pas le prix au million de tokens.

Pièges fréquents

  • Promettre une réponse fiable sans mesurer le rappel des documents.
  • Comparer des prix qui ne couvrent pas le même contexte.
  • Prendre un benchmark pour une garantie sur votre cas.

Checklist

  • Vingt questions réelles servent de test.
  • Le bon document arrive dans les premiers résultats.
  • Le format de sortie est vérifié automatiquement.
  • Le coût inclut les tentatives et les évaluations.

Relire le module 2

Module 03

Architecture n8n

À retenir

  • Un workflow transporte des items. Chaque nœud reçoit un tableau et renvoie un tableau.
  • Une expression lit l’item courant ou un item précis d’un nœud précédent.
  • pairedItem conserve le lien entre une sortie et l’item d’entrée.
  • Un filtre qui ne laisse rien passer produit zéro item, pas une erreur.
  • Un sous-workflow isole une logique, à condition de documenter ses entrées et sorties.

Pièges fréquents

  • Chercher l’erreur dans le canvas alors que le journal d’exécution la montre.
  • Empiler des nœuds là où cinq lignes lisibles suffiraient.
  • Modifier un sous-workflow sans vérifier ses appelants.

Checklist

  • Le dernier nœud vert a été inspecté.
  • Le cas « zéro item » est testé.
  • La branche d’erreur est branchée.
  • Le workflow est lisible six mois plus tard.

Relire le module 3

Module 04

Agents et MCP

À retenir

  • Un agent est une boucle : observer, choisir une action, l’exécuter, regarder le résultat.
  • L’agent est utile quand le chemin n’est pas connu à l’avance. Il coûte cher quand une règle suffit.
  • MCP standardise les outils et le transport, pas la confiance ni la sécurité.
  • Une réponse d’outil est une donnée non fiable : elle peut contenir une instruction injectée.
  • Une flotte d’agents a besoin d’un superviseur, de traces et de limites.

Pièges fréquents

  • Donner à l’agent plus de droits que la tâche ne demande.
  • Confondre mémoire longue et vérité : elle accumule aussi les erreurs.
  • Évaluer sur une démonstration au lieu d’un jeu de cas.

Checklist

  • Le chemin pouvait-il être écrit à l’avance ?
  • Les outils autorisés sont listés.
  • Chaque action irréversible demande une validation.
  • Les traces permettent de rejouer un échec.

Relire le module 4

Module 05

Construire sa stack

À retenir

  • Il n’y a pas de meilleure stack, seulement des compromis datés.
  • Le coût total inclut licences, hébergement, sauvegardes, maintenance et migration.
  • Le temps de maintenance est une ligne de coût, même s’il n’est pas facturé.
  • Un outil auto-hébergé déplace la dépense vers l’exploitation.
  • La sortie compte : export, API, format ouvert, documentation.

Pièges fréquents

  • Comparer uniquement l’abonnement et le prix du VPS.
  • Choisir une stack pour une démonstration qui ne passera pas l’échelle.
  • Oublier qui répare à deux heures du matin.

Checklist

  • Le coût à douze et trente-six mois est écrit.
  • La procédure de sauvegarde est prévue.
  • Une migration est techniquement possible.
  • La personne qui maintient est identifiée.

Relire le module 5

Module 06

Gouvernance

À retenir

  • La gouvernance, c’est ce qui reste quand la personne qui a construit s’en va.
  • Un nom de workflow doit dire l’environnement, le département et l’objet.
  • Le moindre privilège limite les dégâts d’une clé qui fuite.
  • Une sauvegarde non testée n’est pas une sauvegarde.
  • Une erreur silencieuse est plus dangereuse qu’une erreur bruyante.

Pièges fréquents

  • Mettre les secrets dans un fichier versionné.
  • Donner un accès administrateur « pour aller plus vite ».
  • Copier la sauvegarde sur le même disque que la production.

Checklist

  • Les secrets sont dans un coffre.
  • Une restauration a été testée.
  • Le chemin d’erreur envoie une alerte.
  • Les rôles et les départs sont documentés.

Relire le module 6

Module 07

Open source et licences

À retenir

  • Open source OSI, open weights, fair-code et commercial ne donnent pas les mêmes droits.
  • Une licence se lit dans le fichier LICENSE, pas dans un badge.
  • L’AGPL impose des obligations quand le service est offert sur un réseau.
  • Le fair-code peut interdire la revente d’un accès hébergé.
  • Les étoiles mesurent l’attention, pas la santé du projet.

Pièges fréquents

  • Confondre « code visible » et « open source ».
  • Installer un dépôt archivé sans le savoir.
  • Ignorer les modules enterprise et les marques.

Checklist

  • La licence est lue pour l’usage prévu.
  • Le dernier commit et la dernière release sont datés.
  • Les issues récentes ont des réponses.
  • L’export des données est possible.

Relire le module 7

Module 08

Modélisation des données

À retenir

  • Une table décrit un sujet. Une colonne dépend de la clé de sa table.
  • Une clé primaire technique ne change pas. Un email ou un nom, si.
  • Une clé étrangère relie deux tables et protège l’intégrité.
  • Une contrainte en base protège aussi les imports et les scripts.
  • Un index accélère une lecture, au prix d’une écriture plus lente.

Pièges fréquents

  • Stocker plusieurs valeurs dans un champ.
  • Stocker une date en texte.
  • Modeler l’écran au lieu du métier.

Checklist

  • Dix questions métier sont écrites.
  • Les relations 1:N et N:N sont explicites.
  • Les contraintes sont en base.
  • Les champs souvent filtrés sont indexés.

Relire le module 8

Module 09

Progression et ressources

À retenir

  • Un tutoriel donne une carte. Un projet donne le territoire.
  • Un bon projet est petit, réel, avec un utilisateur et un délai.
  • La boucle utile : livrer, buter, chercher, corriger, noter.
  • Un livrable daté vaut mieux qu’une démonstration abandonnée.
  • Montrer une décision et une limite est plus crédible qu’un catalogue d’outils.

Pièges fréquents

  • Enchaîner les cours sans jamais finir.
  • Vouloir authentification, paiement, mobile et IA dans la première version.
  • Choisir un projet dont les données sont inaccessibles.

Checklist

  • Un utilisateur est nommé.
  • Le périmètre tient en quatre semaines.
  • Une démonstration avant/après est possible.
  • Le temps passé est noté.

Relire le module 9

Module 10

Vendre un service

À retenir

  • On ne vend pas des nœuds, on promet un résultat observable.
  • Une mesure actuelle précède toute estimation de gain.
  • Le taux horaire est honnête pour l’exploration, risqué pour la production.
  • Un forfait sans périmètre est plus dangereux qu’un taux horaire.
  • La réversibilité rassure : le client doit pouvoir partir.

Pièges fréquents

  • Inventer un pourcentage d’économie.
  • Oublier les accès, la maintenance et la fin de contrat.
  • Facturer la valeur d’un gain que le client ne peut pas vérifier.

Checklist

  • Les volumes et hypothèses sont validés par écrit.
  • Le périmètre exclut explicitement ce qui n’est pas fait.
  • La responsabilité et la réversibilité sont écrites.
  • Le prix tient compte du risque.

Relire le module 10

Module 11

Auto-hébergement

À retenir

  • Une image est une recette, un conteneur est le plat préparé.
  • Un volume survit à la recréation du conteneur. Supprimer un conteneur ne supprime pas ses volumes.
  • L’ordre compte : accès, sauvegardes, supervision, puis applications.
  • 3-2-1 : trois copies, deux supports, une hors site.
  • Tout service auto-hébergé a besoin d’un propriétaire et d’une procédure.

Pièges fréquents

  • Installer dix services avant la première sauvegarde.
  • Mettre les mots de passe dans le fichier compose.
  • Héberger le mail entrant ou le paiement sans compétence dédiée.

Checklist

  • Le reverse proxy et TLS fonctionnent.
  • Une restauration a été testée sur un dossier vide.
  • Une sonde prévient en cas de panne.
  • Chaque volume est sauvegardé.

Relire le module 11

Module 12

Comprendre les API

À retenir

  • Une API est un contrat : méthode, URL, en-têtes, corps, statut.
  • Un 200 ne garantit pas un contenu correct. Un 400 ne dit pas toujours quel champ est fautif.
  • L’authentification identifie, l’autorisation décide.
  • La pagination par curseur résiste mieux aux insertions que l’offset.
  • Une écriture rejouée doit être idempotente.

Pièges fréquents

  • Mettre un jeton de test en production.
  • Réessayer un 400 ou un 401 sans changer la requête.
  • Boucler sur mille éléments sans limite ni backoff.

Checklist

  • Un GET sur une seule ligne fonctionne.
  • Les statuts 400, 409, 429 et 500 sont traités.
  • La clé d’idempotence est envoyée.
  • L’identifiant de requête est journalisé.

Relire le module 12

Module 13

UI et UX des outils internes

À retenir

  • Un outil interne échoue quand il demande plus d’effort que l’ancienne méthode.
  • DASH : densité, action, statut, hiérarchie.
  • Un message d’erreur dit ce qui s’est passé, pourquoi et quoi faire.
  • Un bon formulaire empêche l’erreur avant de la signaler.
  • Les états vide, chargement, erreur et succès font partie de l’écran.

Pièges fréquents

  • Afficher « Erreur 500 » comme seul message.
  • Cacher une action irréversible derrière un clic trop facile.
  • Oublier le clavier, le focus et le contraste.

Checklist

  • L’écran se comprend sans mode d’emploi.
  • Les erreurs indiquent le champ et la correction.
  • Les actions risquées demandent confirmation.
  • Le parcours clavier est testé.

Relire le module 13

Module 14

Extraits de code

À retenir

  • Le nœud Code est utile quand la transformation est difficile à exprimer visuellement.
  • Un nœud natif reste préférable quand il suffit et qu’il est lisible.
  • map transforme, filter sélectionne, reduce agrège.
  • Une date se stocke avec un fuseau, pas dans une chaîne locale.
  • Une regex se teste sur des cas réels, y compris vides.

Pièges fréquents

  • Coller un extrait sans comprendre ce qu’il fait.
  • Lancer un script sur mille items sans test sur un seul.
  • Attraper toutes les erreurs pour faire disparaître le symptôme.

Checklist

  • L’extrait gère null et absent.
  • Le résultat est vérifié sur un item.
  • Le code est plus lisible que les nœuds équivalents.
  • L’erreur est reproduite avant d’être corrigée.

Relire le module 14

17

Glossaire

Les mots du mémo, définis une fois et reliés au contexte

Un même mot peut désigner deux choses selon le module. Ce glossaire fixe le sens utilisé ici, avec des définitions courtes et, quand c’est utile, ce que le terme ne veut pas dire. Il n’est ni exhaustif ni juridique : pour une licence ou un traitement de données, lisez le texte officiel et demandez un avis compétent.

Les définitions sont datées du 11 novembre 2026. Les sigles sont regroupés avec leur forme longue. Utilisez le champ de recherche pour filtrer par terme, par sigle ou par mot de la définition. Les puces de vocabulaire des modules ouvrent une définition rapide, parfois plus courte.

115 termes

Automatisation et exploitation

Automatisation
Exécution d’une tâche par un système, avec un déclencheur et des règles, sans intervention humaine à chaque occurrence. Automatiser une tâche mal comprise ne fait qu’accélérer l’erreur.
Workflow
Suite d’étapes ordonnées qui transforment une entrée en résultat. Il peut être déterministe, assisté par IA, ou un mélange des deux.
Nœud
Unité d’un workflow visuel. Il reçoit des données, les transforme et les transmet à l’étape suivante. Dans n8n, un nœud manipule des items.
Déclencheur
Événement qui démarre un workflow : horaire, formulaire, webhook, nouvel enregistrement ou appel manuel.
Webhook
URL exposée par un service pour recevoir un événement envoyé par un autre service. Il évite d’interroger la source en boucle.
Polling
Interrogation régulière d’une source pour savoir si quelque chose a changé. Simple à mettre en place, mais coûteux en appels et en latence.
Orchestration
Coordination de plusieurs services ou étapes, avec un ordre, des conditions et une gestion des erreurs.
Idempotence
Propriété d’une opération qui produit le même résultat si on la rejoue. Indispensable après un timeout : sans elle, une écriture peut être faite deux fois.
File d’attente
Stockage temporaire des tâches en attente. Elle absorbe les pics et découple celui qui produit de celui qui traite.
Nouvelle tentative (retry)
Rejouer une opération après un échec. À réserver aux erreurs temporaires, avec un délai et un nombre de tentatives limités.
Backoff exponentiel
Attendre de plus en plus longtemps entre les tentatives pour ne pas aggraver la surcharge d’un service déjà en difficulté.
Runbook
Procédure courte qui dit quoi faire quand un service tombe, qui prévenir, comment vérifier le retour à la normale et où trouver les accès.
Observabilité
Capacité à comprendre l’état d’un système à partir de ses traces, de ses métriques et de ses journaux.
Journal (log)
Trace datée d’un événement. Utile pour diagnostiquer, à condition de ne pas y stocker de mots de passe ni de données personnelles inutiles.
Supervision
Surveillance automatique d’un service, avec alerte quand il ne répond plus ou dépasse un seuil.
Environnement
Copie d’un système avec ses propres données et accès : développement, préproduction, production. Ne jamais tester une suppression en production.

No-code, low-code et produit

No-code
Approche qui permet de construire une application ou un workflow avec une interface visuelle, sans écrire de code. Elle déplace l’effort vers la configuration et la compréhension des limites de l’outil.
Low-code
Approche visuelle qui laisse la place à du code, à des requêtes ou à des scripts pour les cas que l’interface ne couvre pas. Elle demande souvent une compétence technique minimale pour durer.
Vibe coding
Écriture de code assistée par un modèle de langage, guidée par l’intention et les itérations. Le mot ne dispense ni de spécification, ni de revue, ni de tests.
Citizen developer
Personne d’un métier qui construit ses propres outils avec des plateformes no-code ou low-code, souvent sans faire partie de l’équipe informatique.
MVP
Produit minimum viable : la plus petite version qui permet d’apprendre quelque chose d’utile auprès de vrais utilisateurs. Ce n’est pas une version bâclée.
POC
Proof of concept, ou preuve de concept. Objectif : vérifier qu’une idée est techniquement possible, pas livrer un système maintenable.
Service productisé
Prestation décrite avec un périmètre, un livrable, un prix et un délai fixes, pour réduire les négociations à chaque mission.
Verrouillage fournisseur
Situation où changer d’outil devient coûteux parce que les données, les intégrations ou les compétences sont captives. Un export incomplet est un signal d’alerte.
Dette technique
Coût futur créé par un raccourci présent : contournement, dépendance non documentée, test absent. Elle n’est pas interdite, mais elle doit être visible et remboursée.

Données

Base de données relationnelle
Base organisée en tables reliées par des clés, interrogée avec un langage comme SQL. Elle excelle quand les règles et l’intégrité comptent.
Table
Ensemble de lignes qui décrivent le même type de sujet : clients, commandes, réservations. Une table ne devrait décrire qu’un sujet.
Enregistrement
Une ligne d’une table, avec une valeur pour chaque colonne. En anglais : row ou record.
Champ
Une colonne d’une table, avec un type et parfois une contrainte. Le choix du type (texte, date, nombre) évite beaucoup d’erreurs.
Clé primaire
Valeur unique qui identifie une ligne. Préférez une clé technique sans signification métier : un email ou un nom peut changer.
Clé étrangère
Colonne qui référence la clé primaire d’une autre table. Elle relie les données et empêche une commande de pointer vers un client inexistant.
Relation 1:N
Un enregistrement d’une table peut être lié à plusieurs enregistrements d’une autre : un client a plusieurs commandes.
Relation N:N
Plusieurs enregistrements d’une table peuvent être liés à plusieurs de l’autre : des étudiants et des cours. Elle passe souvent par une table de liaison.
Schéma
Description de la structure d’une base : tables, colonnes, types, clés et contraintes. Il doit pouvoir être recréé à partir d’une migration.
Normalisation
Organisation des données pour éviter les doublons et les contradictions : chaque information dépend de sa table et de sa clé.
Dénormalisation
Duplication volontaire d’une donnée pour accélérer une lecture. Elle n’est acceptable que si l’on sait quelle copie fait autorité et comment la recalculer.
Contrainte
Règle imposée par la base : valeur obligatoire, unicité, référence existante, date de fin après la date de début. Elle protège aussi les imports et les scripts.
Index
Structure qui accélère certaines lectures, au prix d’un peu d’espace et d’écritures plus lentes. Un index sur une colonne que personne ne filtre ne sert à rien.
Transaction
Groupe d’opérations qui réussissent ou échouent ensemble. Elle évite un état intermédiaire incohérent, par exemple un paiement sans commande.
Jointure
Opération qui combine des lignes de plusieurs tables à partir d’une condition, souvent une clé étrangère. Une jointure mal maîtrisée peut multiplier les lignes.
SQL
Langage d’interrogation et de manipulation des bases relationnelles. Lire un EXPLAIN vaut souvent mieux qu’ajouter un index au hasard.
JSON
Format texte de données structurées, très utilisé par les API. Pratique pour transporter un objet, moins pour filtrer des champs que l’on interroge souvent.
CSV
Fichier texte de lignes et de colonnes séparées par un délimiteur. Simple, mais fragile sur les dates, les accents, les guillemets et les séparateurs.
Migration
Script qui fait évoluer le schéma d’une base : ajout d’une colonne, création d’une table, changement de type. Elle doit être versionnée et réversible quand c’est possible.
Sauvegarde
Copie des données permettant de reconstruire un système après une panne ou une erreur. Une copie sur le même disque que la production ne protège pas d’une panne matérielle.
Restauration
Action de remettre une sauvegarde en service. Elle se teste : durée, procédure, données présentes, accès rétablis. Une sauvegarde jamais restaurée reste une hypothèse.
RPO et RTO
RPO : quantité de données que l’on accepte de perdre, exprimée en temps. RTO : durée acceptable avant le retour du service. Les deux orientent la stratégie de sauvegarde.

IA et agents

Modèle de langage (LLM)
Modèle entraîné à prédire la suite probable d’un texte. Il produit une réponse à partir d’un contexte, sans base de vérité ni mémoire automatique de la conversation.
Token
Unité de texte manipulée par un modèle, souvent un morceau de mot. Les prix et les limites de contexte sont exprimés en tokens, pas en mots.
Fenêtre de contexte
Quantité maximale de tokens qu’un modèle peut prendre en compte en une fois. Au-delà, il faut résumer, découper ou retrouver les passages utiles.
Prompt
Instruction et contexte envoyés au modèle. Un prompt utile décrit la tâche, le format attendu, les contraintes et parfois un exemple.
Prompt système
Instruction placée avant l’échange et censée définir le rôle ou les règles. Elle oriente le modèle, mais ne le rend pas invulnérable à une injection.
Injection de prompt
Contenu malveillant placé dans un document ou une réponse d’outil pour détourner les instructions du modèle. Toute donnée externe doit être traitée comme non fiable.
Embedding
Représentation d’un texte sous forme de vecteur, utilisée pour mesurer une proximité. Deux contenus proches statistiquement ne sont pas nécessairement pertinents pour la question.
RAG
Retrieval Augmented Generation : retrouver des passages dans un corpus, puis les donner au modèle pour répondre. Le RAG dépend d’abord de la qualité du corpus et du découpage.
Fine-tuning
Entraînement complémentaire d’un modèle sur des exemples pour modifier son comportement ou son style. Il ne remplace pas une base de connaissances à jour.
Hallucination
Réponse plausible mais fausse, produite sans signal d’erreur. Elle se réduit par de meilleures sources, des citations et une vérification, pas par la seule formulation du prompt.
Température
Paramètre qui rend la génération plus ou moins aléatoire. Une température basse aide à la régularité, elle ne garantit pas l’exactitude.
Quantification
Réduction de la précision des poids d’un modèle pour économiser de la mémoire. Elle peut dégrader légèrement la qualité et doit être évaluée sur vos cas.
Multimodal
Modèle capable de traiter plusieurs types de contenus : texte, image, audio, parfois vidéo. Vérifiez ce qui est réellement accepté en entrée et en sortie.
Agent
Système qui boucle : observer un état, choisir une action, l’exécuter, regarder le résultat. Il est utile quand le chemin n’est pas connu à l’avance.
Boucle ReAct
Schéma d’agent qui alterne raisonnement et action, puis réinjecte l’observation. Elle peut tourner en rond, inventer un outil ou choisir de mauvais arguments.
Outil (tool)
Fonction exposée à un modèle : lire un fichier, appeler une API, chercher dans une base. Un outil mal décrit ou trop permissif est une source d’erreur.
MCP
Model Context Protocol : protocole qui standardise la description et l’appel d’outils par un hôte. Il facilite les connexions, pas la confiance dans les outils.
Serveur MCP
Programme qui expose des outils, des ressources ou des prompts à un client MCP. Il faut décider quels serveurs sont autorisés et à quelles données ils accèdent.
Mémoire d’agent
Stockage d’informations entre plusieurs tours ou sessions. Utile pour un suivi, dangereuse si elle conserve des erreurs, des secrets ou des données périmées.
Harnais
Ensemble qui entoure le modèle : outils, permissions, contexte, mémoire, traces et limites. C’est souvent lui qui fait la différence entre une démo et un agent utilisable.
Évaluation (eval)
Jeu de cas reproductibles qui mesure si un modèle ou un agent fait le travail attendu. Sans eval, on ne compare que des impressions.

API et web

API
Interface de programmation qui permet à deux logiciels de se parler selon un contrat : méthodes, formats, erreurs et limites.
REST
Style d’architecture web organisé autour de ressources identifiées par des URL et manipulées par des méthodes HTTP. Ce n’est pas une garantie de qualité.
Endpoint
URL précise d’une API, par exemple /api/reservations. Elle peut accepter plusieurs méthodes avec des comportements différents.
Méthode HTTP
Verbe qui indique l’intention : GET lit, POST crée, PUT remplace, PATCH modifie, DELETE supprime. Les conventions ne sont pas toujours respectées à la lettre.
En-tête
Métadonnée d’une requête ou d’une réponse : type de contenu, authentification, limite de débit, identifiant de requête. Les ignorer, c’est perdre la moitié du contrat.
Corps
Contenu transporté par une requête ou une réponse, souvent du JSON. GET et HEAD ne devraient pas en transporter.
Code de statut
Nombre à trois chiffres qui résume le résultat : 200 succès, 201 création, 400 requête invalide, 401 non authentifié, 403 interdit, 404 absent, 409 conflit, 429 trop de requêtes, 500 erreur serveur.
Authentification
Vérifier l’identité de l’appelant. Elle répond à la question « qui êtes-vous ? ».
Autorisation
Décider ce que l’appelant a le droit de faire. Elle répond à la question « avez-vous le droit ? ». Un utilisateur authentifié n’est pas automatiquement autorisé.
Clé d’API
Secret qui identifie un client. Elle doit être limitée à un usage, stockée dans un coffre et révoquée quand elle n’est plus nécessaire.
OAuth 2.0
Cadre d’autorisation qui permet à une application d’obtenir un jeton d’accès sans connaître le mot de passe de l’utilisateur. OpenID Connect ajoute la couche identité.
Jeton
Valeur transmise à chaque appel pour prouver une identité ou un droit. Un jeton porte souvent une durée de vie et un périmètre.
JWT
JSON Web Token : jeton signé qui contient des informations sous forme de claims. La signature protège l’intégrité, pas la confidentialité du contenu.
Pagination
Découpage d’un résultat en pages. L’offset est simple mais instable quand des lignes sont insérées ; le curseur est plus robuste pour une synchronisation.
Limite de débit
Nombre maximal d’appels autorisés sur une période. Elle se lit dans les en-têtes et se respecte avec un backoff, pas en réessayant immédiatement.
Signature de webhook
Empreinte cryptographique ajoutée à un événement pour prouver qu’il vient bien du service attendu et qu’il n’a pas été modifié.
CORS
Mécanisme du navigateur qui autorise ou refuse une requête vers une autre origine. Ce n’est pas une authentification et cela ne protège pas une API appelée hors navigateur.
TLS
Chiffrement et authentification de la connexion réseau, visible par le cadenas et le préfixe HTTPS. Il protège le transport, pas les données stockées sur le serveur.

Infrastructure

Conteneur
Environnement isolé qui exécute une application à partir d’une image. Le conteneur est le plat préparé ; l’image est la recette.
Image
Modèle figé qui contient le système, les dépendances et l’application nécessaires pour créer un conteneur.
Volume
Stockage persistant monté dans un conteneur. Il survit à la recréation du conteneur, mais doit être sauvegardé séparément.
Réseau Docker
Réseau virtuel qui permet aux conteneurs de se joindre par leur nom de service. Il isole les services de l’extérieur, sauf ports publiés.
Docker Compose
Fichier déclaratif qui décrit plusieurs services, leurs volumes, leurs réseaux et leurs variables d’environnement. Les secrets ne doivent pas y être écrits en clair.
Reverse proxy
Serveur qui reçoit les requêtes et les transmet aux services internes. Il gère souvent TLS, le routage, la compression et parfois les limites de débit.
VPS
Serveur virtuel privé. Vous gérez le système, les mises à jour, les sauvegardes et l’astreinte, même si l’hébergeur gère la machine physique.
DNS
Système qui traduit un nom de domaine en adresse. Le délai de propagation dépend du TTL et des caches, pas seulement de l’hébergeur.
Stockage objet
Stockage de fichiers organisé en objets et en compartiments, accessible par HTTP ou une API compatible S3. Adapté aux fichiers, pas aux transactions relationnelles.
CDN
Réseau de serveurs qui rapproche les contenus statiques des utilisateurs. Il réduit la latence et la charge, à condition de gérer correctement le cache.
CI/CD
Chaîne automatisée qui construit, teste et déploie une application à chaque changement. Elle ne remplace pas la revue, elle rend les erreurs plus visibles.

Gouvernance et licences

RGPD
Règlement européen sur la protection des données personnelles, applicable depuis 2018. Il fixe des principes et des obligations ; ce glossaire n’est pas un avis juridique.
Donnée personnelle
Toute information qui permet d’identifier une personne physique, directement ou indirectement : nom, email, adresse IP, identifiant de compte.
Minimisation
Principe qui consiste à ne collecter que les données nécessaires à la finalité annoncée, pour la durée nécessaire.
Durée de conservation
Période pendant laquelle une donnée est gardée. Elle doit être justifiée par l’usage ou une obligation légale, puis la donnée est supprimée ou anonymisée.
Moindre privilège
Donner à chaque compte, clé ou service uniquement les droits nécessaires à sa tâche. Cela réduit les dégâts en cas de fuite ou d’erreur.
Secret
Information qui donne un accès : mot de passe, clé d’API, certificat, jeton. Un secret ne vit ni dans un dépôt Git, ni dans un fichier de workflow exporté.
Coffre à secrets
Outil qui stocke et distribue les secrets de façon contrôlée. Il ne remplace pas une politique de rotation et de moindre privilège.
Rotation des secrets
Remplacement régulier d’une clé ou d’un mot de passe. La procédure doit être testée avant l’urgence, sinon elle casse le service le jour où elle est appliquée.
Licence open source (OSI)
Licence approuvée par l’Open Source Initiative, qui autorise l’usage, la modification et la redistribution selon des conditions. Un code visible sans ces droits n’est pas open source.
Copyleft
Principe qui impose de conserver la même licence pour les œuvres dérivées distribuées. Il existe des copyleft forts et faibles, avec des obligations différentes.
MIT
Licence permissive courte : usage, modification et redistribution autorisés, à condition de conserver la mention de copyright et la licence. Aucune garantie n’est fournie.
Apache-2.0
Licence permissive avec une clause de brevet explicite. Elle demande de conserver les mentions et d’indiquer les modifications, sans accorder de droit sur les marques.
AGPL-3.0
Licence copyleft fort avec clause réseau : si le logiciel modifié est offert à des utilisateurs sur un réseau, le code correspondant doit leur être rendu disponible.
Fair-code
Terme utilisé par certains éditeurs, dont n8n, pour un code source visible avec un usage interne et auto-hébergé autorisé, mais une revente d’accès hébergé souvent soumise à accord. Ce n’est pas une catégorie approuvée par l’OSI.
Open weights
Poids d’un modèle téléchargeables et utilisables selon une licence. Les données d’entraînement et le code peuvent rester fermés, et l’usage commercial doit être vérifié.
Licence commerciale
Droit d’usage accordé par un contrat : nombre de sièges, volume, revente, support. Elle peut être plus restrictive que l’open source et doit être lue avant un usage hébergé.
Souveraineté
Capacité à choisir où et par qui les données sont traitées, et à garder une possibilité de sortie. L’open source aide, mais ne garantit ni l’hébergement ni le droit applicable.
Réversibilité
Capacité à quitter un fournisseur en récupérant ses données, ses configurations et ses identifiants dans un format utilisable. Elle se prépare avant la signature, pas au moment du départ.

Validation des Acquis