Aller au contenu
Module

SQL pour PM : les requêtes qui vous rendent autonome pour décider

Pourquoi un PM gagne à lire et écrire du SQL, les requêtes types (entonnoir, cohorte, top N), les pièges à éviter et un aide-mémoire gratuit.

Guide rédigé par Alex Dionisio, Senior Product Manager. Mis à jour le 13 novembre 2026.

En bref

Un Product Manager n’a pas besoin de devenir analyste pour tirer profit du SQL. Comprendre comment les données sont rangées et écrire une poignée de requêtes (compter, filtrer une période, suivre un entonnoir, mesurer une rétention, classer un top N) suffit pour répondre seul aux questions courantes, à condition de connaître les pièges classiques, de travailler en lecture seule et de faire vérifier ce qui sert une décision importante.

Pourquoi un Product Manager a-t-il intérêt à apprendre le SQL ?

Apprendre le SQL permet à un Product Manager de répondre lui-même aux questions simples sur l’usage du produit, sans attendre qu’un analyste se libère, et de mieux comprendre les chiffres présentés par les tableaux de bord, donc de savoir quand s’en méfier.

Le SQL est le langage qui sert à interroger les bases de données relationnelles. Dans la plupart des produits numériques, les inscriptions, les abonnements et les actions des utilisateurs finissent dans des tables que l’on peut interroger avec quelques mots-clés : SELECT, FROM, WHERE, GROUP BY, JOIN.

Pour un PM, l’intérêt n’est pas de remplacer l’équipe data. Il est ailleurs :

  • Gagner du temps sur les petites questions : combien de comptes ont utilisé la nouvelle option la semaine dernière ? Ce genre de question tient en trois lignes et ne mérite pas un ticket.
  • Comprendre d’où viennent les chiffres : un graphique de tableau de bord est une requête cachée. Savoir la lire permet de repérer un filtre oublié ou une définition discutable.
  • Mieux formuler les demandes : quand vous devez solliciter un analyste, vous savez quelles tables existent et quelle question précise poser.
  • Tester une intuition avant d’en parler : vérifier qu’un problème existe vraiment avant de le mettre à l’ordre du jour d’un comité.

Le SQL complète l’analytics produit : les outils d’analyse donnent des vues prêtes à l’emploi, le SQL répond aux questions qu’aucune vue n’avait prévues.

Comment comprendre le modèle de données avant d’écrire une requête ?

Avant d’écrire une requête, un PM doit savoir quelles tables existent, ce que représente une ligne dans chacune, quelle colonne identifie chaque ligne (la clé primaire) et quelles colonnes relient les tables entre elles (les clés étrangères). Sans cette carte, les résultats sont faux sans que rien ne le signale.

Le modèle de données décrit comment l’information est rangée. Dans tout ce guide, nous prenons un exemple volontairement simple, une application en ligne de suivi de projets :

  • users : une ligne par compte, avec id, signup_at (date d’inscription), country et plan.
  • events : une ligne par action enregistrée, avec user_id, name (par exemple project_created) et occurred_at.
  • subscriptions : une ligne par abonnement payant, avec user_id, started_at et ended_at.

La question la plus utile à se poser devant une table est : que représente exactement une ligne ? Un compte, une action, un abonnement, une journée ? Tout le reste en découle. Si une table d’événements contient une ligne par clic, compter ses lignes ne donne pas un nombre d’utilisateurs.

Les clés font le lien. users.id identifie un compte de façon unique ; events.user_id pointe vers ce compte. C’est grâce à cette correspondance qu’une jointure peut rapprocher une action de la personne qui l’a faite. Demandez à l’équipe technique le schéma ou la documentation des tables avant de commencer : c’est souvent le document le plus rentable de la semaine. La leçon Lire un modèle de données détaille cette lecture pas à pas.

Quelles sont les requêtes de base qu’un PM utilise le plus ?

Les trois requêtes de base d’un PM sont le comptage d’utilisateurs distincts, le filtre sur une période donnée et le classement des éléments les plus fréquents (top N). À elles trois, elles couvrent une grande partie des questions quotidiennes sur l’usage d’un produit.

Compter des utilisateurs, pas des lignes. Pour connaître le nombre de comptes qui ont créé un projet, on compte les identifiants distincts, sinon un utilisateur actif pèse autant que dix utilisateurs occasionnels :

SELECT COUNT(DISTINCT user_id) AS createurs
FROM events
WHERE name = 'project_created';

Filtrer une période. On borne avec une date de début incluse et une date de fin exclue. Cette écriture évite d’oublier la dernière journée quand la colonne contient aussi l’heure :

SELECT COUNT(*) AS inscriptions
FROM users
WHERE signup_at >= '2026-10-01'
  AND signup_at <  '2026-11-01';

Classer un top N. Pour voir quelles actions touchent le plus d’utilisateurs sur les sept derniers jours (aujourd’hui exclu, car la journée est incomplète), on regroupe, on compte, on trie et on limite :

SELECT name, COUNT(DISTINCT user_id) AS utilisateurs
FROM events
WHERE occurred_at >= CURRENT_DATE - 7
  AND occurred_at <  CURRENT_DATE
GROUP BY name
ORDER BY utilisateurs DESC
LIMIT 10;

La syntaxe des dates varie d’une base à l’autre (PostgreSQL, BigQuery, Snowflake, MySQL). Les exemples ci-dessus suivent PostgreSQL ; adaptez les fonctions de date à votre outil.

Comment croiser utilisateurs et événements et suivre un entonnoir simple ?

Pour croiser utilisateurs et événements, on écrit une jointure sur la clé commune (l’identifiant du compte). Pour un entonnoir simple, on part des comptes inscrits sur une période et on compte, parmi eux, ceux qui ont réalisé chaque étape, puis on compare les étapes entre elles.

Une jointure permet par exemple de répartir les créateurs de projet par formule d’abonnement, une information qui vit dans users alors que l’action vit dans events :

SELECT u.plan, COUNT(DISTINCT e.user_id) AS createurs
FROM events e
JOIN users u ON u.id = e.user_id
WHERE e.name = 'project_created'
GROUP BY u.plan;

Un entonnoir de conversion simple se construit avec une ligne de comptage par étape :

SELECT
  COUNT(DISTINCT u.id) AS inscrits,
  COUNT(DISTINCT CASE WHEN e.name = 'project_created' THEN e.user_id END) AS projet,
  COUNT(DISTINCT CASE WHEN e.name = 'invite_sent' THEN e.user_id END) AS invitation
FROM users u
LEFT JOIN events e
  ON e.user_id = u.id
 AND e.occurred_at >= u.signup_at
 AND e.occurred_at <  u.signup_at + INTERVAL '30 days'
WHERE u.signup_at >= '2026-10-01'
  AND u.signup_at <  '2026-11-01';

On part des comptes inscrits sur la période et on regarde ce qu’ils font dans leurs trente premiers jours, pour que chaque étape porte sur les mêmes personnes. Cette version ne vérifie pas l’ordre des étapes : une personne qui invite avant de créer un projet est comptée dans les deux colonnes. Pour une première lecture, c’est souvent suffisant ; pour une décision importante, il faut un entonnoir ordonné, que l’équipe data ou la formation vous aideront à construire. Les erreurs de jointure sont la première source de chiffres faux : la leçon Les pièges des jointures les passe en revue.

Comment mesurer une rétention par cohorte en SQL, version simplifiée ?

Une rétention par cohorte simplifiée regroupe les utilisateurs par mois d’inscription, puis compte, dans chaque groupe, ceux qui ont encore une activité dans une fenêtre définie après leur inscription, par exemple entre le trentième et le soixantième jour.

L’analyse de cohorte évite un biais courant : une rétention globale mélange des utilisateurs arrivés il y a deux ans et d’autres arrivés hier. En regroupant par date d’arrivée, on voit si les nouvelles cohortes restent mieux ou moins bien que les anciennes.

SELECT
  DATE_TRUNC('month', u.signup_at) AS cohorte,
  COUNT(DISTINCT u.id) AS inscrits,
  COUNT(DISTINCT e.user_id) AS actifs_j30_j60
FROM users u
LEFT JOIN events e
  ON e.user_id = u.id
 AND e.occurred_at >= u.signup_at + INTERVAL '30 days'
 AND e.occurred_at <  u.signup_at + INTERVAL '60 days'
WHERE u.signup_at < CURRENT_DATE - 60
GROUP BY 1
ORDER BY 1;

Trois remarques avant d’interpréter le résultat :

  • Le LEFT JOIN garde tous les inscrits, même ceux sans activité ; une jointure classique les ferait disparaître et gonflerait la rétention.
  • Les cohortes trop récentes n’ont pas encore atteint leur soixantième jour : leur chiffre serait incomplet, pas mauvais, d’où le filtre qui ne garde que les inscrits d’il y a plus de soixante jours.
  • La définition d’« actif » (n’importe quel événement ou une action précise) change tout. Écrivez-la noir sur blanc à côté du chiffre.

Quels sont les pièges classiques du SQL pour un PM ?

Les pièges classiques du SQL pour un PM sont les doublons créés par une jointure, les fuseaux horaires mal gérés, les valeurs nulles qui disparaissent des calculs et les conclusions tirées d’un échantillon trop petit ou non représentatif. Chacun produit un chiffre plausible et faux.

  • Doublons : joindre une table d’utilisateurs à une table où chaque utilisateur a plusieurs lignes multiplie les lignes. Un SUM sur le résultat compte alors plusieurs fois le même montant. Réflexe : compter les lignes du résultat, puis recompter une fois la jointure ajoutée.
  • Fuseaux horaires : les dates sont souvent stockées en UTC. Une « journée » calculée en UTC ne correspond pas à la journée de vos utilisateurs à Paris ou à Montréal, ce qui décale les pics et les comparaisons de jour à jour. En PostgreSQL, une date écrite sans fuseau et DATE_TRUNC utilisent le fuseau de la session : fixez-le explicitement, par exemple SET TIME ZONE 'Europe/Paris';, ou écrivez '2026-10-01 00:00:00+00'.
  • Valeurs nulles : NULL signifie « inconnu », pas zéro. Une condition WHERE country <> 'FR' exclut aussi les pays non renseignés, et AVG ignore les nulls sans prévenir.
  • Échantillon : un écart observé sur quelques dizaines de comptes peut relever du hasard. Avant de conclure, regardez les effectifs et, pour comparer deux variantes, passez par une démarche d’A/B test.
  • Données de test et comptes internes : les comptes de l’équipe faussent les petites mesures. Demandez comment les exclure.

Une bonne habitude consiste à vérifier chaque résultat par un second chemin : un chiffre du tableau de bord, une estimation plausible, ou la même question posée autrement. Si les deux ne concordent pas, c’est la requête qu’il faut soupçonner en premier.

Comment utiliser l’IA pour écrire du SQL sans se tromper ?

L’IA écrit vite des requêtes SQL correctes en apparence, mais elle ne connaît pas votre modèle de données ni vos définitions métier. Il faut lui fournir le schéma et la définition des indicateurs, lui demander d’expliquer la requête, puis vérifier le résultat sur un cas connu.

Un assistant IA est un excellent partenaire pour passer d’une question en français à une requête, ou pour comprendre une requête existante. Ses erreurs typiques sont prévisibles : il invente une colonne qui n’existe pas, choisit une jointure qui duplique les lignes ou interprète « actif » à sa façon. Une méthode simple :

  1. Donnez le contexte : la liste des tables utiles, leurs colonnes, ce que représente une ligne, le dialecte SQL de votre base.
  2. Formulez une question précise : période, population, définition de chaque indicateur, ce qu’il faut exclure.
  3. Demandez une explication ligne à ligne et les hypothèses retenues, pas seulement le code.
  4. Testez sur un cas que vous connaissez : un utilisateur précis, une petite période, un chiffre déjà validé ailleurs.
  5. Faites relire toute requête qui alimente une décision engageante ou un chiffre présenté à la direction.

Ne collez jamais de données personnelles réelles dans un outil d’IA non approuvé par votre entreprise : le schéma suffit pour écrire la requête. La leçon Écrire du SQL avec l’IA et la formation L’IA pour travailler avec les données approfondissent ces usages. La même logique de vérification s’applique quand vous évaluez une fonctionnalité IA, comme l’explique le guide sur les evals IA pour Product Manager.

Quel accès aux données demander quand on est PM ?

Un PM doit demander un accès en lecture seule, idéalement à une copie des données de production (entrepôt ou réplique) plutôt qu’à la base qui sert le produit, avec des données personnelles masquées ou limitées au strict nécessaire.

L’accès aux données est une question de sécurité et de conformité avant d’être une question technique. Quelques principes à défendre auprès de l’équipe :

  • Lecture seule : un compte sans aucun droit d’écriture ou de suppression. Une commande UPDATE ou DELETE mal écrite ne doit tout simplement pas pouvoir s’exécuter.
  • Hors de la base qui fait tourner le produit : une requête gourmande sur cette base peut ralentir l’application pour tout le monde. Un entrepôt de données ou une réplique évite ce risque.
  • Données minimales : pas d’e-mails, de noms ou de coordonnées si la question ne l’exige pas. Le RGPD pose un principe de minimisation : ne traiter que les données utiles aux finalités poursuivies.
  • Traçabilité : un accès nominatif, pas un identifiant partagé, pour savoir qui a consulté quoi.

La leçon Accès et confidentialité aide à préparer cette demande. Pour aller du modèle de données aux requêtes produit avec des exercices guidés, la formation Données et SQL pour PM reprend toute la démarche, et la formation Analytics produit aide à choisir les bons indicateurs avant de les calculer.

Modèle gratuit : REQUETES-SQL-PM.md

Un aide-mémoire à garder ouvert à côté de votre outil de requêtes. Adaptez chaque table et chaque colonne à votre propre modèle de données, puis complétez la section « Définitions » avec votre équipe.

Télécharger REQUETES-SQL-PM.md
# Aide-mémoire SQL pour PM

## Mon modèle de données
- Table des comptes : [nom] (une ligne = [quoi])
- Table des événements : [nom] (une ligne = [quoi])
- Clé de liaison : [table_evenements.colonne] -> [table_comptes.colonne]
- Dialecte SQL : [PostgreSQL / BigQuery / Snowflake / autre]
- Fuseau horaire des dates : [UTC ou autre]

## Définitions (à valider avec l'équipe)
- Utilisateur actif : [événement(s) retenu(s)]
- Comptes exclus : [comptes internes, tests]

## Requêtes types
```sql
-- Compter des utilisateurs distincts
SELECT COUNT(DISTINCT user_id) FROM events WHERE name = '[action]';

-- Filtrer une période (début inclus, fin exclue)
WHERE occurred_at >= '[AAAA-MM-JJ]' AND occurred_at < '[AAAA-MM-JJ]'

-- Top N
SELECT name, COUNT(DISTINCT user_id) AS n
FROM events GROUP BY name ORDER BY n DESC LIMIT 10;

-- Jointure comptes / événements
SELECT u.[colonne], COUNT(DISTINCT e.user_id)
FROM events e JOIN users u ON u.id = e.user_id
GROUP BY u.[colonne];
```

## Avant de partager un chiffre
- [ ] Je sais ce que représente une ligne de chaque table
- [ ] J'ai compté des identifiants distincts, pas des lignes
- [ ] Lignes recomptées après chaque jointure
- [ ] Bornes de dates et fuseau horaire vérifiés
- [ ] Valeurs nulles prises en compte
- [ ] Comptes internes et de test exclus
- [ ] Effectifs suffisants pour conclure
- [ ] Résultat recoupé avec une autre source
- [ ] Requête relue si le chiffre sert une décision importante

## Travailler avec l'IA
- Fournir : schéma, dialecte, définitions, période, exclusions
- Demander : la requête + une explication ligne à ligne + les hypothèses
- Ne jamais coller de données personnelles réelles

Passer à la pratique

La formation « Modéliser les données de son produit et les interroger en SQL » vous guide pas à pas, sur votre propre produit, jusqu’au livrable.

Voir la formation

Questions fréquentes

Combien de temps faut-il pour apprendre le SQL quand on est PM ?

Les bases utiles (sélectionner, filtrer, compter, regrouper, joindre deux tables) s’apprennent assez vite si vous pratiquez sur vos propres données. Le plus long n’est pas la syntaxe mais la connaissance du modèle de données de votre produit et de ses pièges.

Un PM doit-il écrire du SQL ou seulement savoir le lire ?

Savoir le lire est le minimum : cela permet de comprendre un tableau de bord et de discuter avec l’équipe data. L’écrire, y compris en vous faisant assister par un modèle d’IA, vous rend autonome sur les questions simples, à condition de respecter les règles de vérification.

Quel SQL apprendre : PostgreSQL, MySQL ou BigQuery ?

Le cœur du langage est commun à toutes les bases. Ce qui change d’une base à l’autre, ce sont surtout les fonctions qui manipulent dates et chaînes de caractères. Apprenez celui de l’outil que votre entreprise utilise et gardez sa documentation à portée de main.

Peut-on laisser l’IA écrire toutes ses requêtes SQL ?

L’IA peut écrire la plupart des requêtes, mais vous restez responsable du chiffre. Donnez-lui le schéma et les définitions, demandez-lui d’expliquer chaque ligne et testez le résultat sur un cas connu avant de le diffuser.

Le SQL remplace-t-il un outil d’analytics produit ?

Non, les deux se complètent. Les outils d’analytics produit offrent des vues prêtes à l’emploi et faciles à partager ; le SQL répond aux questions que ces vues n’avaient pas prévues et permet de vérifier leurs calculs.