16

Fiches mémo

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

Annexe 1610 min de lectureMis à jour le 20 novembre 2026

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.

Les quatorze fiches

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