Onboarding client automatisé : deal gagné → welcome email, dossier, accès et kick-off planifié en 5 minutes

Un deal est signé. Le commercial fait la danse de la victoire. Et puis… le silence. Le client attend 3 jours avant de recevoir un email de bienvenue. Le chef de projet découvre le dossier en réunion d'équipe lundi matin. Personne n'a créé le dossier partagé. Les accès à l'outil ne sont pas ouverts. Le kick-off est planifié 2 semaines après la signature — le client a déjà perdu son enthousiasme.

Ce trou noir entre la signature et le premier livrable est le moment où vous perdez la confiance que le commercial a mis des mois à construire.

Ce guide détaille un système complet qui se déclenche dès que le deal passe en « Gagné » dans le CRM : email de bienvenue personnalisé, dossier projet créé avec l'arborescence complète, accès ouverts, tâches d'onboarding assignées, et lien de prise de rendez-vous pour le kick-off envoyé au client. Le tout en moins de 5 minutes, sans qu'un humain touche quoi que ce soit.

Tout est faisable en interne.

Ce que fait le système

Six étapes, du deal signé au kick-off planifié :

1. Déclencheur — Le deal passe en « Gagné » (Closed Won) dans le CRM
2. Collecte des données — Le système récupère toutes les infos du deal, du contact et de l'entreprise
3. Welcome email — Un email de bienvenue personnalisé part au client dans les 5 minutes, avec les prochaines étapes et le lien de prise de RDV kick-off
4. Dossier projet — Un dossier Drive/SharePoint est créé avec l'arborescence complète et les templates pré-remplis
5. Accès et comptes — Les accès client sont ouverts (outil, plateforme, espace collaboratif)
6. Tâches internes — Le chef de projet reçoit son brief, les tâches d'onboarding sont créées et assignées, l'équipe est notifiée

Temps humain : 0 entre la signature et le premier contact post-vente. Le client reçoit un email pro dans les 5 minutes. Le chef de projet a son dossier complet avant même d'ouvrir Slack. Contre 2 à 5 jours de latence habituellement — quand personne n'oublie rien.

Les outils

La plupart de ces outils sont déjà dans votre stack. Le coût marginal du système est souvent inférieur à 20 €/mois — le prix, c'est surtout le temps de mise en place.

Étape 1 — Le déclencheur CRM

HubSpot — Webhook sur changement de deal stage

Le workflow se déclenche quand la propriété dealstage passe à votre étape « Closed Won ».

Option 1 — Workflow HubSpot natif + webhook

Dans HubSpot, créez un workflow basé sur les deals :

• Trigger : « Deal stage is Closed Won »
• Action : « Send webhook » vers votre URL n8n/Make

Le webhook envoie l'ID du deal. Le workflow externe récupère ensuite toutes les données.

Option 2 — n8n polling (si pas de HubSpot Pro)

// n8n — Cron toutes les 10 minutes
// Chercher les deals passés en Closed Won récemment

const res = await fetch('https://api.hubapi.com/crm/v3/objects/deals/search', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${hubspotToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    filterGroups: [{
      filters: [
        {
          propertyName: 'dealstage',
          operator: 'EQ',
          value: 'closedwon'
        },
        {
          propertyName: 'hs_lastmodifieddate',
          operator: 'GTE',
          value: Date.now() - 600000  // 10 dernières minutes
        }
      ]
    }],
    properties: [
      'dealname', 'amount', 'dealstage',
      'closedate', 'hubspot_owner_id',
      'pipeline', 'description'
    ]
  })
});

// Filtrer les deals déjà traités (stocker les IDs dans un tableur)

Pipedrive — Webhook natif

Pipedrive envoie un webhook sur tout changement de deal :

// Créer le webhook dans Pipedrive :
// Paramètres > Webhooks > Ajouter
// Event: updated / Object: deal

// n8n — node Webhook — filtrer les deals gagnés
const payload = $input.first().json;

// Ne traiter que les deals qui viennent de passer en "Won"
if (payload.current?.status !== 'won' || payload.previous?.status === 'won') {
  return [];  // ignorer
}

return [{ json: payload.current }];

Récupérer toutes les données du deal

// n8n — node Code — assembler le contexte complet
const dealId = $input.first().json.id;

// 1. Détails du deal
const deal = await fetchHubSpot(`/crm/v3/objects/deals/${dealId}`, {
  properties: [
    'dealname', 'amount', 'closedate', 'description',
    'hubspot_owner_id', 'pipeline',
    // Propriétés custom selon votre métier
    'type_prestation', 'duree_contrat', 'nb_utilisateurs',
    'offre_souscrite', 'conditions_particulieres'
  ]
});

// 2. Contact principal
const contacts = await fetchHubSpot(
  `/crm/v4/objects/deals/${dealId}/associations/contacts`
);
const contactId = contacts.results[0]?.toObjectId;
const contact = await fetchHubSpot(`/crm/v3/objects/contacts/${contactId}`, {
  properties: ['firstname', 'lastname', 'email', 'phone',
    'jobtitle', 'company']
});

// 3. Entreprise
const companies = await fetchHubSpot(
  `/crm/v4/objects/deals/${dealId}/associations/companies`
);
const companyId = companies.results[0]?.toObjectId;
const company = await fetchHubSpot(`/crm/v3/objects/companies/${companyId}`, {
  properties: ['name', 'domain', 'industry', 'numberofemployees',
    'city', 'country']
});

// 4. Commercial (owner)
const owner = await fetchHubSpot(
  `/crm/v3/owners/${deal.properties.hubspot_owner_id}`
);

return [{
  json: {
    deal: deal.properties,
    contact: contact.properties,
    company: company.properties,
    commercial: { name: `${owner.firstName} ${owner.lastName}`, email: owner.email },
    dealId, contactId, companyId
  }
}];

Étape 2 — Le welcome email

Pourquoi l'IA et pas un template ?

Un template statique fonctionne quand tous vos clients achètent la même chose. Dès que vous avez 3 offres, 4 secteurs, des montants variables et des conditions particulières, le template devient un monstre à 15 blocs conditionnels — impossible à maintenir.

L'IA prend les données du deal et rédige un email sur mesure. Le coût : 0,02 € par email. Le gain : un email de bienvenue qui semble écrit à la main, à chaque fois.

Le prompt

Tu rédiges un email de bienvenue envoyé à un nouveau client
qui vient de signer avec notre entreprise.

CONTEXTE ENTREPRISE :
Nom : [VOTRE ENTREPRISE]
Secteur : [VOTRE SECTEUR]
Ton : professionnel, chaleureux, enthousiaste sans excès.
Signataire : le commercial qui a géré la vente.

DONNÉES DU DEAL :
- Client : {{ prenom }} {{ nom }}, {{ poste }} chez {{ entreprise }}
- Offre souscrite : {{ offre }}
- Montant : {{ montant }} € HT
- Durée : {{ duree_contrat }}
- Conditions particulières : {{ conditions }}
- Commercial : {{ nom_commercial }}

RÈGLES :
- Objet : court et chaleureux. Ex: "[Prénom], bienvenue chez
  [Entreprise] !" ou "C'est parti — voici la suite"
- Longueur : 8-12 phrases max. Pas de pavé.
- Structure :
  1. Remerciement sincère (1-2 phrases)
  2. Rappel de ce qui va se passer (les prochaines étapes concrètes)
  3. Lien de prise de RDV kick-off : {{ lien_calendly }}
  4. Contact en cas de question (le commercial reste le point d'entrée)
- Mentionne l'offre ou le projet par son nom — pas de générique.
- Si des conditions particulières existent, montre que tu les
  as en tête ("Comme convenu, nous prioriserons…").
- Pas de jargon interne. Le client ne connaît pas vos process.
- Le kick-off est la prochaine étape concrète — mets-le en
  évidence.

JSON attendu :
{
  "objet": "...",
  "corps_html": "...",
  "corps_texte": "..."
}

Variantes par secteur

La beauté du système, c'est que le même prompt s'adapte à tous les métiers grâce aux données du deal :

Cabinet d'architecture — « Nous sommes ravis de travailler sur la rénovation de vos bureaux rue de Rivoli. Le kick-off nous permettra de valider le brief et le planning des études. »

Agence de communication — « Bienvenue ! Nous avons hâte de lancer la refonte de votre identité visuelle. Lors du kick-off, nous ferons un atelier de positionnement avec votre équipe. »

Éditeur de logiciel SaaS — « Votre accès à la plateforme est en cours de création. Le kick-off servira à configurer votre espace et former vos 12 utilisateurs. »

Bureau d'études thermiques — « Suite à la signature du lot fluides du projet Résidence Les Érables, nous planifions le kick-off pour caler le planning d'études avec le maître d'œuvre. »

Prestataire de maintenance — « Le contrat de maintenance de vos 8 sites franciliens est actif. Le kick-off permettra de valider les plannings d'intervention et les contacts site par site. »

Organisme de formation — « L'inscription de vos 15 collaborateurs à la formation "Management de projet" est confirmée. Nous vous proposons un point de calage pour finaliser les dates et le programme. »

Le prompt ne change pas. Seules les données du deal changent — et l'IA fait le reste.

L'envoi

// n8n — Envoyer le welcome email
const email = $('Node_IA_Welcome').first().json;
const ctx = $('Node_Context').first().json;

// Via Brevo (ex-Sendinblue)
await fetch('https://api.brevo.com/v3/smtp/email', {
  method: 'POST',
  headers: {
    'api-key': brevoApiKey,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    sender: {
      name: ctx.commercial.name,
      email: ctx.commercial.email  // envoyé "de la part du" commercial
    },
    to: [{ email: ctx.contact.email, name: `${ctx.contact.firstname} ${ctx.contact.lastname}` }],
    subject: email.objet,
    htmlContent: email.corps_html,
    textContent: email.corps_texte,
    replyTo: { email: ctx.commercial.email },
    headers: { 'X-Mailin-Tag': 'onboarding-welcome' }
  })
});

Point important : l'email est envoyé au nom du commercial, pas de « noreply@ ». Le client répond à quelqu'un qu'il connaît. C'est un détail, mais ça change tout pour la relation.

Étape 3 — Le dossier projet

Créer l'arborescence automatiquement

À la signature, le système crée un dossier complet dans votre Drive/SharePoint avec une structure prête à l'emploi.

Google Drive

// n8n — Créer l'arborescence projet dans Google Drive
const ctx = $('Node_Context').first().json;
const parentFolderId = 'ID_DU_DOSSIER_CLIENTS'; // Dossier racine "Clients"

// Nom du dossier : "NomEntreprise — NomProjet (2025)"
const projectName = `${ctx.company.name} — ${ctx.deal.dealname} (${new Date().getFullYear()})`;

// 1. Créer le dossier racine du projet
const rootFolder = await createDriveFolder(projectName, parentFolderId);

// 2. Créer les sous-dossiers
const subfolders = [
  '01 — Commercial',        // Devis signé, contrat, CGV
  '02 — Brief & Specs',     // Brief client, cahier des charges
  '03 — Production',        // Livrables en cours
  '04 — Livrables finaux',  // Livrables validés
  '05 — Administratif',     // Factures, bons de commande
  '06 — Échanges client'    // Comptes-rendus, emails importants
];

const folderIds = {};
for (const name of subfolders) {
  const folder = await createDriveFolder(name, rootFolder.id);
  folderIds[name] = folder.id;
}

// Fonction helper
async function createDriveFolder(name, parentId) {
  const res = await fetch('https://www.googleapis.com/drive/v3/files', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${googleToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name,
      mimeType: 'application/vnd.google-apps.folder',
      parents: [parentId]
    })
  });
  return await res.json();
}

return [{ json: { rootFolderId: rootFolder.id, folderIds } }];

Copier les templates pré-remplis

// Copier et pré-remplir les documents templates
const ctx = $('Node_Context').first().json;
const folders = $('Node_Create_Folders').first().json.folderIds;

// Liste des templates à copier
const templates = [
  {
    templateId: 'GOOGLE_DOC_TEMPLATE_ID_BRIEF',
    destFolder: folders['02 — Brief & Specs'],
    newName: `Brief — ${ctx.company.name}`
  },
  {
    templateId: 'GOOGLE_DOC_TEMPLATE_ID_PV_KICKOFF',
    destFolder: folders['06 — Échanges client'],
    newName: `PV Kick-off — ${ctx.company.name}`
  },
  {
    templateId: 'GOOGLE_SHEET_TEMPLATE_SUIVI',
    destFolder: folders['03 — Production'],
    newName: `Suivi projet — ${ctx.company.name}`
  }
];

for (const tpl of templates) {
  // Copier le template
  const copy = await fetch(
    `https://www.googleapis.com/drive/v3/files/${tpl.templateId}/copy`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${googleToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        name: tpl.newName,
        parents: [tpl.destFolder]
      })
    }
  );
  const newFile = await copy.json();

  // Remplacer les variables dans le document
  // (Google Docs API — batchUpdate)
  await fetch(
    `https://docs.googleapis.com/v1/documents/${newFile.id}:batchUpdate`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${googleToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        requests: [
          replaceText('{{NOM_CLIENT}}', ctx.company.name),
          replaceText('{{CONTACT}}', `${ctx.contact.firstname} ${ctx.contact.lastname}`),
          replaceText('{{EMAIL_CONTACT}}', ctx.contact.email),
          replaceText('{{OFFRE}}', ctx.deal.offre_souscrite || ctx.deal.dealname),
          replaceText('{{MONTANT}}', `${ctx.deal.amount} € HT`),
          replaceText('{{DATE_SIGNATURE}}', ctx.deal.closedate),
          replaceText('{{COMMERCIAL}}', ctx.commercial.name),
          replaceText('{{DATE}}', new Date().toLocaleDateString('fr-FR'))
        ]
      })
    }
  );
}

function replaceText(placeholder, value) {
  return {
    replaceAllText: {
      containsText: { text: placeholder, matchCase: true },
      replaceText: value || '—'
    }
  };
}

SharePoint / OneDrive (Microsoft 365)

// Créer un dossier projet dans SharePoint
const siteId = 'VOTRE_SITE_ID';
const driveId = 'VOTRE_DRIVE_ID';
const basePath = 'Clients';

const projectName = `${ctx.company.name} — ${ctx.deal.dealname}`;

// Créer le dossier racine
await fetch(
  `https://graph.microsoft.com/v1.0/sites/${siteId}/drives/${driveId}/root:/${basePath}/${projectName}:/children`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${msToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: '01 — Commercial',
      folder: {},
      '@microsoft.graph.conflictBehavior': 'rename'
    })
  }
);
// Répéter pour chaque sous-dossier...

Adaptez l'arborescence à votre métier. Un cabinet comptable aura « Pièces comptables / Déclarations / Bilans / Correspondance ». Un bureau d'études aura « Études / Plans / Notes de calcul / Visa ». Un organisme de formation aura « Convention / Programme / Émargement / Évaluation ». L'arborescence est un tableau de strings — changez-le et tout le reste suit.

Étape 4 — Les accès client

Ouvrir un compte sur votre outil

Si votre prestation inclut l'accès à un outil (plateforme SaaS, espace client, extranet, outil de suivi), le système crée le compte automatiquement.

// Exemple générique — adapter à votre API
const ctx = $('Node_Context').first().json;

// Créer le compte utilisateur sur votre plateforme
const newUser = await fetch('https://api.votreoutil.com/v1/users', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    email: ctx.contact.email,
    first_name: ctx.contact.firstname,
    last_name: ctx.contact.lastname,
    company: ctx.company.name,
    role: 'client',
    plan: ctx.deal.offre_souscrite || 'standard',
    // Envoyer l'email d'invitation automatiquement
    send_invite: true
  })
});

Partager le dossier Drive

// Donner l'accès au client sur le dossier projet
const rootFolderId = $('Node_Create_Folders').first().json.rootFolderId;
const clientEmail = ctx.contact.email;

// Accès "commentateur" — le client voit et commente,
// mais ne modifie pas les documents
await fetch(
  `https://www.googleapis.com/drive/v3/files/${rootFolderId}/permissions`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${googleToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      type: 'user',
      role: 'commenter',  // ou 'reader' pour lecture seule
      emailAddress: clientEmail
    })
  }
);

// Pas de notification Google Drive (on a déjà le welcome email)
// Ajouter ?sendNotificationEmail=false en query param

Ajouter le client à un canal Slack partagé (optionnel)

Si vous utilisez Slack Connect pour communiquer avec vos clients :

// Créer un canal Slack pour le projet
const channelName = `client-${ctx.company.name.toLowerCase()
  .replace(/[^a-z0-9]/g, '-').substring(0, 60)}`;

const channel = await fetch('https://slack.com/api/conversations.create', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${slackToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: channelName,
    is_private: true
  })
});

const channelId = (await channel.json()).channel.id;

// Inviter l'équipe interne
const teamMembers = [chefDeProjetSlackId, commercialSlackId, techLeadSlackId];
for (const userId of teamMembers) {
  await fetch('https://slack.com/api/conversations.invite', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${slackToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      channel: channelId,
      users: userId
    })
  });
}

// Inviter le client via Slack Connect
await fetch('https://slack.com/api/conversations.inviteShared', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${slackToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel: channelId,
    emails: [ctx.contact.email]
  })
});

Étape 5 — Les tâches d'onboarding internes

Le checklist automatique

Chaque nouveau projet suit un checklist d'onboarding. Le système le crée automatiquement dans votre outil de gestion de projet.

Asana — créer un projet à partir d'un template

// Dupliquer un template de projet Asana
const ctx = $('Node_Context').first().json;

// 1. Dupliquer le template
const project = await fetch(
  `https://app.asana.com/api/1.0/project_templates/${asanaTemplateId}/instantiateProject`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${asanaToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: `Onboarding — ${ctx.company.name}`,
      team: asanaTeamId,
      public: false,
      requested_dates: [
        {
          gid: 'start_date_gid',  // ID du champ date dans le template
          value: new Date().toISOString().split('T')[0]
        }
      ]
    })
  }
);

const projectId = (await project.json()).data.new_project.gid;

// 2. Assigner les tâches
// Les tâches viennent du template avec des assignés par défaut
// On peut les personnaliser si besoin :
const tasks = await fetch(
  `https://app.asana.com/api/1.0/projects/${projectId}/tasks`,
  {
    headers: { 'Authorization': `Bearer ${asanaToken}` }
  }
);

// Mettre à jour les dates (relatives à la date de signature)
const taskList = (await tasks.json()).data;
const today = new Date();

for (const task of taskList) {
  // Exemple : si la tâche s'appelle "Kick-off client" → due J+5
  // Si "Envoi questionnaire onboarding" → due J+1
  // etc. (le mapping dépend de votre template)
}

Notion — créer une page de suivi

// Créer une page dans la base "Projets" de Notion
const ctx = $('Node_Context').first().json;

await fetch('https://api.notion.com/v1/pages', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${notionToken}`,
    'Notion-Version': '2022-06-28',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    parent: { database_id: notionDbId },
    properties: {
      'Nom': { title: [{ text: { content: `${ctx.company.name} — ${ctx.deal.dealname}` } }] },
      'Client': { rich_text: [{ text: { content: ctx.company.name } }] },
      'Contact': { email: ctx.contact.email },
      'Montant': { number: parseFloat(ctx.deal.amount) },
      'Date signature': { date: { start: ctx.deal.closedate } },
      'Commercial': { rich_text: [{ text: { content: ctx.commercial.name } }] },
      'Statut': { select: { name: 'Onboarding' } },
      'Offre': { select: { name: ctx.deal.offre_souscrite || 'Standard' } },
      'Lien dossier': { url: `https://drive.google.com/drive/folders/${rootFolderId}` }
    }
  })
});

Le brief chef de projet — généré par IA

Le chef de projet ne devrait pas avoir à lire le CRM pour comprendre le dossier. L'IA lui prépare un brief structuré :

Tu rédiges un brief interne pour un chef de projet
qui prend en charge un nouveau client.

DONNÉES :
- Client : {{ entreprise }} ({{ secteur }}, {{ nb_employes }} salariés, {{ ville }})
- Contact principal : {{ prenom }} {{ nom }}, {{ poste }}
- Offre vendue : {{ offre }}
- Montant : {{ montant }} € HT
- Durée : {{ duree }}
- Commercial : {{ nom_commercial }}
- Conditions particulières : {{ conditions }}
- Notes commerciales : {{ description_deal }}

RÈGLES :
- Format : texte structuré, pas de JSON.
- Résume le contexte en 3-4 phrases : qui est le client,
  ce qu'il a acheté, pourquoi.
- Liste les points d'attention (conditions particulières,
  contraintes mentionnées, signaux du cycle de vente).
- Rappelle les prochaines étapes standard de l'onboarding.
- Ton : direct, factuel, opérationnel. Pas de commercial.

Étape 6 — Le kick-off

Le lien Calendly / Cal.com

Le welcome email contient un lien de prise de RDV. Le client choisit un créneau — le kick-off est calé sans un seul email d'aller-retour.

// Générer un lien Calendly personnalisé avec pré-remplissage
const ctx = $('Node_Context').first().json;

const calendlyLink = `https://calendly.com/votre-equipe/kick-off`
  + `?name=${encodeURIComponent(`${ctx.contact.firstname} ${ctx.contact.lastname}`)}`
  + `&email=${encodeURIComponent(ctx.contact.email)}`
  + `&a1=${encodeURIComponent(ctx.company.name)}`  // champ custom "Entreprise"
  + `&a2=${encodeURIComponent(ctx.deal.dealname)}`;  // champ custom "Projet"

// Le client clique, choisit un créneau, c'est fait.
// Calendly envoie les invitations calendar à tout le monde.

Quand le kick-off est bookée

Calendly/Cal.com envoie un webhook quand le RDV est confirmé. Le workflow met à jour le CRM et notifie l'équipe :

// n8n — Webhook Calendly — kick-off planifié
const event = $input.first().json.payload;

// Mettre à jour le deal dans HubSpot
await fetch(`https://api.hubapi.com/crm/v3/objects/deals/${dealId}`, {
  method: 'PATCH',
  headers: {
    'Authorization': `Bearer ${hubspotToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    properties: {
      date_kickoff: event.scheduled_event.start_time,
      dealstage: 'onboarding_en_cours'  // pipeline post-vente
    }
  })
});

// Notifier l'équipe sur Slack
await sendSlack('#projets', {
  text: `📅 Kick-off planifié — ${ctx.company.name}\n`
    + `Date : ${new Date(event.scheduled_event.start_time).toLocaleString('fr-FR')}\n`
    + `Participants : ${event.invitees.map(i => i.name).join(', ')}\n`
    + `📁 Dossier : https://drive.google.com/drive/folders/${rootFolderId}`
});

Workflow complet (résumé n8n)

[Trigger : Deal → Closed Won (webhook CRM ou polling)]
    ↓
[Récupérer données : deal + contact + entreprise + commercial]
    ↓
[Claude API : Générer welcome email personnalisé]
    ↓
┌──────────────────────┬──────────────────────┬──────────────────────┐
│ Brevo / SMTP :       │ Google Drive :       │ Asana / Notion :     │
│ Envoyer welcome      │ Créer dossier        │ Créer projet         │
│ email + lien         │ + sous-dossiers      │ onboarding           │
│ kick-off             │ + templates          │ + tâches             │
│                      │ pré-remplis          │ + brief CDP          │
└──────────────────────┴──────────────────────┴──────────────────────┘
    ↓
┌──────────────────────┬──────────────────────┬──────────────────────┐
│ Plateforme :         │ Drive :              │ Slack :              │
│ Créer compte         │ Partager accès       │ Créer canal projet   │
│ client (si SaaS)     │ au client            │ + inviter équipe     │
└──────────────────────┴──────────────────────┴──────────────────────┘
    ↓
[CRM : Mettre à jour le deal (stage "Onboarding en cours")]
    ↓
[Slack #commercial : "🎉 Nouveau client : Entreprise X — Offre Y — XX €"]
    ↓
[Attente webhook Calendly : kick-off planifié]
    ↓
[CRM : Mettre à jour date kick-off]
[Slack #projets : "📅 Kick-off le XX/XX à XXh"]

Ce que ça donne en vrai

Le gain le plus important n'est pas le temps — c'est l'impression que le client a de votre organisation. Un client qui reçoit un email de bienvenue personnalisé dans les 5 minutes, avec les prochaines étapes claires et un lien pour prendre RDV, se dit « je suis entre de bonnes mains ». Cette impression colore toute la suite de la relation.

Les limites

Le trigger CRM doit être fiable. Si le commercial oublie de passer le deal en « Closed Won » (ou le fait trop tôt, avant la signature effective), le système se déclenche au mauvais moment. Solution : ajoutez une condition supplémentaire — vérifier qu'un montant est renseigné, qu'un contrat est uploadé, ou qu'une propriété « Contrat signé » est cochée.

Le welcome email ne remplace pas l'appel. Le meilleur onboarding combine un email automatique immédiat (le système) et un appel humain dans les 24-48h (le commercial ou le chef de projet). L'email montre la réactivité, l'appel montre l'attention. L'un sans l'autre est incomplet.

Les templates pré-remplis ne se remplissent pas tout seuls. Le système injecte les données du CRM (nom, date, montant, offre). Si le CRM est mal renseigné — champs vides, descriptions vagues — les templates seront incomplets. Le système révèle la qualité de votre CRM, il ne la compense pas.

L'arborescence dossier doit être maintenue. Si votre process interne évolue (nouveau livrable, nouvelle étape), il faut mettre à jour le tableau de sous-dossiers et les templates. Prévoyez une revue trimestrielle.

Les accès client dépendent de votre outil. Si votre plateforme n'a pas d'API pour créer des comptes, cette étape reste manuelle. Le système peut quand même générer un ticket interne « Créer le compte client X » avec toutes les infos pré-remplies.

Maintenance. Vérification des logs, mise à jour des templates, ajustement du prompt welcome quand l'offre évolue. Prévoir 1h/mois.

Troubleshooting

Le budget

Le coût marginal est faible si vous avez déjà les outils. Le ROI ne se mesure pas en euros économisés sur le tri d'emails — il se mesure en taux de rétention client. Un onboarding fluide réduit le churn de 10 à 25% selon les études. Sur un panier moyen de 10 000 € par client, garder un seul client de plus par an rembourse le système pour une décennie.

Tout est là

Ce guide contient l'architecture, le déclencheur CRM (HubSpot et Pipedrive), le prompt du welcome email, le code de création de dossier (Google Drive et SharePoint), la copie de templates pré-remplis, la gestion des accès, l'intégration Asana/Notion, le booking kick-off (Calendly), et le troubleshooting. Si vous avez quelqu'un en interne qui maîtrise les outils d'automatisation — lancez-vous.

Le point clé, c'est le temps entre la signature et le premier signe de vie. Chaque heure de silence post-signature est une heure où le client se demande s'il a fait le bon choix. Le système ne remplace pas la relation humaine — il garantit que la relation ne commence pas par un trou noir.

Si vous préférez gagner du temps : on branche le système sur vos 3 prochains deals. On configure le workflow, on calibre le welcome email sur votre ton, et on vous montre le résultat en live : email envoyé, dossier créé, kick-off bookable. Si le client est impressionné — on pérennise. Si ça ne change rien, vous n'avez rien dépensé.

→ Demander le test gratuit

Marketing Robot — systèmes d'automatisation pour PME. Des process, des outils, des résultats mesurables.