SQL Pratique
Réussir son entretien SQL en data analyse
21 min de lecture

Réussir son entretien SQL en data analyse

Guide complet pour réussir votre entretien SQL data analyst : sujets incontournables, méthodologie, erreurs à éviter et plan de préparation sur 3 semaines.

Avatar de Thomas LeroyThomas Leroy

L'entretien SQL est devenu le passage obligé pour tout poste en data : data analyst, data engineer, data scientist, business analyst, product analyst. Les entreprises l'utilisent pour vérifier que vous savez réellement manipuler des données — pas seulement en théorie, mais face à un problème concret avec un chronomètre.

Ce guide complet, rédigé par Thomas Leroy, couvre tout ce que vous devez savoir pour arriver préparé et confiant : les sujets testés, la méthodologie à appliquer pendant l'épreuve, les erreurs fatales à éviter, et un plan de préparation sur 3 semaines.

📌 Ce qu'il faut retenir

  • L'entretien SQL se prépare comme un sport : la pratique régulière sur 50+ exercices fait la différence
  • La méthodologie (comprendre → planifier → coder → vérifier) est aussi importante que la technique SQL
  • Les sujets discriminants en 2026 : fonctions fenêtre, CTE et optimisation
  • Poser des questions de clarification est valorisé, pas pénalisé
  • 3 semaines de préparation régulière (30-45 min/jour) suffisent avec de bonnes bases

Les formats d'entretien SQL en 2026

Le test en ligne asynchrone

Format le plus courant en première étape. Vous recevez un lien vers une plateforme (HackerRank, Codility, StrataScratch, DataLemur) avec 3 à 5 exercices SQL à résoudre en 45-90 minutes.

Ce qu'il faut savoir :

  • Vous êtes seul, mais chronomé
  • Les tests vérifient la correction automatiquement (résultat exact)
  • Certaines plateformes mesurent aussi le temps par question
  • Vous ne pouvez généralement pas revenir en arrière

Le live coding avec un interviewer

Un recruteur ou un data lead vous donne un problème en direct. Vous partagez votre écran (ou écrivez sur un tableau blanc) et résolvez en expliquant votre raisonnement.

Ce qu'il faut savoir :

  • Le raisonnement compte autant que le résultat
  • On vous évalue sur votre méthode, pas uniquement sur la syntaxe
  • Poser des questions de clarification est attendu et valorisé
  • Le recruteur peut modifier l'énoncé en cours de route

Le case study data

On vous donne un jeu de données (schéma de plusieurs tables) et une question business. Vous devez écrire les requêtes SQL nécessaires pour y répondre.

Ce qu'il faut savoir :

  • Plus proche du travail réel
  • Plusieurs requêtes peuvent être nécessaires
  • On évalue votre compréhension métier autant que votre SQL

Le take-home test

Exercice à faire chez soi, en 24-48h, avec un jeu de données fourni. Souvent plus complexe et plus complet.

💡 Bon à savoir

Certaines entreprises combinent plusieurs formats : test en ligne pour présélectionner, puis live coding pour évaluer le raisonnement. Préparez-vous aux quatre formats pour maximiser vos chances.

Les 8 sujets SQL testés en entretien

Niveau 1 : Les fondamentaux (toujours testés)

1. SELECT, WHERE, ORDER BY, LIMIT

Ce sont les bases. Vous ne les verrez pas comme questions isolées, mais chaque requête les utilise. Les recruteurs vérifient :

  • Filtres sur dates, textes, NULL
  • Opérateurs : BETWEEN, IN, LIKE, IS NULL
  • Tri multi-colonnes

2. JOINs (INNER, LEFT, RIGHT, FULL)

Le sujet le plus testé, tous niveaux confondus. Les recruteurs vérifient :

  • Savez-vous quand utiliser INNER vs LEFT ?
  • Comprenez-vous le comportement avec les NULL ?
  • Pouvez-vous joindre 3+ tables ?
  • Connaissez-vous l'anti-join (LEFT JOIN + WHERE IS NULL) ?

Pour une préparation complète, consultez notre guide complet des JOINs SQL.

3. GROUP BY et HAVING

Le deuxième sujet le plus fréquent. Les recruteurs vérifient :

  • Différence entre WHERE et HAVING
  • COUNT(*) vs COUNT(col) vs COUNT(DISTINCT col)
  • GROUP BY avec plusieurs colonnes
  • Combinaison avec CASE WHEN pour les pivots

Consultez notre guide GROUP BY et HAVING pour maîtriser ces concepts.

Niveau 2 : Intermédiaire (fréquemment testé)

4. Sous-requêtes et EXISTS

Les recruteurs testent :

  • Sous-requêtes dans WHERE, FROM et SELECT
  • Sous-requêtes corrélées vs non corrélées
  • EXISTS vs IN (et le piège NOT IN avec NULL)

Approfondissez avec notre ressource sur les sous-requêtes SQL.

5. CASE WHEN

Utilisé dans presque toutes les requêtes complexes :

  • Catégorisation de données
  • Pivots (lignes → colonnes)
  • Agrégation conditionnelle

Maîtrisez cette technique avec notre guide CASE WHEN SQL.

6. CTE (Common Table Expressions)

Devenues un standard en SQL moderne :

  • Structurer des requêtes complexes
  • CTE récursives pour les hiérarchies
  • Réutilisation dans la même requête

Approfondir avec notre guide complet sur les CTE SQL.

Niveau 3 : Avancé (discriminant)

7. Fonctions fenêtre (Window Functions)

Le sujet qui fait la différence entre un candidat moyen et un bon candidat :

  • ROW_NUMBER, RANK, DENSE_RANK
  • LAG, LEAD
  • SUM/AVG/COUNT OVER (PARTITION BY ...)
  • Cumuls et moyennes mobiles

Les fonctions fenêtre sont le critère #1 pour différencier les bons candidats. Leur maîtrise est quasi indispensable pour les postes intermédiaires et seniors. Consultez notre guide complet des fonctions fenêtre et nos exercices pratiques.

8. Optimisation et performance

De plus en plus testé, même pour les data analysts :

  • Comprendre un plan d'exécution (EXPLAIN)
  • Quand et comment créer un index
  • Pourquoi éviter SELECT *
  • Importance de la cardinalité et des filtres sélectifs

Découvrez les 10 techniques d'optimisation SQL.

La méthodologie en entretien : 5 étapes clés

Étape 1 : Comprendre le problème (2-3 minutes)

Avant d'écrire la moindre ligne de SQL :

  1. Lisez l'énoncé complètement — ne commencez pas à coder après la première phrase
  2. Identifiez les tables et colonnes disponibles
  3. Posez des questions de clarification :
    • « Les valeurs NULL sont-elles possibles dans cette colonne ? »
    • « Faut-il inclure les enregistrements supprimés ? »
    • « Par date, on entend la date de création ou de modification ? »
    • « S'il y a des ex æquo, on les inclut tous ou un seul ? »

Les recruteurs valorisent énormément les questions de clarification. Elles montrent que vous réfléchissez au problème avant de coder.

Exemple concret : Sarah, data analyst chez Leboncoin, raconte : "En entretien chez BlaBlaCar, j'ai posé 3 questions de clarification avant de commencer à coder. Le recruteur m'a dit après coup que c'était exactement ce qu'il attendait — dans le vrai travail, on ne code jamais sans clarifier les ambiguïtés métier."

Étape 2 : Planifier l'approche (1-2 minutes)

Verbalisez votre plan avant de coder :

« Je vais d'abord filtrer les commandes de 2026, puis les joindre avec la table clients, grouper par client et filtrer ceux dont le total dépasse 1000 € avec HAVING. »

Cela montre votre capacité à structurer votre pensée et permet au recruteur de vous corriger si vous partez dans la mauvaise direction.

Étape 3 : Écrire la requête (5-15 minutes)

Bonnes pratiques pendant l'écriture :

  • Commencez simple, puis complexifiez progressivement
  • Testez mentalement avec des données d'exemple
  • Indentez proprement — la lisibilité compte
  • Utilisez des alias courts mais compréhensibles
  • Commentez si nécessaire : -- anti-join pour trouver les clients sans commande

Étape 4 : Vérifier le résultat (2-3 minutes)

Avant de dire « j'ai fini » :

  1. Relisez la requête et vérifiez la logique
  2. Vérifiez les cas limites : NULL, duplicats, données vides
  3. Posez-vous la question : « Si je passe mes données d'exemple, est-ce que j'obtiens le résultat attendu ? »

Étape 5 : Discuter des alternatives (2-3 minutes)

Même si votre solution est correcte, le recruteur peut demander :

  • « Peut-on faire autrement ? »
  • « Comment cette requête se comporterait sur 10 millions de lignes ? »
  • « Quel index ajouteriez-vous ? »

Avoir en tête les alternatives (CTE vs sous-requête, EXISTS vs IN, window function vs self-join) est un atout majeur.

Les erreurs fatales en entretien SQL (et comment les éviter)

Les 4 erreurs les plus coûteuses

⚠️ Attention

Ces erreurs peuvent ruiner un entretien même avec un bon niveau technique :

1. Confondre WHERE et HAVING

  • L'erreur : Écrire WHERE SUM(montant) > 500 au lieu de HAVING SUM(montant) > 500
  • Pourquoi c'est grave : Provoque une erreur SQL directe
  • Comment éviter : WHERE filtre les lignes avant GROUP BY, HAVING filtre les groupes après

2. Le piège NOT IN avec NULL

  • L'erreur : WHERE client_id NOT IN (SELECT client_id FROM blacklist) quand blacklist contient des NULL
  • Pourquoi c'est grave : Retourne 0 lignes au lieu du résultat attendu
  • Comment éviter : Utilisez NOT EXISTS ou WHERE client_id NOT IN (SELECT client_id FROM blacklist WHERE client_id IS NOT NULL)

3. Foncer sans lire l'énoncé complètement

  • L'erreur : Commencer à coder après avoir lu la première phrase
  • Pourquoi c'est grave : Résoudre le mauvais problème avec une requête parfaite = 0 point
  • Comment éviter : Lisez tout, identifiez les mots-clés (derniers 30 jours, actifs, uniques...)

4. Ne pas tester mentalement la requête

  • L'erreur : Dire "j'ai fini" sans vérifier les cas limites
  • Pourquoi c'est grave : Montre un manque de rigueur professionnel
  • Comment éviter : Passez mentalement 2-3 lignes d'exemple dans votre requête

Les 6 erreurs techniques classiques

5. SELECT * en entretien En entretien, cela envoie le signal que vous ne savez pas ce que vous cherchez. Listez toujours les colonnes explicitement.

6. Code illisible Pas d'indentation, pas d'alias, pas de structure. Le recruteur doit pouvoir lire votre requête sans effort.

7. Ignorer les fonctions fenêtre En 2026, les window functions ne sont plus « avancées » — elles sont attendues pour tout poste data de niveau intermédiaire ou plus.

8. CROSS JOIN accidentel Oublier une condition de jointure sur de grandes tables montre un manque de conscience des implications de performance.

9. Ne pas poser de questions Le silence est mal interprété. Posez des questions, verbalisez votre raisonnement, demandez des clarifications.

10. Paniquer sur la syntaxe Un oubli de virgule ou une parenthèse mal placée ne sont pas éliminatoires. Le recruteur évalue votre logique, pas votre capacité à écrire du SQL sans erreur de syntaxe.

Spécificités par type de poste et secteur d'activité

Data Analyst Junior (0-2 ans)

Attendus techniques :

  • JOINs, GROUP BY, sous-requêtes simples
  • ROW_NUMBER pour déduplication
  • CASE WHEN pour catégorisation
  • Notions de performance (éviter SELECT *)

Questions business typiques :

  • Calculer un taux de conversion
  • Identifier les clients les plus actifs
  • Analyser l'évolution mensuelle des ventes

Exemple d'exercice : "Trouvez les 10 produits les plus vendus par catégorie en 2026, avec leur chiffre d'affaires total."

Data Analyst Senior (2+ ans)

Attendus techniques :

  • Toutes les window functions (ROW_NUMBER, RANK, LAG/LEAD, cumuls)
  • CTE complexes, CTE récursives
  • Optimisation (EXPLAIN, index)
  • Requêtes multi-étapes structurées

Questions business typiques :

  • Analyse de cohortes
  • Funnel d'acquisition
  • Détection d'anomalies
  • Calculs de rétention

Consultez notre article sur la préparation à l'entretien data analyst pour une approche globale.

Business Analyst

Attendus techniques :

  • Niveau intermédiaire en SQL
  • Focus sur la compréhension métier
  • Capacité à traduire une question business en SQL

Questions business typiques :

  • KPI et métriques métier
  • Segmentation client
  • Analyse de performance commerciale

Data Engineer / Data Scientist

Attendus techniques :

  • SQL avancé + optimisation poussée
  • Requêtes sur très gros volumes
  • Connaissance des spécificités par moteur SQL (PostgreSQL, BigQuery, Snowflake)

Questions spécifiques :

  • Partitioning et sharding
  • Requêtes distribuées
  • ETL et transformations complexes

Erreurs fréquentes par secteur d'activité

E-commerce

  • Piège : Oublier les retours/remboursements dans le CA
  • Piège : Ne pas distinguer commandes et articles dans les analyses
  • À maîtriser : Funnel d'achat, panier moyen, récurrence

Exemple concret : Marco, développeur brésilien chez Rappi, explique : "En entretien chez Zalando, j'ai calculé le CA sans retirer les remboursements. Le recruteur m'a immédiatement demandé de corriger — c'était un test pour voir si je pensais aux cas réels métier."

Fintech / Banque

  • Piège : Transactions en double (autorisation + débit)
  • Piège : Ne pas gérer les fuseaux horaires
  • À maîtriser : Soldes cumulés, détection de fraude, compliance

SaaS / Tech

  • Piège : Confondre utilisateur créé et utilisateur actif
  • Piège : Metrics de croissance mal définies (WAU, MAU, DAU)
  • À maîtriser : Rétention, churn, analyse de cohortes, funnels

Explorez nos exercices d'analyse SQL pour maîtriser ces cas.

Média / Contenu

  • Piège : Sessions vs pages vues vs utilisateurs uniques
  • Piège : Attribution multi-touch
  • À maîtriser : Engagement, temps de session, analyse de contenu

Erreurs typiques selon le profil du candidat

Candidats autodidactes

  • Force : Créativité dans l'approche, solutions non-conventionnelles
  • Piège fréquent : Lacunes sur les bonnes pratiques (performance, lisibilité)
  • Conseil : Insistez sur la structure et les conventions SQL standard

Candidats formation école

  • Force : Bases théoriques solides, méthodologie rigoureuse
  • Piège fréquent : Complexification inutile, manque de pragmatisme
  • Conseil : Privilégiez la simplicité et l'efficacité, testez sur des données réelles

Candidats reconversion

  • Force : Expérience métier précieuse, vision business
  • Piège fréquent : Manque de fluidité technique, syntaxe approximative
  • Conseil : Compensez par votre compréhension métier, verbalisez votre logique

Plan de préparation sur 3 semaines (détaillé)

Semaine 1 : Les fondamentaux (30 min/jour)

Jour Sujet Objectif
Lun SELECT, WHERE, ORDER BY Rappels de base, filtres complexes
Mar JOINs : INNER et LEFT Exercices de jointure avec anti-join
Mer JOINs : SELF JOIN, multi-tables Hiérarchies, 3+ tables
Jeu GROUP BY + fonctions d'agrégation COUNT, SUM, AVG, GROUP BY multi-colonnes
Ven HAVING + WHERE Différence WHERE/HAVING, exercices combinés
Sam Sous-requêtes simples IN, sous-requêtes dans WHERE
Dim Révision + 5 exercices mixtes Consolider les acquis

Exercices recommandés par jour : 5 exercices de difficulté croissante Temps par exercice : 5-6 minutes maximum Focus : Corriger immédiatement les erreurs, comprendre les solutions alternatives

Semaine 2 : Intermédiaire (45 min/jour)

Jour Sujet Objectif
Lun CASE WHEN Catégorisation, pivots
Mar Sous-requêtes corrélées EXISTS, NOT EXISTS
Mer CTE simples WITH, CTE multiples
Jeu CTE récursives Hiérarchies, séquences
Ven Window functions : ROW_NUMBER, RANK Classement, déduplication
Sam Window functions : LAG, LEAD, SUM OVER Cumuls, comparaisons temporelles
Dim 10 exercices d'entretien Simulation conditions réelles

Nouveauté : Chronométrez-vous à partir du mercredi (8 minutes max par exercice) Focus : Maîtriser les window functions — c'est le critère discriminant #1

Semaine 3 : Avancé et simulation (45 min/jour)

Jour Sujet Objectif
Lun Window functions avancées NTILE, moyennes mobiles, ROWS BETWEEN
Mar Optimisation EXPLAIN, index, performance
Mer Exercices business Funnel, rétention, cohortes
Jeu Simulation complète (60 min) 5 exercices chronométrés
Ven Revue des erreurs Analyser et corriger
Sam Simulation complète (60 min) 5 exercices différents chronométrés
Dim Relecture des notes Points clés à réviser

Crucial : Les simulations du jeudi et samedi doivent reproduire les conditions réelles d'entretien Objectif : Être à l'aise sur tous les sujets, avoir corrigé ses erreurs résiduelles

Validation post-préparation : checklist OFII

💡 Bon à savoir

Cette checklist vous permet de valider votre niveau avant l'entretien. Si vous cochez moins de 8/12 points, prolongez votre préparation d'une semaine.

Techniques SQL (8 points) :

Méthodologie (4 points) :

Tableau récapitulatif des techniques par niveau de difficulté

Niveau Techniques SQL Temps préparation Exemples d'usage
Débutant SELECT, WHERE, JOINs, GROUP BY 7 jours Rapports simples, KPI basiques
Intermédiaire Sous-requêtes, CASE WHEN, CTE, ROW_NUMBER 7 jours Classements, pivots, déduplication
Avancé Window functions, CTE récursives, optimisation 7 jours Analyses temporelles, hiérarchies, performance
Expert Requêtes distribuées, partitioning, ETL Continu Big Data, optimisation avancée

Exercices types par difficulté avec corrections

Niveau Débutant : Fondamentaux

Exercice 1 - JOINs et agrégation

Soit une base e-commerce avec les tables commandes(id, client_id, montant, date_commande) et clients(id, nom, email, date_inscription). Trouvez le nombre total de commandes et le montant total pour chaque client inscrit en 2026, classés par montant décroissant.

Solution type :

SELECT 
    c.nom,
    COUNT(co.id) as nb_commandes,
    COALESCE(SUM(co.montant), 0) as montant_total
FROM clients c
LEFT JOIN commandes co ON c.id = co.client_id
WHERE c.date_inscription >= '2026-01-01' 
    AND c.date_inscription < '2027-01-01'
GROUP BY c.id, c.nom
ORDER BY montant_total DESC;

**Points clés** : LEFT JOIN pour inclure clients sans commandes, COALESCE pour gérer NULL, filtre sur année avec inégalités.

### Niveau Intermédiaire : Window Functions et CTE

**Exercice 2 - Classement et comparaisons temporelles**
> Avec la même base, affichez pour chaque client inscrit en 2026 : son nom, sa date d'inscription, le montant de sa dernière commande et le montant de sa meilleure commande. Classez par date d'inscription décroissante.

**Solution type** :
```sql
WITH client_stats AS (
    SELECT 
        c.id,
        c.nom,
        c.date_inscription,
        co.montant,
        ROW_NUMBER() OVER (PARTITION BY c.id ORDER BY co.date_commande DESC) as rn_recent,
        ROW_NUMBER() OVER (PARTITION BY c.id ORDER BY co.montant DESC) as rn_max
    FROM clients c
    LEFT JOIN commandes co ON c.id = co.client_id
    WHERE c.date_inscription >= '2026-01-01' 
        AND c.date_inscription < '2027-01-01'
)
SELECT 
    nom,
    date_inscription,
    MAX(CASE WHEN rn_recent = 1 THEN montant END) as derniere_commande,
    MAX(CASE WHEN rn_max = 1 THEN montant END) as meilleure_commande
FROM client_stats
GROUP BY id, nom, date_inscription
ORDER BY date_inscription DESC;
**Points clés** : Utilisation de CTE pour structure, ROW_NUMBER avec PARTITION BY, CASE WHEN pour extraire valeurs spécifiques.

### Niveau Avancé : Analyse complexe

**Exercice 3 - Analyse de rétention**
> Calculez le taux de rétention mensuel pour les clients inscrits en janvier 2026. Définissez la rétention comme "client ayant au moins une commande ce mois-ci ET le mois suivant".

**Solution type** :
```sql
WITH monthly_active AS (
    SELECT 
        c.id,
        DATE_TRUNC('month', c.date_inscription) as cohort_month,
        DATE_TRUNC('month', co.date_commande) as activity_month,
        ROW_NUMBER() OVER (PARTITION BY c.id, DATE_TRUNC('month', co.date_commande) 
                           ORDER BY co.date_commande) as activity_flag
    FROM clients c
    JOIN commandes co ON c.id = co.client_id
    WHERE DATE_TRUNC('month', c.date_inscription) = '2026-01-01'
),
cohort_months AS (
    SELECT DISTINCT
        cohort_month,
        activity_month,
        COUNT(DISTINCT id) as active_users
    FROM monthly_active
    WHERE activity_flag = 1
    GROUP BY cohort_month, activity_month
)
SELECT 
    cohort_month,
    activity_month,
    active_users,
    ROUND(100.0 * active_users / LAG(active_users) OVER (ORDER BY activity_month), 2) as retention_rate
FROM cohort_months
ORDER BY activity_month;

Points clés : Gestion des dates, CTE multiples, LAG pour comparaison temporelle, ROUND pour formatage.

Ressources et exercices pratiques

📌 Plateforme recommandées

Pour débuter : LeetCode SQL, Mode Analytics Pour s'entraîner : HackerRank, StrataScratch, DataLemur Pour les cas réels : Exercices SQL window functions, Analyses de funnel

Nombre d'exercices à résoudre : Minimum 50 exercices variés pour être suffisamment à l'aise.

Questions fréquentes

Combien de temps dois-je préparer un entretien SQL ?

3 à 4 semaines avec 30-45 minutes quotidiennes suffisent si vous avez des bases solides. Si vous partez de zéro ou d'un niveau très basique, comptez 6-8 semaines. L'essentiel est la régularité plutôt que les sessions longues : 30 min chaque jour > 5h le weekend.

Quel moteur SQL dois-je maîtriser : PostgreSQL, MySQL, SQL Server ?

Les concepts fondamentaux sont identiques partout. Cependant, maîtrisez le dialecte de l'entreprise que vous ciblez. PostgreSQL est incontournable pour les startups tech, BigQuery pour les entreprises cloud-first, SQL Server pour les grandes organisations. En entretien, mentionnez les différences de syntaxe si vous testez sur un dialect différent.

Les window functions sont-elles vraiment indispensables ?

Oui, absolument. En 2026, ne pas connaître les window functions envoie un signal "junior" ou "basique". Pour tout poste intermédiaire+, c'est un attendu. ROW_NUMBER, RANK et SUM OVER sont les trois incontournables. Renforcez votre maîtrise avec notre guide complet des fonctions fenêtre.

Comment gérer le stress en live coding ?

Pratiquez avec un minuteur, parlez à voix haute en résolvant les exercices (reproduisez le cadre d'un entretien réel), posez des questions même en entraînement. L'habitude réduit l'anxiété. Prenez une seconde avant de coder, respirez, identifiez le problème calmement.

Vaut-il mieux maîtriser peu de choses ou connaître beaucoup de sujets superficiellement ?

Profondeur > largeur. Maîtriser complètement JOINs, GROUP BY, window functions et optimisation vaut mieux que connaître 15 sujets sans expertise. En cas de doute, un recruteur pose des questions approfondies pour tester votre compréhension réelle.

Qu'est-ce qui différencie un candidat "bon" d'un candidat "excellent" en entretien SQL ?

Un bon candidat résout les problèmes correctement. Un excellent candidat pose des questions de clarification, verbalize sa pensée, propose plusieurs solutions, discute des trade-offs de performance et reste calme face à un problème inattendu. C'est à 40% technique, 60% méthodologie et communication.

Comment bien se préparer si je manque de temps avant l'entretien ?

Concentrez-vous sur les sujets les plus testés : JOINs (25%), GROUP BY (15%), Window Functions (15%), Sous-requêtes (12%), CASE WHEN (10%), CTE (8%) et autres (15%). Maîtrisez les 70% qui constituent l'essentiel plutôt que de survoler tout.

Découvrez aussi notre guide 20 questions SQL en entretien pour vous préparer aux incontournables et notre article SQL et ChatGPT pour l'entretien si vous utilisez l'IA dans votre préparation.

Un entretien réussi commence par un CV qui passe le filtre ATS. Avant de vous concentrer sur le SQL, assurez-vous que votre candidature n'est pas éliminée avant lecture — guide erreurs CV à éviter pour les profils data et tech.

Prêt à vous entraîner ?

50 exercices SQL interactifs avec éditeur en ligne, chronomètre et feedback IA.

Voir les exercices