Top 25 Data Science Sollicitatievragen in 2026 (met Antwoorden)

Data science-functies behoren tot de meest competitieve technische posities van dit moment. Recruiters en hiring managers toetsen niet alleen algoritmische kennis, maar ook statistisch inzicht, praktische Python-vaardigheden en het vermogen om technische bevindingen helder te communiceren aan niet-technische stakeholders. Dit overzicht bundelt de 25 meest gestelde data science sollicitatievragen van 2026, gebaseerd op ervaringen van kandidaten bij toonaangevende tech-bedrijven, fintechs en datageoriënteerde scale-ups.

Kansrekening en Statistiek — de Basis (V1–V3)

V1. Wat is een p-waarde en hoe interpreteer je die correct?

Een p-waarde geeft de kans aan dat de geobserveerde data (of extremere uitkomsten) zouden optreden als de nulhypothese waar is. Een veelgemaakte fout is de p-waarde te interpreteren als de kans dat de nulhypothese klopt — dat is fundamenteel onjuist. Een p-waarde van 0,03 betekent: als H₀ waar is, zou dit resultaat in slechts 3% van de steekproeven optreden. Het zegt niets over de praktische relevantie van het effect.

Interviewers verwachten dat kandidaten het verschil kennen tussen statistische significantie en praktische relevantie (effectgrootte), weten wat het meervoudig-testen-probleem is, en Bonferroni-correctie of FDR kunnen toelichten.

# binomial_test.py
from scipy import stats

# Two-sided binomial test: is the coin fair?
result = stats.binomtest(k=8, n=10, p=0.5, alternative='two-sided')
print(f"p-value: {result.pvalue:.4f}")  # 0.1094 (two-sided)
print(f"Reject H0 at alpha=0.05? {result.pvalue < 0.05}")  # False

V2. Leg het verschil uit tussen Bayesiaanse en frequentistische statistiek.

Frequentisten beschouwen parameters als vaste, onbekende constanten en schatten ze op basis van de data. Bayesianen behandelen parameters als kansverdelingen en werken ze bij zodra nieuwe data beschikbaar komt via de stelling van Bayes: P(θ|data) ∝ P(data|θ) × P(θ). In de praktijk levert een Bayesiaanse aanpak geloofwaardigheidsintervallen (credible intervals) op die intuïtiever te interpreteren zijn dan frequentistische betrouwbaarheidsintervallen.

# bayesian_vs_frequentist.py
import numpy as np
from scipy import stats

# Frequentist: confidence interval for a mean
data = np.array([23.1, 25.4, 22.8, 24.9, 23.7, 25.1, 24.3])
ci = stats.t.interval(0.95, df=len(data)-1, loc=np.mean(data), scale=stats.sem(data))
print(f"95% CI (frequentist): [{ci[0]:.2f}, {ci[1]:.2f}]")

# Bayesian: posterior with conjugate prior (Normal-Normal)
prior_mean, prior_var = 24.0, 4.0  # prior belief
data_mean, data_var = np.mean(data), np.var(data, ddof=1) / len(data)
# Posterior parameters (conjugate update)
post_var = 1 / (1/prior_var + 1/data_var)
post_mean = post_var * (prior_mean/prior_var + data_mean/data_var)
post_ci = stats.norm.interval(0.95, loc=post_mean, scale=np.sqrt(post_var))
print(f"95% credible interval (Bayesian): [{post_ci[0]:.2f}, {post_ci[1]:.2f}]")

V3. Beschrijf de aannames van lineaire regressie.

Lineaire regressie steunt op vijf centrale aannames: (1) lineariteit van de relatie tussen predictoren en uitkomst, (2) onafhankelijkheid van residuen, (3) homoscedasticiteit (gelijkmatige variantie van residuen), (4) normaliteit van residuen, en (5) geen perfecte multicollineariteit. Schendingen van deze aannames vereisen verschillende remedies: transformaties, robuuste standaardfouten, of de overstap naar gegeneraliseerde lineaire modellen.

Feature Engineering en Datavoorbereiding (V4–V5)

V4. Welke strategieën bestaan er voor het omgaan met ontbrekende waarden?

Ontbrekende waarden kennen drie mechanismen: MCAR (Missing Completely At Random), MAR (Missing At Random) en MNAR (Missing Not At Random). Het mechanisme bepaalt de juiste strategie. Simpele imputatie met gemiddelde of mediaan kan de variantie onderschatten en correlaties vertekenen. Geavanceerdere methoden zijn KNN-imputatie (behoudt lokale structuur), iteratieve imputatie (MICE-aanpak) en het toevoegen van een binaire indicator voor de ontbrekendheidspatronen.

# missing_data_strategies.py
import pandas as pd
from sklearn.impute import KNNImputer, SimpleImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'age': [25, 30, None, 45, None, 38],
    'income': [50000, None, 70000, 90000, 60000, None],
    'score': [85, 90, 78, None, 88, 92]
})

# Strategy 1: KNN imputation (preserves local structure)
knn_imp = KNNImputer(n_neighbors=2)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Strategy 2: Iterative imputation (MICE-like, models each feature)
iter_imp = IterativeImputer(max_iter=10, random_state=42)
df_iter = pd.DataFrame(iter_imp.fit_transform(df), columns=df.columns)

# Strategy 3: Add missingness indicator (preserves signal in the pattern)
df['income_missing'] = df['income'].isna().astype(int)
print(df_knn.round(1))

V5. Hoe werkt target encoding en hoe voorkom je data-leakage?

Target encoding vervangt categorische waarden door het gemiddelde van de doelvariabele per categorie. Het risico is echter aanzienlijk: zonder voorzorgsmaatregelen lekt informatie uit de validatieset naar het model, wat leidt tot overfitting. De oplossing is K-fold target encoding, waarbij het gemiddelde per categorie uitsluitend wordt berekend op de trainingsdata van elke fold.

# target_encoding.py
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    """Target encoding with K-fold regularization to prevent leakage."""
    encoded = pd.Series(index=df.index, dtype=float)
    global_mean = df[target].mean()
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # Compute means only from training fold
        means = df.iloc[train_idx].groupby(col)[target].mean()
        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(means)

    # Fill categories unseen in training fold with global mean
    encoded.fillna(global_mean, inplace=True)
    return encoded

df = pd.DataFrame({
    'city': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon', 'Paris',
             'Marseille', 'Lyon', 'Paris', 'Marseille'],
    'hired': [1, 0, 1, 0, 1, 1, 0, 0, 1, 1]
})
df['city_encoded'] = target_encode_kfold(df, 'city', 'hired')
print(df[['city', 'city_encoded', 'hired']])

Kernconcepten van Machine Learning (V6–V9)

V6. Wat is het bias-variantie-dilemma?

Hoge bias wijst op underfitting: het model mist de onderliggende structuur in de data. Hoge variantie wijst op overfitting: het model heeft de trainingsdata te nauwkeurig onthouden en generaliseert slecht. De truc is het zoeken naar de juiste balans. Ensemblemethoden benaderen dit probleem vanuit twee kanten: bagging (zoals Random Forest) verlaagt variantie door middeling van meerdere modellen; boosting (zoals XGBoost of LightGBM) verlaagt bias door opeenvolgende correctie van fouten.

V7. Leg het gradient descent-algoritme uit, inclusief varianten.

Gradient descent minimaliseert een kostfunctie door parameters stapsgewijs aan te passen in de richting van de negatieve gradiënt. Batch gradient descent berekent de gradiënt over alle trainingsdata per stap — stabiel maar traag bij grote datasets. Stochastic gradient descent (SGD) gebruikt één voorbeeld per stap — snel maar ruisachtig. Mini-batch gradient descent combineert beide en is in de praktijk de standaard. Adaptieve optimizers zoals Adam en AdaGrad passen de leersnelheid per parameter aan, wat convergentie versnelt.

V8. Wat is het verschil tussen L1- en L2-regularisatie?

L1-regularisatie (Lasso) voegt de som van absolute parameterwaarden toe aan de kostfunctie en moedigt sparse oplossingen aan: niet-relevante features krijgen een coëfficiënt van precies nul. L1 is dus bruikbaar voor automatische featureselectie. L2-regularisatie (Ridge) bestraft de som van kwadraten van parameters en verdeelt de invloed gelijkmatig over gecorreleerde features zonder ze volledig te elimineren. Elastic Net combineert beide termen en biedt zo meer flexibiliteit.

V9. Hoe werkt een Random Forest en waarom generaliseert het goed?

Een Random Forest traint meerdere beslissingsbomen op bootstrap-steekproeven van de trainingsdata (bagging). Bij elke splitsing wordt een willekeurige deelverzameling van features geselecteerd, wat de correlatie tussen bomen verlaagt. De voorspelling is het gemiddelde (regressie) of de meerderheidsstem (classificatie) van alle bomen. Door decorrelatie en middeling daalt de variantie significant, terwijl de bias beperkt toeneemt — wat leidt tot robuuste generalisatie.

Modelevaluatie en Validatie (V10–V11)

V10. Welke metrics gebruik je bij sterk ongebalanceerde datasets?

Bij ongebalanceerde datasets geeft de ROC AUC-score een algemeen beeld, maar de AUPRC verdient de voorkeur omdat die gevoeliger is voor de prestaties op de minderheidsklasse. Op operationeel niveau sturen de zakelijke kosten de keuze: een hoge recall is cruciaal bij fraudedetectie (weinig valse negatieven), terwijl hoge precisie prioriteit heeft bij spam-filtering (weinig valse positieven).

# imbalanced_metrics.py
from sklearn.metrics import (
    classification_report, precision_recall_curve,
    average_precision_score, roc_auc_score
)
import numpy as np

# Simulated predictions on imbalanced data
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 95/5 imbalance
y_scores = np.random.beta(2, 5, 1000)  # predicted probabilities
y_scores[y_true == 1] += 0.3  # positive class scores slightly higher
y_scores = np.clip(y_scores, 0, 1)
y_pred = (y_scores > 0.5).astype(int)

print(classification_report(y_true, y_pred, digits=3))
print(f"ROC AUC: {roc_auc_score(y_true, y_scores):.3f}")
print(f"Average Precision (AUPRC): {average_precision_score(y_true, y_scores):.3f}")

V11. Wat is data-leakage en hoe wordt het voorkomen?

Data-leakage treedt op wanneer informatie uit de validatie- of testset het trainingsproces binnendringt, wat leidt tot overdreven optimistische prestatiemetingen in productie. Typische vormen zijn: standaardisatie op de gehele dataset voor cross-validatie, het opnemen van toekomstige variabelen die in productie niet beschikbaar zijn, en imputatie op basis van statistieken berekend over de volledige dataset. De correcte oplossing is het gebruik van Scikit-learn Pipelines, die preprocessing strikt binnen de trainingsfold uitvoeren.

# leakage_prevention.py
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# WRONG: fit scaler on all data, then cross-validate
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # leakage: test fold info in scaling

# CORRECT: pipeline ensures preprocessing fits only on training folds
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC (no leakage): {scores.mean():.3f} +/- {scores.std():.3f}")

Deep Learning en Neurale Netwerken (V12–V14)

V12. Hoe werkt backpropagation?

Backpropagation berekent de gradiënt van de verliesfunctie ten opzichte van alle gewichten in het netwerk via de kettingregel van de differentiaalrekening. Eerst wordt een voorwaartse stap uitgevoerd om de activaties en het verlies te berekenen. Vervolgens wordt de gradiënt terugwaarts door het netwerk gepropageerd: elke laag ontvangt de gradiënt van de bovenliggende laag en berekent de lokale gradiënten voor zijn eigen gewichten. Gradient descent werkt de gewichten dan bij op basis van deze gradiënten.

V13. Wat is het verdwijnende gradiënt-probleem en hoe wordt het aangepakt?

Bij diepe netwerken worden gradiënten vermenigvuldigd tijdens backpropagation. Bij activatiefuncties zoals sigmoid of tanh liggen deze vermenigvuldigers in (0, 1), wat bij veel lagen leidt tot exponentieel kleine gradiënten in de vroege lagen — het netwerk leert daardoor nauwelijks. Oplossingen zijn: ReLU-activatiefuncties (gradiënt = 1 voor positieve invoer), residual connections (skip connections in ResNets), batch normalization, en zorgvuldige gewichtsinitialisatie (He- of Xavier-initialisatie).

V14. Leg het zelf-aandacht-mechanisme (self-attention) in Transformers uit.

Zelf-aandacht stelt elk token in een reeks in staat om alle andere tokens te raadplegen bij het berekenen van zijn representatie. Voor elke positie worden query (Q), sleutel (K) en waarde (V) vectoren berekend via lineaire projecties. De aandachtsgewichten worden bepaald door het scalaire product van Q en K te delen door de vierkantswortel van de dimensie — dit voorkomt te grote gradiënten. Softmax normaliseert de gewichten, waarna een gewogen som van V de uitvoer vormt.

# self_attention.py
import torch
import torch.nn.functional as F

def self_attention(x, d_k):
    """Scaled dot-product self-attention from scratch."""
    # x shape: (batch_size, seq_len, d_model)
    batch_size, seq_len, d_model = x.shape

    # Linear projections for Q, K, V
    W_q = torch.randn(d_model, d_k) * 0.1
    W_k = torch.randn(d_model, d_k) * 0.1
    W_v = torch.randn(d_model, d_k) * 0.1

    Q = x @ W_q  # (batch, seq_len, d_k)
    K = x @ W_k
    V = x @ W_v

    # Scaled dot-product attention
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)  # (batch, seq_len, seq_len)
    weights = F.softmax(scores, dim=-1)  # attention weights
    output = weights @ V  # (batch, seq_len, d_k)

    return output, weights

# Example: 1 batch, 4 tokens, 8-dim embeddings
x = torch.randn(1, 4, 8)
out, attn = self_attention(x, d_k=8)
print(f"Output shape: {out.shape}")    # (1, 4, 8)
print(f"Attention weights:\n{attn[0].detach().numpy().round(3)}")

SQL en Datamanipulatie (V15–V16)

V15. Schrijf een query om het op-één-na-hoogste salaris per afdeling op te halen.

Dit is een klassieke SQL-vraag die interviewers gebruiken om te toetsen of een kandidaat venstering (window functions) kent en gecorreleerde subquery's begrijpt. Hieronder de aanpak met een gecorreleerde subquery die telt hoeveel unieke salarissen hoger liggen dan het huidige.

-- second_highest_salary.sql
-- Approach: correlated subquery counting distinct higher salaries
SELECT d.department_name, e.employee_name, e.salary
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
      AND e2.salary > e.salary
) = 1
ORDER BY d.department_name;

V16. Wat is het verschil tussen GROUP BY en PARTITION BY?

GROUP BY comprimeert de resultaatset tot één rij per groep en wordt gebruikt met aggregatiefuncties in combinatie met SELECT. PARTITION BY is een clausule van vensterfuncties (OVER) en behoudt alle rijen, waarbij de aggregatie of rangschikking per partitie wordt berekend zonder de resultaatset te reduceren. Gebruik PARTITION BY wanneer het originele rijdetail behouden moet blijven naast de geaggregeerde waarde.

Toegepaste Data Science en Systeemontwerp (V17–V20)

V17. Hoe ontwerp je een aanbevelingssysteem voor een e-commerce platform?

Een aanbevelingssysteem combineert doorgaans drie benaderingen: collaboratief filteren (gebruikers die vergelijkbaar gedrag vertonen, krijgen vergelijkbare aanbevelingen), inhoudsgebaseerd filteren (op basis van productkenmerken) en hybride methoden. In productie spelen latency, schaalbaarheid en het koude-startprobleem (nieuwe gebruikers of producten zonder historische data) een cruciale rol. Matrix factorizatie (ALS, SVD) is een gangbare aanpak; modern onderzoek zet in op sequentiemodellen en graph neural networks.

V18. Een A/B-test laat tegenstrijdige resultaten zien op korte en lange termijn. Hoe ga je daarmee om?

Tegenstrijdige A/B-testresultaten wijzen vaak op het Simpsonparadox, novelty-effecten (gebruikers reageren initieel anders op nieuwe features) of seizoensinvloeden. Aanbevolen aanpak: verleng de testperiode om novelty uit te sluiten, segmenteer de resultaten per gebruikersgroep, controleer op primacy-effecten bij terugkerende gebruikers, en pas indien nodig Bayesiaanse A/B-testing toe voor continue monitoring zonder het meervoudig-testen-probleem.

V19. Hoe zou je feature-importantie in een black-box model interpreteren?

Model-agnostische interpreteerbaarheidstools zijn SHAP (SHapley Additive exPlanations) en LIME (Local Interpretable Model-agnostic Explanations). SHAP berekent de bijdrage van elke feature op basis van speltheorie (Shapley-waarden) en biedt zowel globale als lokale verklaringen.

# feature_importance_shap.py
import shap
import xgboost as xgb
from sklearn.datasets import make_classification

# Generate synthetic dataset
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)

# Train XGBoost model
model = xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')
model.fit(X, y)

# SHAP explanation
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)

# Global importance: mean absolute SHAP value per feature
import numpy as np
importance = np.abs(shap_values).mean(axis=0)
for i in np.argsort(importance)[::-1]:
    print(f"Feature {i}: {importance[i]:.4f}")

V20. Hoe bepaal je de minimale steekproefomvang voor een A/B-test?

De formule voor twee proporties is: n = 2 × (z_α/2 + z_β)² × p(1−p) / δ², waarbij p de basisconversieratio is en δ het MDE. In Python biedt statsmodels.stats.proportion.proportion_effectsize een directe berekening. Let ook op het meervoudig-testen-probleem bij meerdere metriek tegelijkertijd.

Python en Pandas-vaardigheid (V21–V22)

V21. Wat is het verschil tussen map, apply en transform in Pandas?

Deze drie methoden worden regelmatig door elkaar gehaald in interviews. map werkt element-gewijs op een Series en is het snelste bij eenvoudige vervangingen via een dictionary of functie. apply past een arbitraire functie toe per rij of kolom van een DataFrame, of per element van een Series. transform verschilt fundamenteel: het retourneert een uitvoer met dezelfde index als de invoer, waardoor groepsstatistieken direct kunnen worden teruggekoppeld aan de oorspronkelijke rijen.

# pandas_operations.py
import pandas as pd

df = pd.DataFrame({
    'team': ['A', 'A', 'B', 'B', 'A'],
    'score': [10, 20, 30, 40, 50]
})

# map: element-wise on Series
df['team_upper'] = df['team'].map({'A': 'Alpha', 'B': 'Beta'})

# apply: arbitrary function per row
df['score_label'] = df['score'].apply(lambda x: 'high' if x > 25 else 'low')

# transform: group-level, same shape output (broadcasts back)
df['team_mean'] = df.groupby('team')['score'].transform('mean')
df['score_normalized'] = df.groupby('team')['score'].transform(
    lambda x: (x - x.mean()) / x.std()
)
print(df)

V22. Hoe optimaliseer je geheugengebruik in Pandas voor grote datasets?

Standaard wijst Pandas ruimhartig geheugentypen toe: integers als int64, floats als float64, en strings als het dure object-type. Strategieën om geheugen te besparen: downcast numerieke kolommen naar kleinere types met pd.to_numeric(..., downcast='integer'), zet hoog-cardinale kolommen met weinig unieke waarden om naar category, gebruik chunksize bij het inlezen van grote CSV-bestanden, en overweeg het Parquet-formaat voor persistentie — dit biedt kolomopslag met ingebouwde compressie.

Dimensiereductie en Ongesuperviseerd Leren (V23–V24)

V23. Vergelijk PCA, t-SNE en UMAP voor dimensiereductie.

De keuze tussen dimensiereductietechnieken hangt sterk af van het doel en de dataomvang:

| Methode | Lineair | Behoudt globale structuur | Snelheid (100K punten) | Toepassing | |---------|---------|--------------------------|------------------------|------------| | PCA | Ja | Ja | Seconden | Preprocessing, feature-reductie | | t-SNE | Nee | Nee | Minuten | Clustervisualisatie (kleine datasets) | | UMAP | Nee | Gedeeltelijk | Seconden | Visualisatie + preprocessing |

PCA is deterministisch en snel, maar kan alleen lineaire structuren vastleggen. t-SNE bewaart lokale buurrelaties uiterst goed maar schaalt slecht en is niet geschikt voor preprocessing. UMAP combineert de voordelen van beide: sneller dan t-SNE, beter schaalbaar, en de representaties zijn bruikbaar als features in downstream modellen.

V24. Leg de werking van het k-means-algoritme uit en noem de beperkingen ervan.

K-means minimaliseert de som van kwadratische afstanden van datapunten tot hun dichtstbijzijnde cluster-centroïde via iteratieve aanpassing: (1) wijs elk punt toe aan de dichtstbijzijnde centroïde, (2) herbereken de centroïden als het gemiddelde van de toegewezen punten. Herhaal tot convergentie. Beperkingen: het aantal clusters k moet vooraf worden opgegeven, het algoritme convergeert naar lokale minima (oplossing: meerdere random initialisaties of k-means++), is gevoelig voor uitbijters, en gaat ervan uit dat clusters bolvormig zijn met vergelijkbare omvang — waardoor het slecht presteert bij langgerekte of sterk verschillende clusters.

Communicatie en Zakelijke Impact (V25)

V25. Hoe communiceer je een complex model naar een niet-technisch publiek?

Dit is een van de meest onderschatte vaardigheden in data science. Een sterk antwoord toont drie lagen: (1) het zakelijke vraagstuk centraal stellen, niet de technologie; (2) analogieën gebruiken om modelwerking te duiden zonder jargon; (3) onzekerheid en modelgrenzen expliciet benoemen. Interviewers letten erop of een kandidaat de neiging heeft om te versimpelen ten koste van nauwkeurigheid, of juist te veel technisch detail geeft zonder de zakelijke relevantie te verbinden. Een goed model dat niet overtuigt in een boardroomdiscussie, leidt zelden tot een geïmplementeerde oplossing.

Conclusie

Een succesvolle data science-sollicitatie vereist voorbereiding op meerdere fronten tegelijkertijd:

• Statistische grondslag: p-waarden, hypothesetoetsing en Bayesiaanse intuïtie zijn basisvereisten, geen nichekennis.
• Hands-on Python: Pandas, Scikit-learn en visualisatietools moeten vloeiend zijn, inclusief valkuilen als data-leakage en geheugenoptimalisatie.
• ML-diepgang: Het bi-as-variantie-dilemma, regularisatie en ensemblemethoden worden in vrijwel elk senior interview bevraagd.
• Modelevaluatie: Weten welke metric wanneer van toepassing is, onderscheidt een junior van een senior kandidaat.
• Communicatie: Technische precisie gecombineerd met helder zakelijk verhaal is de onderscheidende factor op senior niveau.

De vragen in dit overzicht zijn representatief voor wat grote tech-bedrijven, banken en snelgroeiende scale-ups in 2026 verwachten van data science-kandidaten op elk ervaringsniveau.