Top 25 des questions d'entretien en Data Analytics en 2026

Les entretiens en data analytics en 2026 vont bien au-delà de la simple syntaxe SQL ou de la création de graphiques. Les recruteurs évaluent la capacité des candidats à extraire du sens à partir de données désordonnées, à communiquer les résultats à des interlocuteurs non techniques et à relier chaque indicateur à un objectif business concret. Ce guide couvre les 25 questions qui reviennent le plus fréquemment lors des entretiens pour des postes de data analyst junior, intermédiaire et senior.

Questions SQL pour les entretiens Data Analyst

SQL reste la compétence la plus testée en entretien data analytics. Toute entreprise disposant d'une base de données relationnelle attend des analystes qu'ils rédigent des requêtes de manière autonome. Pour approfondir les modèles avancés, consulter Fonctions de fenêtrage SQL, CTE et requêtes avancées.

1. Quelle est la différence entre WHERE et HAVING ?

WHERE filtre les lignes avant l'agrégation. HAVING filtre les groupes après l'agrégation. Confondre les deux constitue l'une des erreurs les plus courantes lors des tests techniques.

-- monthly_revenue.sql
SELECT
  DATE_TRUNC('month', order_date) AS month,
  SUM(amount)                     AS revenue
FROM orders
WHERE status = 'completed'          -- filtre au niveau des lignes
GROUP BY month
HAVING SUM(amount) > 10000;         -- filtre au niveau des groupes

WHERE réduit le jeu de données avant que le moteur de base de données n'exécute le GROUP BY. HAVING opère sur le résultat agrégé. L'utilisation de WHERE chaque fois que possible améliore les performances de la requête en réduisant le volume de données traité plus tôt dans le plan d'exécution.

2. Expliquer les fonctions de fenêtrage avec un exemple pratique

Les fonctions de fenêtrage (window functions) calculent une valeur sur un ensemble de lignes liées à la ligne courante, sans réduire le jeu de résultats. Elles sont indispensables pour le classement, les totaux cumulés et les comparaisons de période à période.

-- user_ranking.sql
SELECT
  user_id,
  purchase_date,
  amount,
  ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY purchase_date) AS purchase_rank,
  SUM(amount)   OVER (PARTITION BY user_id ORDER BY purchase_date) AS running_total,
  LAG(amount)   OVER (PARTITION BY user_id ORDER BY purchase_date) AS prev_amount
FROM purchases;

ROW_NUMBER attribue un rang séquentiel par utilisateur. SUM(...) OVER(...) calcule un total cumulé sans auto-jointure. LAG récupère la valeur de la ligne précédente pour une comparaison directe. Les recruteurs demandent fréquemment de calculer la croissance mois par mois en utilisant exactement ce type de requête.

3. Comment identifier et supprimer les doublons

La détection des doublons est une tâche quotidienne pour les analystes travaillant avec des journaux d'événements, des exports CRM ou des flux de données tiers.

-- deduplicate_events.sql
WITH ranked AS (
  SELECT *,
    ROW_NUMBER() OVER (
      PARTITION BY user_id, event_type, DATE_TRUNC('minute', created_at)
      ORDER BY created_at
    ) AS rn
  FROM events
)
SELECT * FROM ranked WHERE rn = 1;

La CTE attribue un numéro de ligne au sein de chaque groupe de doublons. Ne conserver que rn = 1 renvoie la première occurrence. Cette approche préserve les données originales tout en éliminant le bruit.

4. Écrire une requête de rétention par cohorte hebdomadaire

La rétention par cohorte est l'une des analyses les plus demandées dans les équipes produit et croissance. Le schéma SQL suit une structure cohérente quelle que soit la base de données. Pour s'exercer davantage, essayer le module d'entretien sur la rétention par cohorte.

-- weekly_cohort_retention.sql
WITH cohorts AS (
  SELECT
    user_id,
    DATE_TRUNC('week', MIN(event_date)) AS cohort_week
  FROM user_events
  GROUP BY user_id
),
activity AS (
  SELECT
    c.cohort_week,
    DATE_TRUNC('week', e.event_date) AS active_week,
    COUNT(DISTINCT e.user_id)        AS active_users
  FROM user_events e
  JOIN cohorts c ON c.user_id = e.user_id
  GROUP BY c.cohort_week, DATE_TRUNC('week', e.event_date)
)
SELECT
  cohort_week,
  EXTRACT(WEEK FROM active_week - cohort_week) AS weeks_since_signup,
  active_users
FROM activity
ORDER BY cohort_week, weeks_since_signup;

La première CTE identifie la semaine d'inscription de chaque utilisateur. La deuxième CTE compte les utilisateurs actifs distincts par cohorte et par semaine. La requête finale transforme le résultat en une matrice de rétention. Les recruteurs attendent des candidats qu'ils expliquent l'interprétation business : une chute brutale à la semaine 1 signale un problème d'onboarding, tandis qu'une courbe plate à partir de la semaine 4 suggère une base d'utilisateurs fidèles et stable.

5. Qu'est-ce qu'une CTE et quand remplace-t-elle une sous-requête ?

Une Common Table Expression (CTE) est un ensemble de résultats temporaire nommé défini avec WITH. Les CTE améliorent la lisibilité et permettent les requêtes récursives. Les sous-requêtes tendent à produire du SQL profondément imbriqué, difficile à déboguer. Une CTE est préférable lorsque la même table dérivée est référencée plusieurs fois dans la requête, ou lorsque la logique comporte trois étapes de transformation ou plus.

Questions Python pour l'analyse de données

Les questions Python en 2026 se concentrent sur Pandas 3.0, les workflows de nettoyage de données et la capacité à expliquer le code en termes business. Les recruteurs recherchent des solutions pragmáticas, pas des abstractions académiques.

6. Comment gérer les valeurs manquantes dans un DataFrame Pandas

Les données manquantes faussent les agrégations et les entrées de modèles. L'approche dépend du type de colonne et du contexte métier. Avec pandas 3.0, les colonnes de type chaîne utilisent désormais le dtype str basé sur PyArrow, qui gère les valeurs manquantes comme NaN de manière cohérente.

# handle_missing.py
import pandas as pd
import numpy as np

df = pd.read_csv('sales.csv')

# Inspecter l'étendue des données manquantes
print(df.isnull().sum())
print(df.isnull().mean().round(3))  # pourcentage par colonne

# Stratégie 1 : supprimer les lignes où les colonnes critiques sont nulles
df_clean = df.dropna(subset=['customer_id', 'amount'])

# Stratégie 2 : remplir les colonnes numériques avec la médiane (robuste aux valeurs aberrantes)
df['amount'] = df['amount'].fillna(df['amount'].median())

# Stratégie 3 : remplir les colonnes catégorielles avec le mode
df['region'] = df['region'].fillna(df['region'].mode()[0])

La suppression de lignes fonctionne lorsque le taux de données manquantes est inférieur à 5 % et que la colonne est critique. L'imputation par la médiane est plus sûre que la moyenne pour les distributions asymétriques. L'imputation par le mode convient aux colonnes catégorielles ayant une valeur dominante. Documenter la stratégie d'imputation est essentiel pour la traçabilité.

7. Merge, join et concatenate : quand utiliser chacun

Pandas offre plusieurs méthodes pour combiner des DataFrames. Le choix dépend de l'opération (par lignes ou par colonnes) et de la nécessité d'une correspondance par clé.

# combine_dataframes.py
import pandas as pd

orders = pd.read_csv('orders.csv')
customers = pd.read_csv('customers.csv')

# Fusion par clé (équivalent d'un SQL JOIN)
result = orders.merge(customers, on='customer_id', how='left')

# Empiler les lignes de plusieurs sources
all_events = pd.concat([events_q1, events_q2], ignore_index=True)

# Ajouter des colonnes côte à côte (même nombre de lignes requis)
combined = pd.concat([features, labels], axis=1)

merge est le bon choix pour les jointures par clé. concat avec axis=0 par défaut empile les lignes. concat avec axis=1 ajoute des colonnes. L'utilisation de how='left' préserve toutes les lignes du DataFrame gauche, ce qui correspond à un LEFT JOIN en SQL.

8. Grouper, agréger et transformer des données de ventes

Les opérations GroupBy sont l'équivalent Pandas du GROUP BY SQL. Ce schéma apparaît dans pratiquement tous les exercices à domicile de data analyst.

# sales_analysis.py
import pandas as pd

df = pd.read_csv('transactions.csv', parse_dates=['date'])

# Revenu mensuel par catégorie de produit
monthly = (
    df.groupby([pd.Grouper(key='date', freq='ME'), 'category'])
    .agg(revenue=('amount', 'sum'), orders=('order_id', 'nunique'))
    .reset_index()
)

# Ajouter une colonne avec la part de chaque catégorie dans le revenu mensuel total
monthly['share'] = (
    monthly.groupby('date')['revenue']
    .transform(lambda x: x / x.sum())
    .round(4)
)

print(monthly.head(10))

Note : pandas 3.0 a changé l'alias de fréquence par défaut de 'M' à 'ME' (MonthEnd). Le code utilisant l'ancien alias 'M' provoquera une erreur. agg avec agrégation nommée maintient la lisibilité du résultat. transform diffuse un calcul au niveau du groupe vers chaque ligne, ce qui évite une étape de fusion séparée. Cette combinaison couvre la majorité des tâches de reporting ad-hoc.

9. Qu'est-ce qui a changé avec Copy-on-Write dans pandas 3.0 ?

Copy-on-Write (CoW) est devenu le mode par défaut et unique dans pandas 3.0 (janvier 2026). Ce changement élimine l'imprévisible SettingWithCopyWarning mais casse les patterns d'assignation chaînée qui fonctionnaient dans pandas 2.x.

# copy_on_write_demo.py
import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# Ceci NE MODIFIE PLUS df dans pandas 3.0
df['A'][0] = 999  # Ne fait rien, pas d'avertissement

# Approche correcte : utiliser .loc pour l'assignation directe
df.loc[0, 'A'] = 999  # Fonctionne

# Quand une copie indépendante est nécessaire, être explicite
subset = df[df['A'] > 1].copy()
subset['A'] = subset['A'] * 2  # Modification sûre

Les recruteurs en 2026 attendent des candidats qu'ils expliquent pourquoi l'assignation chaînée échoue et comment la corriger. La bonne réponse : utiliser .loc ou .iloc pour l'assignation directe, et appeler .copy() explicitement lors de la création d'un sous-ensemble qui sera modifié. Consulter le guide de migration pandas 3.0 pour la liste complète des changements.

10. Détecter et traiter les valeurs aberrantes dans un jeu de données

La détection des valeurs aberrantes détermine si les valeurs extrêmes sont des erreurs de saisie, des signaux de fraude ou de véritables cas limites.

# detect_outliers.py
import pandas as pd
import numpy as np

df = pd.read_csv('transactions.csv')

# Méthode IQR
Q1 = df['amount'].quantile(0.25)
Q3 = df['amount'].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR

outliers = df[(df['amount'] < lower) | (df['amount'] > upper)]
print(f'Outliers found: {len(outliers)} ({len(outliers)/len(df)*100:.1f}%)')

# Plafonner au lieu de supprimer (winsorisation)
df['amount_capped'] = df['amount'].clip(lower=lower, upper=upper)

La méthode IQR signale les valeurs au-delà de 1,5 fois l'écart interquartile. Le plafonnement (winsorisation) préserve le nombre de lignes tout en limitant l'influence des valeurs extrêmes. La suppression n'est appropriée que lorsque les valeurs aberrantes représentent des erreurs manifestes.

Questions de statistiques et probabilités

La culture statistique distingue les data analysts qui se contentent de rapporter des chiffres de ceux qui les interprètent correctement. Ces questions testent la compréhension fondamentale.

11. Expliquer la p-value en langage simple

Une p-value est la probabilité d'observer un résultat au moins aussi extrême que celui mesuré, en supposant que l'hypothèse nulle est vraie. Une p-value de 0,03 ne signifie pas qu'il y a 3 % de chances que l'hypothèse nulle soit vraie. Cela signifie que si l'hypothèse nulle était vraie, des résultats aussi extrêmes apparaîtraient 3 % du temps par le seul fait du hasard. Le seuil (alpha) est généralement fixé à 0,05, mais le choix dépend du coût d'un faux positif dans le contexte métier spécifique.

12. Quand utiliser la médiane plutôt que la moyenne

La moyenne est sensible aux valeurs extrêmes. Les données de revenus, les montants de transactions et les durées de session sont des exemples classiques où la médiane donne une tendance centrale plus représentative. Un jeu de données comportant quelques transactions de grande valeur peut pousser la moyenne bien au-dessus de ce que vit un client typique. Présenter la médiane aux côtés de la moyenne, en incluant l'écart type, donne aux parties prenantes une vision complète.

13. Quelle est la différence entre corrélation et causalité ?

La corrélation mesure l'intensité et la direction d'une relation linéaire entre deux variables. La causalité signifie qu'une variable influence directement l'autre. Les ventes de glaces et les noyades sont corrélées parce que les deux augmentent en été, et non parce que l'une cause l'autre. Établir la causalité nécessite une expérience contrôlée (test A/B) ou un cadre rigoureux d'inférence causale tel que la méthode des différences de différences ou les variables instrumentales.

14. Expliquer les erreurs de type I et de type II avec un exemple business

Une erreur de type I (faux positif) se produit lorsqu'un test rejette incorrectement l'hypothèse nulle. Exemple : conclure qu'un nouveau tunnel de paiement augmente le taux de conversion alors qu'il n'a en réalité aucun effet, conduisant à une modification produit inutile. Une erreur de type II (faux négatif) se produit lorsqu'un test ne détecte pas un effet réel. Exemple : conserver l'ancien tunnel de paiement parce que le test n'avait pas un échantillon suffisant pour détecter une amélioration réelle de 2 %. Augmenter la taille de l'échantillon réduit les erreurs de type II. Abaisser le seuil alpha réduit les erreurs de type I mais augmente les erreurs de type II.

Questions Power BI et visualisation de données

Les questions sur la visualisation évaluent la capacité d'un candidat à choisir le bon graphique, à construire des tableaux de bord maintenables et à communiquer des histoires de données à des audiences non techniques.

15. Qu'est-ce que le DAX et en quoi diffère-t-il du SQL ?

DAX (Data Analysis Expressions) est le langage de formules utilisé dans Power BI, Analysis Services et Excel Power Pivot. Contrairement au SQL, qui opère sur des ensembles de lignes, le DAX opère dans un contexte de filtre qui change dynamiquement en fonction des segments, filtres et du contexte de ligne. La fonction CALCULATE en DAX modifie le contexte de filtre avant d'évaluer une expression, un concept sans équivalent direct en SQL. Pour une comparaison des outils de visualisation, consulter Power BI vs Tableau en 2026.

16. Expliquer le mode Import, DirectQuery et Direct Lake

Le mode Import charge les données dans le moteur en mémoire de Power BI (VertiPaq), offrant des performances de requête rapides mais nécessitant des rafraîchissements planifiés. DirectQuery envoie les requêtes à la base de données source en temps réel, garantissant la fraîcheur des données mais dépendant des performances du système source.

Direct Lake, disponible dans Microsoft Fabric, lit des fichiers Parquet depuis OneLake sans importer ni interroger un point de terminaison SQL. Depuis août 2026, Direct Lake sur OneLake prend en charge les modèles composites, permettant de combiner des tables Direct Lake avec des tables Import et DirectQuery dans le même modèle sémantique. Cela associe une fraîcheur quasi temps réel avec la vitesse de l'analyse en mémoire. Pour les workflows CI/CD, les connexions Direct Lake se remappent automatiquement lors du déploiement entre espaces de travail.

17. Quand utiliser un graphique à barres plutôt qu'un graphique linéaire

Les graphiques à barres comparent des catégories discrètes (revenu par région, nombre par produit). Les graphiques linéaires montrent des tendances sur des intervalles continus (utilisateurs actifs quotidiens, taux de churn mensuel). Utiliser un graphique linéaire pour des données catégorielles suggère une tendance entre des catégories sans rapport, ce qui induit le public en erreur. Une question de suivi fréquente en entretien porte sur les graphiques circulaires : ils ne devraient être utilisés que pour montrer les parties d'un tout lorsqu'il n'y a pas plus de cinq segments, car l'oeil humain peine à comparer les angles avec précision.

18. Comment optimiser un rapport Power BI lent

Les rapports lents proviennent généralement de colonnes excessives dans le modèle de données, de mesures DAX complexes évaluées ligne par ligne, ou de visuels interrogeant des millions de lignes. La liste de vérification d'optimisation comprend : supprimer les colonnes inutilisées pour réduire la taille du modèle, remplacer les fonctions itératives (SUMX, FILTER) par leurs équivalents non itératifs lorsque c'est possible, réduire le nombre de visuels par page à moins de 15, et utiliser des tables d'agrégation pour les dimensions à haute cardinalité. L'outil Performance Analyzer intégré à Power BI Desktop identifie précisément quel visuel ou quelle requête DAX constitue le goulot d'étranglement.

Questions comportementales et études de cas

Les compétences techniques permettent d'accéder à l'entretien. Les questions comportementales déterminent si le candidat obtient le poste. Chaque réponse doit suivre le framework STAR : Situation, Tâche, Action, Résultat.

19. Décrire une situation où l'analyse de données a changé une décision business

Les bonnes réponses incluent un indicateur spécifique qui a évolué, la méthode d'analyse utilisée et l'impact en valeur absolue ou en pourcentage. Les réponses faibles décrivent un tableau de bord sans le relier à un résultat concret. Exemple de structure : "L'analyse du churn d'un produit SaaS a révélé que les utilisateurs n'ayant pas terminé l'onboarding dans les 48 heures avaient un taux de churn 60 % plus élevé à 30 jours. L'équipe produit a ajouté une séquence d'e-mails automatisée déclenchée à la 24e heure, réduisant le churn à 30 jours de 8 points de pourcentage."

20. Comment gérer des demandes de données contradictoires de la part des parties prenantes

Cette question teste les compétences en priorisation et en communication. L'approche recommandée : clarifier la question business derrière chaque demande, identifier les indicateurs communs, proposer un tableau de bord unique répondant aux deux besoins, et documenter les compromis de manière transparente. Dire "non" à une partie prenante est acceptable lorsque cela est justifié par des préoccupations de gouvernance des données ou des contraintes de ressources, à condition de proposer une alternative.

21. Expliquer une analyse complexe à un public non technique

Les recruteurs demandent souvent aux candidats d'expliquer un concept comme la régression ou l'analyse de cohorte comme s'ils s'adressaient à un responsable marketing. Les meilleures réponses utilisent des analogies, évitent le jargon et ancrent l'explication dans un résultat business. "L'analyse de cohorte regroupe les clients par mois d'inscription et suit combien sont encore actifs trois mois plus tard. Le graphique montre que les inscrits de janvier ont mieux été retenus que ceux de février, ce qui correspond aux changements d'onboarding déployés fin décembre."

Questions sur le nettoyage de données et les pipelines ETL

Les problèmes de qualité des données consomment une part significative du temps d'un analyste. Ces questions testent les compétences concrètes en transformation de données.

22. Comment valider les données après l'exécution d'un pipeline ETL

Les vérifications de validation doivent couvrir le nombre de lignes (source vs. destination), les taux de nullité sur les colonnes critiques, l'intégrité référentielle entre les tables et les changements de distribution des valeurs (détection de modifications silencieuses de schéma). Des vérifications automatisées exécutées après chaque exécution du pipeline empêchent les données erronées d'atteindre les tableaux de bord.

# etl_validation.py
import pandas as pd

def validate_pipeline(source_df: pd.DataFrame, target_df: pd.DataFrame) -> dict:
    checks = {}
    # Row count match
    checks['row_count_match'] = len(source_df) == len(target_df)
    # Null rate on critical columns
    for col in ['user_id', 'event_date', 'amount']:
        null_rate = target_df[col].isnull().mean()
        checks[f'{col}_null_rate'] = round(null_rate, 4)
    # Revenue reconciliation
    source_total = source_df['amount'].sum()
    target_total = target_df['amount'].sum()
    checks['revenue_diff_pct'] = round(
        abs(source_total - target_total) / source_total * 100, 2
    )
    return checks

results = validate_pipeline(source, target)
for check, value in results.items():
    print(f'{check}: {value}')

Cette fonction renvoie un dictionnaire de résultats de validation pouvant alimenter un système d'alertes. Une différence de revenu supérieure à 0,01 % doit déclencher une investigation.

23. Quelle est la différence entre données normalisées et dénormalisées ?

Les données normalisées minimisent la redondance en répartissant l'information dans des tables liées (3NF). Les données dénormalisées combinent les tables en structures plus larges et plates, optimisées pour les requêtes analytiques à forte intensité de lecture. Les systèmes OLTP favorisent la normalisation pour l'intégrité des données. Les entrepôts de données et les outils BI favorisent la dénormalisation (schéma en étoile, schéma en flocon) pour la vitesse de requête. Comprendre ce compromis est fondamental pour concevoir des pipelines de données efficaces.

Questions d'analyse avancée

Les postes seniors exigent une familiarité avec l'expérimentation, la prévision et la stratégie data transversale.

24. Comment concevoir un test A/B de bout en bout

Un test A/B nécessite cinq composants : une hypothèse claire ("Changer la couleur du bouton CTA de gris à vert augmentera le taux de clic de 5 %"), une métrique principale (taux de clic), un calcul de taille d'échantillon basé sur la taille d'effet attendue et la puissance souhaitée (généralement 80 %), une répartition aléatoire des utilisateurs dans les groupes contrôle et traitement, et une durée de test prédéterminée tenant compte de la saisonnalité hebdomadaire. Exécuter le test pendant au moins deux cycles commerciaux complets évite que le biais du jour de la semaine ne fausse les résultats.

25. Expliquer l'analyse de tunnel et identifier les points de chute critiques

L'analyse de tunnel suit la progression des utilisateurs à travers une séquence d'étapes (par exemple : visite de la page d'accueil, consultation produit, ajout au panier, paiement, achat). L'optimisation à plus fort impact cible l'étape avec la plus grande chute absolue, et non la plus grande chute en pourcentage. Une chute de 40 % de 1 000 utilisateurs à la consultation produit à 600 à l'ajout au panier représente 400 utilisateurs perdus. Une chute de 50 % de 100 utilisateurs au paiement à 50 à l'achat ne représente que 50 utilisateurs perdus. Prioriser le premier goulot d'étranglement génère davantage de conversions totales. S'entraîner sur ce type d'analyse avec le module d'entretien sur l'analyse de tunnel.

26. Comment construire un tableau de bord KPI que les parties prenantes utilisent réellement

Les tableaux de bord échouent lorsqu'ils affichent trop d'indicateurs sans hiérarchie. Un tableau de bord KPI efficace suit la pyramide inversée : un ou deux indicateurs phares en haut (par exemple, revenu récurrent mensuel, Net Promoter Score), des indicateurs de soutien au milieu (taux de conversion, taux de churn, valeur moyenne des commandes), et des détails diagnostiques accessibles par exploration. Limiter la vue de premier niveau à sept indicateurs ou moins réduit la charge cognitive. Ajouter des annotations automatisées ("Le revenu a chuté de 12 % le 5 mars en raison d'une panne de la passerelle de paiement") fournit un contexte que les chiffres bruts ne peuvent pas offrir.

Sources

• Nouveautés de pandas 3.0.0 : Copy-on-Write par défaut, nouveau dtype string, API supprimées
• Guide de migration pour le nouveau type de données string : migration vers le backend string PyArrow
• Résumé des fonctionnalités Power BI août 2026 : modèles composites Direct Lake, mirroring BigQuery
• Présentation de Direct Lake : modes de stockage des modèles sémantiques Microsoft Fabric

Points clés pour les entretiens Data Analyst en 2026

• Les fonctions de fenêtrage SQL, les CTE et les requêtes de cohorte apparaissent dans pratiquement tous les tests techniques de data analyst. Les écrire de mémoire est une compétence de base attendue.
• Python Pandas 3.0 a introduit Copy-on-Write par défaut, ce qui casse l'assignation chaînée. Savoir utiliser .loc et les appels explicites à .copy() est essentiel.
• Les colonnes string dans pandas 3.0 utilisent le dtype str basé sur PyArrow, et non object. Vérifier les comparaisons de dtype dans le code.
• Le raisonnement statistique (p-values, corrélation vs causalité, conception d'expériences) distingue les analystes qui rapportent des chiffres de ceux qui les interprètent correctement.
• Power BI Direct Lake sur OneLake prend désormais en charge les modèles composites, combinant données quasi temps réel et performances d'importation.
• Les réponses comportementales suivant le framework STAR et incluant des résultats quantifiés surpassent les récits vagues.
• S'entraîner sur les modules d'entretien data analytics de SharpSkill : Fonctions de fenêtrage SQL, Rétention par cohorte, Analyse de tunnel.