Data Analyst Sollicitatievragen 2026: Complete Gids voor SQL, Python en Analytics

Sollicitatiegesprekken voor Data Analysts in 2026 testen drie kerngebieden: SQL-vaardigheid, Python data-manipulatie en bedrijfsproblemen oplossen. Bedrijven zoals Google, Meta en Amazon hebben hun technische screeningprocessen gestandaardiseerd, waarbij SQL window functions en Pandas-operaties in meer dan 80% van de interviews voorkomen.

SQL Window Functions: Het meest voorkomende interviewonderwerp

Window functions verschijnen in vrijwel elke technische Data Analyst screening. In tegenstelling tot aggregatiefuncties die rijen samenvoegen, voeren window functions berekeningen uit over een set rijen gerelateerd aan de huidige rij, terwijl de individuele rijgegevens behouden blijven.

Vraag: Bereken het salaris van elke werknemer als percentage van het totale salaris van zijn afdeling.

-- employee_salary_percentage.sql
SELECT 
    employee_id,
    department,
    salary,
    -- SUM als window function behoudt elke rij
    ROUND(
        salary * 100.0 / SUM(salary) OVER (PARTITION BY department),
        2
    ) AS pct_of_dept_salary
FROM employees
ORDER BY department, pct_of_dept_salary DESC;

De PARTITION BY-clausule creëert aparte vensters voor elke afdeling. Het salaris van elke werknemer wordt gedeeld door het totaal van zijn afdeling, niet door het bedrijfstotaal. Dit onderscheid verrast veel kandidaten die in plaats daarvan een subquery of join gebruiken.

Vraag: Vind het lopende totaal van verkopen per datum, met maandelijkse reset.

-- monthly_running_total.sql
SELECT
    sale_date,
    amount,
    SUM(amount) OVER (
        PARTITION BY DATE_TRUNC('month', sale_date)
        ORDER BY sale_date
        -- Standaard frame: RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS monthly_running_total
FROM sales
ORDER BY sale_date;

Recruiters verwachten dat kandidaten het standaard window frame-gedrag kennen. Zonder een expliciete ROWS of RANGE-clausule strekt het frame zich uit van het begin van de partitie tot de huidige rij, wat een lopend totaal produceert.

CTEs en Subqueries: Complexe queries organiseren

Common Table Expressions maken queries leesbaar en onderhoudbaar. Recruiters beoordelen of kandidaten queries logisch structureren in plaats van monolithische statements te schrijven.

Vraag: Vind klanten die aankopen hebben gedaan in opeenvolgende maanden.

-- consecutive_month_purchasers.sql
WITH monthly_purchases AS (
    -- Stap 1: Verkrijg unieke klant-maand combinaties
    SELECT DISTINCT
        customer_id,
        DATE_TRUNC('month', purchase_date) AS purchase_month
    FROM orders
),
with_prev_month AS (
    -- Stap 2: Voeg vorige aankoopmaand toe voor elke klant
    SELECT
        customer_id,
        purchase_month,
        LAG(purchase_month) OVER (
            PARTITION BY customer_id 
            ORDER BY purchase_month
        ) AS prev_purchase_month
    FROM monthly_purchases
)
-- Stap 3: Filter op alleen opeenvolgende maanden
SELECT DISTINCT customer_id
FROM with_prev_month
WHERE purchase_month = prev_purchase_month + INTERVAL '1 month';

Dit patroon combineert CTEs met de LAG window function. Het opdelen van de query in benoemde stappen demonstreert het denkproces, wat recruiters evenveel waarderen als het correcte antwoord.

Python Pandas: Essentiële data-manipulatie

Pandas-vragen testen vaardigheden in dataopschoning, aggregatie en transformatie. Recruiters presenteren rommelige datasets en vragen kandidaten om inzichten te extraheren.

Vraag: Gegeven een DataFrame van gebruikerssessies, bereken de gemiddelde sessieduur per gebruikerssegment, exclusief sessies korter dan 10 seconden.

# session_analysis.py
import pandas as pd

def analyze_sessions(df: pd.DataFrame) -> pd.DataFrame:
    """Bereken gemiddelde sessieduur per gebruikerssegment.
    
    Args:
        df: DataFrame met kolommen [user_id, segment, session_start, session_end]
    
    Returns:
        DataFrame met gemiddelde duur per segment
    """
    # Bereken duur in seconden
    df['duration_seconds'] = (
        df['session_end'] - df['session_start']
    ).dt.total_seconds()
    
    # Filter korte sessies en aggregeer
    return (
        df[df['duration_seconds'] >= 10]
        .groupby('segment')
        .agg(
            avg_duration=('duration_seconds', 'mean'),
            session_count=('user_id', 'count')
        )
        .round(2)
        .reset_index()
    )

Het antwoord demonstreert method chaining, datetime-handling en de agg-functie met benoemde outputs. Recruiters controleren of kandidaten filteren vóór aggregatie in plaats van erna, wat de gemiddelden zou vertekenen.

Vraag: Voeg twee DataFrames samen en behandel ontbrekende waarden op de juiste manier.

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

def merge_user_data(
    users: pd.DataFrame,
    transactions: pd.DataFrame
) -> pd.DataFrame:
    """Voeg gebruikersdemografie samen met transactiegeschiedenis.
    
    Gebruikers zonder transacties krijgen total_spent = 0.
    Transacties zonder gebruikersgegevens worden uitgesloten.
    """
    merged = pd.merge(
        users,
        transactions.groupby('user_id')['amount'].sum().reset_index(),
        on='user_id',
        how='left'  # Behoud alle gebruikers, ook zonder transacties
    )
    
    # Vul NaN voor gebruikers zonder transacties
    merged['amount'] = merged['amount'].fillna(0)
    merged.rename(columns={'amount': 'total_spent'}, inplace=True)
    
    return merged

De how='left' parameter en expliciete fillna-behandeling tonen aandacht voor randgevallen. Kandidaten die how='inner' gebruiken verliezen gebruikers zonder transacties, wat de analysepopulatie verandert.

Statistische concepten: Wat analisten helder moeten uitleggen

Statistische vragen beoordelen of kandidaten concepten kunnen toepassen op echte zakelijke problemen en bevindingen kunnen communiceren naar stakeholders.

Vraag: Een productmanager claimt dat de nieuwe checkout-flow de conversie met 5% heeft verhoogd. De test liep een week met 10.000 gebruikers per variant. Is dit resultaat statistisch significant?

Een volledig antwoord behandelt steekproefgrootte, statistische power en praktische significantie:

1. Bereken de standaardfout: Voor conversieratio's geldt SE = sqrt(p(1-p)/n). Met een basisconversie van 10% en n=10.000 is SE ongeveer 0,003.

2. Bereken de z-score: Een relatieve stijging van 5% betekent dat de nieuwe conversie 10,5% is. Het verschil van 0,5 procentpunt gedeeld door de gepoolde SE bepaalt de significantie.

3. Overweeg praktische significantie: Zelfs als p < 0,05, rechtvaardigt een stijging van 0,5 procentpunt mogelijk niet de ontwikkelingskosten van de nieuwe flow.

4. Controleer op verstorende factoren: Eén week vangt weekend- versus weekdagpatronen, maar mist mogelijk maandelijkse cycli of seizoenseffecten.

Recruiters waarderen kandidaten die aannames in vraag stellen in plaats van mechanisch p-waarden te berekenen.

Vraag: Leg het verschil uit tussen correlatie en causaliteit met een zakelijk voorbeeld.

Ijsverkoop en verdrinkingen correleren positief. Beide stijgen in de zomer vanwege de verstorende variabele temperatuur. Aanbevelen om ijsproductie te verminderen om verdrinkingen te voorkomen verwart correlatie met causaliteit.

In bedrijfsanalytics: advertentie-uitgaven en omzet correleren vaak, maar de relatie kan weerspiegelen dat bedrijven advertentie-uitgaven verhogen wanneer omzetvoorspellingen al sterk zijn, niet dat advertenties de omzet aandrijven. Causaliteit vaststellen vereist gecontroleerde experimenten of causale inferentietechnieken zoals difference-in-differences.

Business case-vragen: Problemen vertalen naar queries

Case-vragen testen het vermogen om ambigue zakelijke problemen te ontleden in concrete analytische stappen.

Vraag: Gebruikersretentie is vorige maand met 15% gedaald. Hoe zou je dit onderzoeken?

Een gestructureerde aanpak:

1. Valideer de metriek: Bevestig dat de retentiedefinitie overeenkomt met historische berekeningen. Controleer op datapipeline-problemen of tracking-wijzigingen.

2. Segmenteer de daling: Splits retentie op per gebruikerscohort, acquisitiekanaal, apparaattype en geografie. Een algehele daling van 15% kan een daling van 50% in één segment zijn die stabiliteit elders maskeert.

3. Identificeer de timing: Daalde de retentie geleidelijk of plotseling? Een plotselinge daling suggereert een productwijziging of bug. Een geleidelijke daling wijst op markt- of concurrentiefactoren.

4. Correleer met gebeurtenissen: Lijn de tijdlijn uit met productreleases, marketingcampagnes, lanceringen van concurrenten en externe gebeurtenissen.

5. Formuleer hypotheses: Stel op basis van segmentatiepatronen testbare verklaringen voor en identificeer de gegevens die nodig zijn om elk te bevestigen of te weerleggen.

-- retention_by_cohort.sql
WITH user_cohorts AS (
    SELECT
        user_id,
        DATE_TRUNC('week', created_at) AS cohort_week
    FROM users
),
weekly_activity AS (
    SELECT
        user_id,
        DATE_TRUNC('week', activity_date) AS activity_week
    FROM user_events
)
SELECT
    c.cohort_week,
    a.activity_week,
    COUNT(DISTINCT a.user_id) AS active_users,
    COUNT(DISTINCT c.user_id) AS cohort_size,
    ROUND(
        COUNT(DISTINCT a.user_id) * 100.0 / COUNT(DISTINCT c.user_id),
        1
    ) AS retention_pct
FROM user_cohorts c
LEFT JOIN weekly_activity a 
    ON c.user_id = a.user_id 
    AND a.activity_week >= c.cohort_week
GROUP BY c.cohort_week, a.activity_week
ORDER BY c.cohort_week, a.activity_week;

Deze cohortanalyse-query produceert de gegevens die nodig zijn voor stap 2.

Take-home opdrachten: Wat evaluatoren beoordelen

Veel bedrijven gebruiken take-home opdrachten van 2 tot 4 uur. Evaluatoren scoren inzendingen op codekwaliteit, analytische grondigheid en communicatie.

Typische opdracht: Gegeven een dataset van e-commerce transacties, identificeer factoren die klantenverloop voorspellen.

Sterke inzendingen delen deze kenmerken:

• Eerst exploratieve analyse: Samenvattende statistieken, distributiegrafieken en beoordeling van ontbrekende waarden vóór modellering
• Feature engineering: Creëren van relevante features zoals recency, frequency, monetary value (RFM) en trendindicatoren
• Motivatie voor modelkeuze: Uitleggen waarom logistische regressie of random forest bij het probleem past, niet alleen defaults draaien
• Validatieaanpak: Tijdsgebaseerde splits gebruiken in plaats van willekeurige splits om data leakage te voorkomen
• Heldere communicatie: Executive summary bovenaan, technische details in bijlage, visualisaties die conclusies ondersteunen

# churn_analysis_structure.py
import pandas as pd
from sklearn.model_selection import TimeSeriesSplit
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_recall_curve, auc

def create_rfm_features(df: pd.DataFrame, analysis_date: str) -> pd.DataFrame:
    """Creëer Recency, Frequency, Monetary features per klant."""
    analysis_dt = pd.to_datetime(analysis_date)
    
    rfm = df.groupby('customer_id').agg(
        recency=('order_date', lambda x: (analysis_dt - x.max()).days),
        frequency=('order_id', 'nunique'),
        monetary=('order_total', 'sum')
    ).reset_index()
    
    return rfm

def evaluate_with_time_split(
    X: pd.DataFrame, 
    y: pd.Series,
    n_splits: int = 5
) -> list:
    """Evalueer model met tijdsgebaseerde cross-validatie."""
    tscv = TimeSeriesSplit(n_splits=n_splits)
    scores = []
    
    for train_idx, val_idx in tscv.split(X):
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X.iloc[train_idx], y.iloc[train_idx])
        
        y_pred_proba = model.predict_proba(X.iloc[val_idx])[:, 1]
        precision, recall, _ = precision_recall_curve(y.iloc[val_idx], y_pred_proba)
        scores.append(auc(recall, precision))
    
    return scores

De code demonstreert domeinrelevante feature engineering en geschikte validatiemethodologie voor tijdreeksgegevens.

Belangrijkste inzichten voor Data Analyst interviews in 2026

• SQL window functions met PARTITION BY en ORDER BY verschijnen in de meeste technische screenings. Oefen het berekenen van lopende totalen, percentages en rankings.

• Python Pandas-vragen benadrukken method chaining, groupby-aggregaties en merge-operaties met correcte behandeling van ontbrekende waarden.

• Statistische vragen vereisen het uitleggen van concepten in zakelijke termen. Recruiters beoordelen communicatievermogen, niet alleen technische kennis.

• Business case-vragen testen gestructureerde probleemontleding. Begin met het valideren van de metriek, segmenteer vervolgens om het probleem te isoleren.

• Take-home opdrachten worden beoordeeld op codekwaliteit en communicatie evenzeer als op analytische nauwkeurigheid. Voeg een executive summary toe en leg je keuzes uit.