Guide pratique · E-commerce · SaaS · Finance · RH · Lecture : ~18 min Teste ton niveau sur modai-lab.com/test-sql/


Pourquoi ce guide existe

Tu veux devenir data analyst. Tu ouvres LinkedIn ou YouTube, et on te sert une roadmap qui ressemble à un programme de master : SQL, Python, pandas, NumPy, statistiques, machine learning, Power BI, Tableau, dbt, Airflow, Spark, Git, Docker, cloud…

Résultat : tu commences tout, tu ne finis rien. Six mois plus tard, tu as suivi trois cours Python à moitié, tu sais faire un SELECT *, et tu ne te sens toujours pas prêt pour un entretien.

Le problème n'est pas ta motivation. C'est que tu mènes trop de combats en même temps.

Après une dizaine d'années dans la data (ESN, freelance, banque, assurance, industrie, et aujourd'hui Lead Data dans une néobanque), mon constat est simple :

  • Le SQL est la compétence qui te fait embaucher et celle que tu utiliseras tous les jours

  • Tu n'as pas besoin de maîtriser SQL et Python pour décrocher ton premier poste

  • Le SQL est beaucoup plus simple à maîtriser que Python : surface réduite, logique déclarative, résultats immédiats

  • Python viendra après, quand tu auras un vrai besoin, pas avant

Ce guide couvre :

  • Ce que fait vraiment un data analyst au quotidien (et la place du SQL dedans)

  • Pourquoi il faut choisir ses combats, et lesquels laisser de côté au début

  • Pourquoi SQL est plus simple à maîtriser que Python, preuves à l'appui

  • Le socle SQL exact à maîtriser, niveau par niveau, avec des cas business

  • Les erreurs classiques des débutants (et ce que font les seniors)

  • Un plan de route sur 90 jours, concret et réaliste


🧪 Calibre ton niveau avant de commencer

Avant de bâtir ta roadmap, il faut savoir d'où tu pars. Tu sais écrire une jointure, mais sais-tu calculer un taux de rétention mensuel ou dédoublonner une table de commandes proprement ? Fais le test en 5 minutes.

👉 Faire le test sur modai-lab.com/test-sql/

_Résultat en direct · Niveau calibré · Parcours personnalisé_


PARTIE 1 — Le vrai métier de data analyst : 80 % de SQL

Ce qui se passe vraiment dans une journée

Oublie l'image du data analyst qui entraîne des modèles de machine learning toute la journée. Dans la réalité d'une entreprise, voici à quoi ressemble une semaine type :

Activité

Part du temps

Outil principal

Répondre à des questions business (« combien ? », « pourquoi ça baisse ? »)

~35 %

SQL

Construire et maintenir des tables / KPI pour les dashboards

~25 %

SQL (+ dbt parfois)

Contrôler la qualité des données (doublons, trous, incohérences)

~15 %

SQL

Construire / mettre à jour des dashboards

~15 %

Power BI, Looker, Tableau, Metabase

Analyses ponctuelles avancées, automatisations

~10 %

Python, Excel

Ce n'est pas une statistique officielle, c'est ce que j'observe depuis des années, en ESN, en freelance et en interne. Le point clé : la donnée vit dans des bases de données. BigQuery, Snowflake, PostgreSQL, Redshift, SQL Server… Et la langue pour parler à ces bases, c'est le SQL.

Même le dashboard que tu construis dans Power BI ou Looker repose, en dessous, sur une requête SQL. Même le data scientist qui fait du Python commence par un SELECT pour récupérer ses données.

Ce qu'on te demande vraiment en entretien

Dans la grande majorité des process de recrutement data analyst junior, tu vas rencontrer :

  1. Un test SQL technique (live coding ou test en ligne) : quasi systématique

  2. Une étude de cas business : « voici une table de commandes, dis-moi ce qui se passe »

  3. Des questions de logique métier : comment tu définis un client actif, un churn, un panier moyen

  4. Parfois une question Python ou un exercice pandas, surtout dans les startups tech

Remarque bien : le point 2 et le point 3 se résolvent… en SQL.

Cas business : la question que tu recevras dès ta première semaine

Contexte e-commerce. Ton manager te demande sur Slack : « Le CA de mars a baissé de 12 % par rapport à février. C'est quoi le problème ? »

Voici ce qu'un analyste fait, en SQL, en moins de 15 minutes :

-- Table orders : order_id, user_id, created_at, montant, statut, region, canal
-- Objectif : décomposer la baisse du CA en volume (nb commandes) et en valeur (panier moyen)
 
SELECT
DATE_TRUNC(created_at, MONTH) AS mois,
region,
COUNT(DISTINCT order_id) AS nb_commandes,
COUNT(DISTINCT user_id) AS nb_clients,
ROUND(SUM(montant), ) AS ca,
ROUND(SUM(montant) / COUNT(DISTINCT order_id), ) AS panier_moyen
FROM orders
WHERE statut = 'livree'
AND created_at >= '2026-02-01'
AND created_at < '2026-04-01'
GROUP BY mois, region
ORDER BY region, mois;
 
-- Résultat (extrait) :
-- mois | region | nb_commandes | nb_clients | ca | panier_moyen
-- 2026-02 | IDF | 4 210 | 3 380 | 286 280 | 68.00
-- 2026-03 | IDF | 4 190 | 3 350 | 284 920 | 68.00 <- stable
-- 2026-02 | Sud-Est | 2 050 | 1 720 | 135 300 | 66.00
-- 2026-03 | Sud-Est | 1 230 | 1 040 | 81 180 | 66.00 <- -40 % de commandes
--
-- Conclusion : le panier moyen ne bouge pas. Le problème est un effondrement
-- du volume sur le Sud-Est. Prochaine question : quel canal ? quelle date ?
devenir-data-analyst · 01

Pas de Python, pas de machine learning. Une requête bien construite, une lecture business, et une prochaine question. C'est ça, le métier.


🧪 Entraîne-toi sur des questions business réelles

Sur Modai Lab, chaque exercice part d'une vraie question de manager (« pourquoi le CA baisse ? », « quels clients vont churner ? ») sur des datasets proches de la production, pas sur des tables employees à 10 lignes.

👉 Pratiquer sur modai-lab.com

_Cas business réels · Datasets réalistes · Correction par l'IA_


PARTIE 2 — Choisir ses combats : SQL d'abord, le reste ensuite

Le piège de la roadmap « tout-en-un »

Le cerveau humain apprend mal en parallèle. Quand tu apprends SQL le lundi, Python le mardi, Power BI le mercredi et les stats le jeudi, tu fais quatre fois le travail de mise en route, et tu n'atteins jamais le stade où une compétence devient automatique.

Or c'est ce stade-là qui compte en entretien et en poste : quand tu n'as plus à réfléchir à la syntaxe, tu peux enfin réfléchir au problème business.

La règle : un combat principal, un combat secondaire, zéro combat tertiaire

Priorité

Compétence

Pourquoi

🥇 Combat principal

SQL

Utilisé tous les jours, testé dans quasiment tous les entretiens

🥈 Combat secondaire

Un outil de BI (Power BI ou Looker Studio) + Excel

Tu dois savoir montrer tes résultats

🧠 En continu

Logique business (KPI, définitions métier)

C'est ce qui te différencie d'un « exécutant de requêtes »

⏸️ Plus tard

Python / pandas

Utile, mais pas bloquant pour un premier poste d'analyste

⛔ Pas maintenant

Machine learning, Spark, Docker, Airflow

Ce sont des compétences de data scientist / data engineer

« Mais toutes les offres demandent Python… »

Oui, beaucoup d'offres listent Python. Mais lis bien :

  • Il est souvent dans les « plus » ou les « idéalement », pas dans les prérequis

  • Les fiches de poste sont des listes de souhaits, rarement des minimums

  • Le test technique, lui, est presque toujours en SQL

Un candidat qui maîtrise vraiment SQL (fenêtres, CTE, cohortes, dédoublonnage) et sait expliquer un KPI passe devant un candidat « SQL + Python + ML » qui ne maîtrise rien à fond. La profondeur bat la largeur, surtout pour un junior.

❌ La roadmap qui épuise vs ✅ la roadmap qui embauche

❌ ROADMAP « JE VEUX TOUT SAVOIR »
Mois 1 : bases SQL + bases Python + intro stats
Mois 2 : pandas + Power BI + intro machine learning
Mois 3 : scikit-learn + projets Kaggle + Tableau
Mois 4 : « je ne me sens toujours pas prêt »
-> 6 compétences à 30 %, aucune à 80 %
-> En entretien : bloqué sur une jointure + agrégation
 
✅ ROADMAP « JE CHOISIS MES COMBATS »
Mois 1 : SQL fondamentaux (SELECT, WHERE, GROUP BY, JOIN) sur cas business
Mois 2 : SQL intermédiaire (CTE, CASE WHEN, dates, fenêtres)
Mois 3 : SQL avancé (cohortes, rétention, funnels) + 1 outil BI + portfolio
Mois 4 : candidatures + entretiens
-> SQL à 80 %, BI à 50 %, logique business solide
-> En entretien : tu déroules, tu expliques, tu proposes
devenir-data-analyst · 02

Quand ajouter Python ?

Ajoute Python quand tu as un besoin concret que SQL ne couvre pas bien :

  • Automatiser un traitement répétitif (envoi de fichiers, appels d'API)

  • Faire des statistiques plus poussées (tests A/B, régressions)

  • Manipuler des fichiers non structurés (JSON complexes, scraping)

À ce moment-là, tu apprendras Python 2 à 3 fois plus vite, parce que tu sauras déjà raisonner sur des tables, des jointures et des agrégations. pandas, c'est en grande partie du SQL avec une autre syntaxe.


🧪 Sais-tu vraiment où tu en es en SQL ?

Avant de décider que tu es « prêt pour Python », vérifie que ton SQL est vraiment solide : jointures, agrégations, fenêtres, cas pièges avec NULL. Le test te dit précisément quoi travailler.

👉 Faire le test sur modai-lab.com/test-sql/

_5 minutes · Niveau calibré · Points faibles identifiés_


PARTIE 3 — Pourquoi SQL est plus simple à maîtriser que Python

Raison 1 : SQL est déclaratif, Python est impératif

En SQL, tu décris ce que tu veux. Le moteur décide comment le calculer. En Python, tu décris chaque étape du calcul.

C'est une différence énorme pour un débutant : en SQL, tu penses en résultat business (« je veux le CA par région »), pas en boucles, variables et types.

Raison 2 : la surface à maîtriser est réduite

Le SQL d'un data analyst tient en une vingtaine de concepts. Python, c'est un langage généraliste complet, plus un écosystème de bibliothèques.

SQL (analyste)

Python (analyste)

Concepts de base

~20 (SELECT, WHERE, GROUP BY, JOIN, CTE, fenêtres…)

Variables, types, listes, dicts, boucles, fonctions, classes…

Bibliothèques à apprendre

Aucune

pandas, NumPy, matplotlib/seaborn, souvent requests, etc.

Environnement

Un éditeur web (BigQuery, Metabase…)

Installation, environnements virtuels, notebooks, dépendances

Erreurs typiques

Logiques (jointure, NULL, doublons)

Logiques + syntaxe + types + versions de librairies

Temps avant d'être utile en entreprise

Quelques semaines de pratique sérieuse

Plusieurs mois

Raison 3 : la même question, deux niveaux de complexité

Question business (SaaS) : « Quel est le revenu mensuel par plan, uniquement pour les abonnements actifs ? »

-- ✅ En SQL : lisible même par un non-technique
-- Table subscriptions : subscription_id, user_id, plan, mrr, statut, started_at
 
SELECT
plan,
COUNT(*) AS nb_abonnes,
SUM(mrr) AS mrr_total,
ROUND(AVG(mrr), ) AS mrr_moyen
FROM subscriptions
WHERE statut = 'actif'
GROUP BY plan
ORDER BY mrr_total DESC;
 
-- Résultat :
-- plan | nb_abonnes | mrr_total | mrr_moyen
-- Business | 420 | 41 580 | 99.00
-- Pro | 1 850 | 53 650 | 29.00
-- Starter | 3 200 | 28 800 | 9.00
devenir-data-analyst · 03

La même chose en Python demande de savoir : se connecter à la base (ou charger un CSV), connaître pandas, comprendre groupby, agg, les index, reset_index, sort_values… et de gérer l'environnement qui va avec.

# Équivalent pandas : correct, mais beaucoup plus de notions à maîtriser
import pandas as pd
 
df = pd.read_csv("subscriptions.csv") # ou connexion à la base
actifs = df[df["statut"] == "actif"]
res = (
actifs.groupby("plan")
.agg(nb_abonnes=("subscription_id", "count"),
mrr_total=("mrr", "sum"),
mrr_moyen=("mrr", "mean"))
.round({"mrr_moyen": 2})
.sort_values("mrr_total", ascending=False)
.reset_index()
)
devenir-data-analyst · 04

Ce n'est pas que Python soit « mauvais ». C'est qu'il y a plus de choses à savoir avant d'être productif. Pour un premier poste, SQL te donne le meilleur retour sur investissement.

Raison 4 : SQL est stable

Le GROUP BY que tu apprends aujourd'hui fonctionnera dans 10 ans. SQL existe depuis les années 70 et reste le standard d'accès aux données, même dans les outils les plus récents (BigQuery, Snowflake, dbt, DuckDB). Ce que tu investis dans SQL ne se périme pas.

Raison 5 : avec l'IA, SQL devient encore plus rentable

Les assistants IA écrivent du SQL très correctement. Mais ils se trompent sur ce qui compte vraiment : la logique métier (quel est le bon grain ? faut-il exclure les commandes annulées ? comment définir un client actif ?). Pour vérifier ce que l'IA te propose, tu dois lire et comprendre le SQL. Le maîtriser fait de toi celui qui valide, pas celui qui copie-colle.


🧪 Apprends le SQL qui sert vraiment en poste

Sur Modai Lab, tu travailles directement les requêtes que demandent les managers : CA par segment, rétention, funnels, cohortes, contrôles qualité. Avec un feedback qui t'explique la logique, pas seulement la syntaxe.

👉 Pratiquer sur modai-lab.com

_Exercices progressifs · Cas métiers · Feedback détaillé_


PARTIE 4 — Le socle SQL à maîtriser, niveau par niveau

Voici exactement ce qu'il faut savoir faire pour être opérationnel en tant que data analyst junior. Pas plus au début. Pas moins.

Niveau 1 — Lire et filtrer

SELECT, WHERE, ORDER BY, LIMIT, DISTINCT, IN, BETWEEN, LIKE, IS NULL.

-- ❌ Le réflexe débutant
SELECT *
FROM orders
WHERE statut != 'annulee';
-- Problème 1 : SELECT * ramène toutes les colonnes (coûteux sur BigQuery, illisible)
-- Problème 2 : les lignes où statut est NULL disparaissent aussi !
-- NULL != 'annulee' renvoie NULL, pas TRUE -> ligne exclue
 
-- ✅ La version propre
SELECT order_id, user_id, created_at, montant, statut
FROM orders
WHERE statut != 'annulee' OR statut IS NULL;
-- Gain : uniquement les colonnes utiles, et aucune ligne perdue en silence
devenir-data-analyst · 05

Niveau 2 — Agréger

COUNT, SUM, AVG, MIN, MAX, GROUP BY, HAVING, COUNT(DISTINCT).

-- ❌ Confondre WHERE et HAVING
SELECT user_id, SUM(montant) AS total
FROM orders
WHERE SUM(montant) > -- ERREUR : WHERE s'applique avant l'agrégation
GROUP BY user_id;
 
-- ✅ Filtrer les lignes avec WHERE, les groupes avec HAVING
SELECT user_id, SUM(montant) AS total
FROM orders
WHERE statut = 'livree' -- filtre sur les lignes
GROUP BY user_id
HAVING SUM(montant) > ; -- filtre sur les groupes
devenir-data-analyst · 06

Niveau 3 — Joindre

INNER JOIN, LEFT JOIN, jointures multiples, et surtout : connaître le grain de chaque table.

-- ❌ La jointure qui gonfle le CA
SELECT u.region, SUM(o.montant) AS ca
FROM orders o
JOIN order_items i ON o.order_id = i.order_id -- 1 commande = N lignes d'articles
JOIN users u ON o.user_id = u.user_id
GROUP BY u.region;
-- Problème : chaque commande est dupliquée autant de fois qu'elle a d'articles.
-- Commande 1001 (montant 120 €, 3 articles) -> comptée 3 fois -> 360 € !
 
-- ✅ Joindre au bon grain
SELECT u.region, SUM(o.montant) AS ca
FROM orders o
JOIN users u ON o.user_id = u.user_id -- grain commande conservé
WHERE o.statut = 'livree'
GROUP BY u.region;
-- Gain : 1 ligne = 1 commande, le CA est juste
devenir-data-analyst · 07

Niveau 4 — Structurer avec CASE WHEN, les dates et les CTE

-- Cas RH : segmenter les salariés par ancienneté et calculer le salaire moyen
-- Table employees : employee_id, departement, date_entree, salaire_brut, statut
 
WITH salaries_actifs AS (
SELECT
employee_id,
departement,
salaire_brut,
DATE_DIFF(CURRENT_DATE(), date_entree, YEAR) AS anciennete
FROM employees
WHERE statut = 'actif'
),
segmentes AS (
SELECT
*,
CASE
WHEN anciennete < THEN '0-2 ans'
WHEN anciennete < THEN '2-5 ans'
ELSE '5 ans et +'
END AS tranche_anciennete
FROM salaries_actifs
)
SELECT
departement,
tranche_anciennete,
COUNT(*) AS effectif,
ROUND(AVG(salaire_brut), ) AS salaire_moyen
FROM segmentes
GROUP BY departement, tranche_anciennete
ORDER BY departement, tranche_anciennete;
 
-- Résultat (extrait) :
-- departement | tranche | effectif | salaire_moyen
-- Data | 0-2 ans | 12 | 44 500
-- Data | 2-5 ans | 9 | 55 200
-- Data | 5 ans et + | 4 | 68 000
devenir-data-analyst · 08

Les CTE (WITH) sont le meilleur ami du data analyst : chaque étape a un nom, la requête se lit de haut en bas, et tu peux tester chaque bloc séparément.

Niveau 5 — Les fonctions de fenêtre (ce qui fait la différence en entretien)

ROW_NUMBER, RANK, LAG, LEAD, SUM() OVER, AVG() OVER.

-- Cas finance : évolution mensuelle du volume de transactions par client
-- Table transactions : transaction_id, client_id, created_at, montant, type
 
WITH mensuel AS (
SELECT
client_id,
DATE_TRUNC(created_at, MONTH) AS mois,
SUM(montant) AS volume
FROM transactions
WHERE type = 'paiement_carte'
GROUP BY client_id, mois
)
SELECT
client_id,
mois,
volume,
LAG(volume) OVER (PARTITION BY client_id ORDER BY mois) AS volume_mois_prec,
ROUND(
* (volume - LAG(volume) OVER (PARTITION BY client_id ORDER BY mois))
/ NULLIF(LAG(volume) OVER (PARTITION BY client_id ORDER BY mois), )
, ) AS evolution_pct
FROM mensuel
ORDER BY client_id, mois;
 
-- Résultat :
-- client_id | mois | volume | volume_mois_prec | evolution_pct
-- C-001 | 2026-07 | 1 240 | NULL | NULL
-- C-001 | 2026-08 | 980 | 1 240 | -21.0
-- C-001 | 2026-09 | 310 | 980 | -68.4 <- signal de churn
devenir-data-analyst · 09

Si tu maîtrises ces 5 niveaux sur des cas business, tu as le niveau SQL d'un data analyst junior opérationnel. Ensuite viennent les cohortes, la rétention, les funnels, qui ne sont que des combinaisons de ces briques.

Cas business complet : rétention par cohorte (SaaS)

C'est LA requête qui impressionne en entretien, et elle n'utilise que les briques ci-dessus.

-- Tables : users (user_id, created_at), sessions (session_id, user_id, started_at)
-- Question : parmi les inscrits de chaque mois, quel % revient M+1, M+2, M+3 ?
 
WITH cohortes AS (
SELECT user_id, DATE_TRUNC(created_at, MONTH) AS mois_cohorte
FROM users
),
activite AS (
SELECT DISTINCT user_id, DATE_TRUNC(started_at, MONTH) AS mois_activite
FROM sessions
),
jointure AS (
SELECT
c.mois_cohorte,
c.user_id,
DATE_DIFF(a.mois_activite, c.mois_cohorte, MONTH) AS mois_depuis_inscription
FROM cohortes c
JOIN activite a ON c.user_id = a.user_id
WHERE a.mois_activite >= c.mois_cohorte
)
SELECT
mois_cohorte,
COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL)) AS m0,
ROUND( * COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL))
/ COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL)), ) AS m1_pct,
ROUND( * COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL))
/ COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL)), ) AS m2_pct,
ROUND( * COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL))
/ COUNT(DISTINCT IF(mois_depuis_inscription = , user_id, NULL)), ) AS m3_pct
FROM jointure
GROUP BY mois_cohorte
ORDER BY mois_cohorte;
 
-- Résultat :
-- mois_cohorte | m0 | m1_pct | m2_pct | m3_pct
-- 2026-05 | 1 820 | 42.3 | 31.0 | 26.4
-- 2026-06 | 2 140 | 45.1 | 33.8 | 28.9
-- 2026-07 | 2 560 | 38.2 | 27.5 | NULL <- onboarding de juillet à investiguer
devenir-data-analyst · 10

🧪 Où te situes-tu sur les 5 niveaux ?

Le test Modai Lab couvre exactement cette progression : filtres, agrégations, jointures, CTE, fenêtres. En 5 minutes, tu sais si tu es au niveau 2 ou au niveau 5, et quoi travailler ensuite.

👉 Faire le test sur modai-lab.com/test-sql/

_Niveau par compétence · Recommandations ciblées · Gratuit_


PARTIE 5 — Les erreurs classiques des futurs data analysts

Erreur 1 : apprendre la syntaxe sans le contexte business

❌ Le junior enchaîne les exercices « sélectionne les employés dont le salaire est supérieur à 3 000 ». Il connaît la syntaxe, mais en entretien, face à « calcule le taux de conversion du funnel », il ne sait pas par où commencer.

✅ Le senior commence toujours par la question business : quel est le grain ? quelle est la définition du KPI ? quelles lignes exclure ? La syntaxe vient ensuite, presque naturellement.

Erreur 2 : ne jamais vérifier ses résultats

-- ❌ Le junior lance la requête, copie le chiffre, l'envoie au manager
SELECT COUNT(*) AS nb_clients FROM orders;
-- 48 230 « clients »... alors qu'il s'agit de commandes !
 
-- ✅ Le senior contrôle systématiquement grain et ordres de grandeur
SELECT
COUNT(*) AS nb_lignes,
COUNT(DISTINCT order_id) AS nb_commandes,
COUNT(DISTINCT user_id) AS nb_clients
FROM orders;
-- nb_lignes = 48 230 | nb_commandes = 48 230 | nb_clients = 17 905
-- Gain : il sait exactement ce qu'il compte avant de l'envoyer
devenir-data-analyst · 11

Erreur 3 : oublier les NULL

-- ❌ Taux de réponse à une enquête RH
SELECT AVG(note_satisfaction) AS satisfaction_moyenne
FROM enquete_rh;
-- AVG ignore les NULL : les non-répondants disparaissent sans prévenir
-- Résultat 7.8/10... mais seulement 35 % des salariés ont répondu
 
-- ✅ Rendre visible ce qui manque
SELECT
COUNT(*) AS nb_salaries,
COUNT(note_satisfaction) AS nb_repondants,
ROUND( * COUNT(note_satisfaction) / COUNT(*), ) AS taux_reponse_pct,
ROUND(AVG(note_satisfaction), ) AS satisfaction_moyenne
FROM enquete_rh;
-- 1 200 | 420 | 35.0 | 7.8 -> le chiffre est remis dans son contexte
devenir-data-analyst · 12

Erreur 4 : dédoublonner avec DISTINCT au lieu de comprendre

-- ❌ « J'ai des doublons, je mets DISTINCT »
SELECT DISTINCT user_id, email, plan, updated_at
FROM subscriptions_history;
-- Les lignes diffèrent par updated_at : DISTINCT ne dédoublonne rien
 
-- ✅ Garder la dernière version de chaque abonnement
SELECT user_id, email, plan, updated_at
FROM (
SELECT
*,
ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY updated_at DESC) AS rn
FROM subscriptions_history
)
WHERE rn = ;
-- Gain : une ligne par user, la plus récente, de façon explicite
devenir-data-analyst · 13

Erreur 5 : vouloir tout apprendre avant de postuler

❌ Le junior attend d'avoir « fini » Python, les stats et le machine learning avant d'envoyer son premier CV. Il n'a jamais fini.

✅ Le senior (qui a été junior) sait qu'on apprend énormément en poste. Un SQL solide, un portfolio de 2-3 analyses business, et tu postules. Le reste s'apprend avec de vraies données et de vrais problèmes.

Erreur 6 : faire des projets portfolio sans question business

❌ « Analyse du dataset Titanic » ou « Prédiction des prix immobiliers » : déjà vus mille fois, aucun lien avec le quotidien d'un analyste.

✅ « Pourquoi la rétention de la cohorte de juillet est 7 points plus basse ? », « Quels segments de clients génèrent 80 % du CA ? » : une question, une requête SQL propre, un graphique, trois recommandations.


🧪 Évite ces erreurs en pratiquant sur des cas réalistes

Les exercices Modai Lab sont construits autour de ces pièges (doublons de jointure, NULL silencieux, grain mal défini) pour que tu les rencontres à l'entraînement plutôt qu'en entretien.

👉 Pratiquer sur modai-lab.com

_Pièges réels · Explications de senior · Progression mesurée_


PARTIE 6 — Ton plan de route sur 90 jours

Semaines 1 à 4 : les fondamentaux SQL

  • SELECT, WHERE, ORDER BY, GROUP BY, HAVING, JOIN

  • 30 à 45 minutes par jour, tous les jours, plutôt que 5 heures le dimanche

  • Chaque exercice : formule d'abord la question business en une phrase

  • Objectif de fin de mois : écrire sans aide une requête CA par mois et par segment

Semaines 5 à 8 : le SQL intermédiaire

  • CASE WHEN, fonctions de dates, CTE, sous-requêtes

  • Gestion des NULL, dédoublonnage, contrôle de grain

  • Début des fonctions de fenêtre : ROW_NUMBER, LAG

  • Objectif : refaire les requêtes de la partie 4 de ce guide sans les regarder

Semaines 9 à 12 : SQL avancé + mise en valeur

  • Cohortes, rétention, funnels, parts de CA (Pareto)

  • Un outil de BI : Power BI ou Looker Studio, pour montrer tes résultats

  • 2 à 3 projets portfolio avec une vraie question business chacun

  • Préparation aux tests techniques SQL en temps limité

Après 90 jours : candidater, puis élargir

  • Tu postules avec ton SQL, ta BI, et tes projets

  • Une fois en poste (ou en parallèle des candidatures), tu peux ouvrir le chapitre Python : pandas d'abord, sur des cas où SQL est moins adapté

  • Tu ne pars plus de zéro : tu sais déjà penser en tables, en grain et en agrégations

Ce que contient un bon projet portfolio

Élément

Exemple

Une question business

« Quels canaux d'acquisition amènent les clients les plus rentables ? »

Les données

Dataset public réaliste ou dataset d'entraînement e-commerce/SaaS

La requête SQL

Propre, commentée, découpée en CTE

Un visuel

1 ou 2 graphiques clairs (BI ou Google Sheets)

Les conclusions

3 constats chiffrés + 2 recommandations actionnables

Les limites

Ce que les données ne permettent pas de conclure


🧪 Valide ton niveau à la fin de chaque étape

Repasse le test à la fin de chaque bloc de 4 semaines : c'est le moyen le plus simple de mesurer ta progression et de savoir quand tu es prêt pour les entretiens.

👉 Faire le test sur modai-lab.com/test-sql/

_Mesure ta progression · Repère tes lacunes · Prépare tes entretiens_


Prompt Claude pour auditer tes requêtes

Copie-colle ce prompt dans Claude, puis colle ta requête et le contexte en dessous.

Tu es un data analyst senior qui fait la revue de code SQL d'un data analyst
junior. Ton objectif est de l'aider à progresser, pas seulement de corriger.
 
Je vais te donner :
1. La question business à laquelle ma requête doit répondre
2. Le schéma des tables utilisées (colonnes + grain de chaque table si je le connais)
3. Ma requête SQL
 
Fais une revue structurée en vérifiant point par point :
 
A. Compréhension du besoin
- Ma requête répond-elle vraiment à la question business posée ?
- La définition du KPI est-elle explicite et cohérente (ex : client actif, CA, churn) ?
- Ai-je exclu les bonnes lignes (annulations, tests, remboursements) ?
 
B. Grain et jointures
- Quel est le grain de chaque table et le grain du résultat final ?
- Une jointure risque-t-elle de dupliquer des lignes et de gonfler une somme ?
- Un LEFT JOIN est-il transformé en INNER JOIN par une condition dans le WHERE ?
 
C. NULL et cas limites
- Y a-t-il des comparaisons (=, !=, NOT IN) qui excluent des NULL sans le vouloir ?
- Les moyennes et les ratios gèrent-ils les NULL et les divisions par zéro (NULLIF) ?
 
D. Agrégations et filtres
- WHERE et HAVING sont-ils utilisés au bon endroit ?
- COUNT(*) vs COUNT(col) vs COUNT(DISTINCT col) : le bon choix est-il fait ?
- DISTINCT est-il utilisé pour masquer un problème de doublons ?
 
E. Lisibilité et performance
- La requête serait-elle plus claire découpée en CTE nommées ?
- Y a-t-il un SELECT * inutile ou un filtre de date manquant (coût sur BigQuery) ?
 
Pour chaque problème trouvé, donne :
- Le niveau de gravité (bloquant / important / amélioration)
- Une explication simple de pourquoi c'est un problème, avec un exemple chiffré
- La correction
 
Termine par :
1. La version corrigée complète de ma requête, commentée
2. Une requête de contrôle pour vérifier que le résultat est cohérent
3. Les 2 notions SQL que je devrais travailler en priorité d'après cette revue
devenir-data-analyst · 14

Récapitulatif

Principe

Ce que ça veut dire concrètement

Le métier est majoritairement SQL

Questions business, KPI, qualité de données : tout passe par des requêtes

Choisir ses combats

Un combat principal (SQL), un secondaire (BI), la logique business en continu

Python n'est pas un prérequis

Utile plus tard, rarement bloquant pour un premier poste d'analyste

SQL est plus simple à maîtriser

Déclaratif, ~20 concepts, aucun environnement à installer, stable dans le temps

Niveau 1 : lire et filtrer

SELECT, WHERE, attention aux NULL

Niveau 2 : agréger

GROUP BY, HAVING vs WHERE, COUNT DISTINCT

Niveau 3 : joindre

Toujours connaître le grain, éviter les doublons de jointure

Niveau 4 : structurer

CASE WHEN, dates, CTE

Niveau 5 : fenêtres

ROW_NUMBER, LAG, SUM OVER : ce qui fait la différence en entretien

Portfolio

2-3 projets avec une vraie question business, pas Titanic

Plan 90 jours

Fondamentaux → intermédiaire → avancé + BI + candidatures


✅ Checklist pour devenir data analyst

  • ☐ J'ai fait le test de niveau SQL et je connais mon point de départ

  • ☐ J'ai choisi UN combat principal (SQL) et j'ai mis Python en pause

  • ☐ Je pratique SQL au moins 30 minutes par jour

  • ☐ Je formule la question business avant d'écrire chaque requête

  • ☐ Je connais le grain de chaque table que j'utilise

  • ☐ Je sais faire la différence entre WHERE et HAVING

  • ☐ Je contrôle les NULL dans mes filtres et mes moyennes

  • ☐ Je sais détecter et éviter un doublon de jointure

  • ☐ J'écris mes requêtes longues avec des CTE nommées

  • ☐ Je maîtrise ROW_NUMBER et LAG sur un cas business

  • ☐ J'ai construit une analyse de rétention par cohorte

  • ☐ Je sais présenter un résultat dans un outil de BI

  • ☐ J'ai 2 à 3 projets portfolio avec question, requête, visuel et recommandations

  • ☐ J'ai commencé à postuler sans attendre de « tout savoir »


🚀 Ton premier combat commence maintenant

Devenir data analyst, ce n'est pas tout apprendre : c'est maîtriser à fond la compétence qui compte le plus, puis élargir. Commence par mesurer ton niveau SQL, et entraîne-toi sur les cas business que tu retrouveras en poste.

👉 modai-lab.com/test-sql/ — Exercices calibrés · Cas business réels · Feedback senior


_Guide offert suite au post LinkedIn · Entraînez-vous sur modai-lab.com/test-sql/ · Partagez librement ♻️_