Automatiser l'onboarding client : de 2h de boulot répétitif à 0

Le contexte

Un nouveau client signe. Génial ! Sauf que maintenant il faut : lui envoyer le questionnaire d'onboarding, créer sa page dans Notion, l'ajouter au CRM, générer ses accès, planifier le kick-off, lui envoyer le guide de démarrage...

Bref, 2 heures de tâches répétitives où tu te dis "un robot pourrait faire ça".

Spoiler : oui, un robot peut faire ça.

Le problème initial

• Agence avec 5-10 nouveaux clients par mois
• Chaque onboarding = 2h de tâches administratives
• Process inconsistant (on oublie des étapes, chaque personne fait différemment)
• Les clients attendent parfois 48h avant de recevoir leurs infos

Avant d'écrire une ligne de code, on a passé plusieurs jours à observer l'onboarding réel pour voir comment circulaient les infos entre Stripe, Notion, le CRM et les emails. Cette cartographie nous a servi de base pour remettre de l'ordre.

La solution : un système d'automation complet

On a construit un système qui automatise 100% de l'onboarding client, de la réception du paiement Stripe jusqu'à l'envoi de l'email de bienvenue personnalisé avec le lien Calendly.

Le flow global

La technique expliquée

Étape 1 : Le webhook Stripe (le déclencheur)

Quand un client paie, Stripe envoie automatiquement une requête POST à notre serveur Python avec toutes les infos :

# Route Flask qui reçoit le webhook Stripe
@app.route('/webhook/stripe', methods=['POST'])
def handle_stripe_webhook():
    """Cette fonction est appelée automatiquement par Stripe"""

    # Récupération des données du paiement
    data = request.json
    client_email = data['customer_email']
    client_name = data['customer_name']
    offer_type = data['product_name']  # "Starter", "Pro", "Enterprise"

    # Lancement de l'automation
    run_onboarding_automation(client_name, client_email, offer_type)

    return {"status": "success"}, 200

Étape 2 : L'IA génère l'email de bienvenue

On refuse d'envoyer le même email générique à tout le monde. Un client qui achète l'offre Starter n'a pas les mêmes besoins qu'un client Enterprise.

L'IA génère un email adapté automatiquement en 2-3 secondes.

def generate_welcome_email_with_ai(client_name, offer_type):
    """Appelle l'API Groq pour générer un email personnalisé"""

    prompt = f"""Tu es un Account Manager bienveillant. Rédige un email de bienvenue pour :

Client : {client_name}
Offre : {offer_type}

Ton email doit :
- Remercier chaleureusement
- Expliquer les prochaines étapes (questionnaire, kick-off)
- Être concis (150 mots max)
- Adopter un ton pro mais friendly

Ne mets pas de formule de politesse finale.
"""

    # Appel API Groq
    response = requests.post(
        "https://api.groq.com/openai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {GROQ_API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "model": "llama-3.1-70b-versatile",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.7  # Un peu de créativité
        }
    )

    return response.json()['choices'][0]['message']['content']

Exemple d'email généré :

email_welcome.html

Jour 0 · Onboarding

Bienvenue à bord

Salut Thomas ! Merci d'avoir rejoint bigxbang. On est ravis de bosser avec toi sur ton projet, tu vas être onboardé en douceur.

Ce qui se passe dans les prochaines 24h :

1

Questionnaire d'onboarding

Tu reçois un rapide formulaire (5 minutes) pour nous donner toutes les infos essentielles.

2

Création de ton espace Notion

Dès que tu valides, on crée ton hub client avec toutes les ressources et suivis.

3

Kick-off planifié automatiquement

Tu reçois un lien Calendly pour booker le créneau qui fonctionne pour toi (30 minutes).

Planifier le kick-off →

Guide de démarrage en pièce jointe Support disponible 7j/7

À très vite,
L'équipe bigxbang

Étape 3 : Création automatique dans Notion

Chaque client = une page Notion structurée avec toutes les infos nécessaires pour l'équipe.

def create_notion_page(client_name, client_email, offer_type):
    """Crée automatiquement une page Notion pour le client"""

    response = requests.post(
        "https://api.notion.com/v1/pages",
        headers={
            "Authorization": f"Bearer {NOTION_API_KEY}",
            "Content-Type": "application/json",
            "Notion-Version": "2022-06-28"
        },
        json={
            "parent": {"database_id": NOTION_DATABASE_ID},
            "properties": {
                "Nom": {"title": [{"text": {"content": client_name}}]},
                "Email": {"email": client_email},
                "Offre": {"select": {"name": offer_type}},
                "Statut": {"select": {"name": "Onboarding en cours"}}
            }
        }
    )

    return response.json()

Ce que ça évite : 15 min de copier-coller manuel + risque d'oublier des sections.

Étape 4 : Les autres intégrations (CRM + Calendly + Email)

Le même principe s'applique pour :

• HubSpot API : Ajouter le client au CRM avec un deal + une tâche assignée
• Calendly API : Générer un lien de planification personnalisé
• SendGrid API : Envoyer l'email avec le guide PDF en pièce jointe

Toutes ces actions se font en parallèle. Total : 30 secondes.

La stack technique

Voici les outils qu'on a utilisés pour construire ce système :

Les résultats

Avant l'automation

• 2h de travail manuel par client
• Emails envoyés avec 24-48h de délai
• Oublis fréquents (guide pas envoyé, CRM pas mis à jour)
• Process différent selon qui gère l'onboarding

Après l'automation

• 30 secondes (temps machine)
• Emails envoyés instantanément
• 0 oubli (tout est systématique)
• Process identique pour tous les clients

ROI mensuel (pour 10 clients/mois)

Ce qu'on a appris

1. L'IA n'est pas magique

Le prompt doit être précis pour avoir des résultats cohérents. On a testé 15 versions avant de trouver le bon équilibre entre ton friendly et professionnel.

2. Commencer simple

On a d'abord automatisé juste l'email. Puis Notion. Puis le reste. Pas tout d'un coup. Chaque étape validée avant de passer à la suivante.

3. La gestion d'erreurs est critique

Si Notion plante, le process doit continuer quand même. On log l'erreur et on crée la page manuellement plus tard. Mais l'email part quoi qu'il arrive.

try:
    create_notion_page(client_name, client_email, offer_type)
except Exception as e:
    # Logger l'erreur mais continuer le process
    log_error(f"Notion failed: {e}")
    send_slack_alert(f"Alerte : création Notion impossible pour {client_name}")
    # L'automation continue (email, CRM, etc.)

4. Tester en conditions réelles

Pendant deux semaines, on a gardé l'ancien onboarding manuel tout en lançant l'automation sur 3 clients volontaires. Chaque action automatique était doublée d'une vérification humaine pour comparer les résultats. C'est comme ça qu'on a ajusté le ton de l'email, l'ordre des étapes et le timing des invitations Calendly.

Le code simplifié (structure globale)

Voici la structure globale du système (code simplifié pour la lisibilité) :

from flask import Flask, request
import requests
import json

app = Flask(__name__)

# Webhook Stripe : reçoit la notification de paiement
@app.route('/webhook/stripe', methods=['POST'])
def handle_stripe_webhook():
    """Appelée automatiquement par Stripe quand un client paie"""

    # 1. Récupérer les données du paiement
    data = request.json
    client_email = data['customer_email']
    client_name = data['customer_name']
    offer_type = data['product_name']

    # 2. Générer l'email avec l'IA
    welcome_email = generate_welcome_email_with_ai(client_name, offer_type)

    # 3. Créer la page Notion
    create_notion_page(client_name, client_email, offer_type)

    # 4. Ajouter au CRM
    add_to_crm(client_email, client_name, offer_type)

    # 5. Générer le lien Calendly
    calendly_link = generate_calendly_link(client_email, client_name)

    # 6. Envoyer l'email
    send_email(
        to=client_email,
        subject="Bienvenue chez bigxbang",
        body=welcome_email,
        calendly_link=calendly_link
    )

    return {"status": "success"}, 200