Data Analyst Bewerbungsfragen 2026: Umfassender Leitfaden für SQL, Python und Analytics

Bewerbungsgespräche für Data Analysts im Jahr 2026 konzentrieren sich auf drei Kernbereiche: SQL-Kenntnisse, Python-Datenmanipulation und Geschäftsproblem-Analyse. Unternehmen wie Google, Meta und Amazon haben ihre technischen Screening-Prozesse standardisiert, wobei SQL-Window-Functions und Pandas-Operationen in über 80% der Interviews vorkommen.

SQL Window Functions: Das häufigste Interviewthema

Window Functions erscheinen in fast jedem technischen Data Analyst Screening. Im Gegensatz zu Aggregatfunktionen, die Zeilen zusammenfassen, führen Window Functions Berechnungen über eine Menge von Zeilen durch, die mit der aktuellen Zeile in Beziehung stehen, während die individuellen Zeilendaten erhalten bleiben.

Frage: Berechne das Gehalt jedes Mitarbeiters als Prozentsatz des Gesamtgehalts seiner Abteilung.

-- employee_salary_percentage.sql
SELECT 
    employee_id,
    department,
    salary,
    -- SUM als Window Function behält jede Zeile bei
    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;

Die PARTITION BY-Klausel erstellt separate Fenster für jede Abteilung. Das Gehalt jedes Mitarbeiters wird durch das Gesamtgehalt seiner Abteilung geteilt, nicht durch das Unternehmensgesamt. Diese Unterscheidung überrascht viele Kandidaten, die stattdessen eine Unterabfrage oder einen Join verwenden.

Frage: Finde die laufende Summe der Verkäufe nach Datum, mit monatlichem Reset.

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

Interviewer erwarten, dass Kandidaten das Standard-Window-Frame-Verhalten kennen. Ohne explizite ROWS- oder RANGE-Klausel erstreckt sich der Frame vom Partitionsanfang bis zur aktuellen Zeile, was eine laufende Summe erzeugt.

CTEs und Unterabfragen: Komplexe Queries strukturieren

Common Table Expressions machen Abfragen lesbar und wartbar. Interviewer bewerten, ob Kandidaten Abfragen logisch strukturieren, anstatt monolithische Statements zu schreiben.

Frage: Finde Kunden, die in aufeinanderfolgenden Monaten Käufe getätigt haben.

-- consecutive_month_purchasers.sql
WITH monthly_purchases AS (
    -- Schritt 1: Erhalte eindeutige Kunde-Monat-Kombinationen
    SELECT DISTINCT
        customer_id,
        DATE_TRUNC('month', purchase_date) AS purchase_month
    FROM orders
),
with_prev_month AS (
    -- Schritt 2: Füge vorherigen Kaufmonat für jeden Kunden hinzu
    SELECT
        customer_id,
        purchase_month,
        LAG(purchase_month) OVER (
            PARTITION BY customer_id 
            ORDER BY purchase_month
        ) AS prev_purchase_month
    FROM monthly_purchases
)
-- Schritt 3: Filtere auf aufeinanderfolgende Monate
SELECT DISTINCT customer_id
FROM with_prev_month
WHERE purchase_month = prev_purchase_month + INTERVAL '1 month';

Dieses Muster kombiniert CTEs mit der LAG-Window-Function. Das Aufteilen der Abfrage in benannte Schritte demonstriert den Denkprozess, den Interviewer genauso wertschätzen wie die korrekte Antwort.

Python Pandas: Grundlagen der Datenmanipulation

Pandas-Fragen testen Fähigkeiten in Datenbereinigung, Aggregation und Transformation. Interviewer präsentieren unordentliche Datensätze und bitten Kandidaten, Erkenntnisse zu extrahieren.

Frage: Berechne bei einem DataFrame von Benutzersitzungen die durchschnittliche Sitzungsdauer nach Benutzersegment, ohne Sitzungen unter 10 Sekunden.

# session_analysis.py
import pandas as pd

def analyze_sessions(df: pd.DataFrame) -> pd.DataFrame:
    """Berechne durchschnittliche Sitzungsdauer nach Benutzersegment.
    
    Args:
        df: DataFrame mit Spalten [user_id, segment, session_start, session_end]
    
    Returns:
        DataFrame mit durchschnittlicher Dauer pro Segment
    """
    # Berechne Dauer in Sekunden
    df['duration_seconds'] = (
        df['session_end'] - df['session_start']
    ).dt.total_seconds()
    
    # Filtere kurze Sitzungen und aggregiere
    return (
        df[df['duration_seconds'] >= 10]
        .groupby('segment')
        .agg(
            avg_duration=('duration_seconds', 'mean'),
            session_count=('user_id', 'count')
        )
        .round(2)
        .reset_index()
    )

Die Antwort demonstriert Method Chaining, Datetime-Handling und die agg-Funktion mit benannten Ausgaben. Interviewer prüfen, dass Kandidaten vor der Aggregation filtern, nicht danach, was die Durchschnitte verzerren würde.

Frage: Führe zwei DataFrames zusammen und behandle fehlende Werte angemessen.

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

def merge_user_data(
    users: pd.DataFrame,
    transactions: pd.DataFrame
) -> pd.DataFrame:
    """Führe Benutzerdemografie mit Transaktionshistorie zusammen.
    
    Benutzer ohne Transaktionen erhalten total_spent = 0.
    Transaktionen ohne Benutzerdaten werden ausgeschlossen.
    """
    merged = pd.merge(
        users,
        transactions.groupby('user_id')['amount'].sum().reset_index(),
        on='user_id',
        how='left'  # Behalte alle Benutzer, auch ohne Transaktionen
    )
    
    # Fülle NaN für Benutzer ohne Transaktionen
    merged['amount'] = merged['amount'].fillna(0)
    merged.rename(columns={'amount': 'total_spent'}, inplace=True)
    
    return merged

Der how='left'-Parameter und die explizite fillna-Behandlung zeigen Aufmerksamkeit für Randfälle. Kandidaten, die how='inner' verwenden, verlieren Benutzer ohne Transaktionen, was die Analysepopulation verändert.

Statistische Konzepte: Was Analysten klar erklären müssen

Statistische Fragen bewerten, ob Kandidaten Konzepte auf reale Geschäftsprobleme anwenden und Ergebnisse für Stakeholder verständlich kommunizieren können.

Frage: Ein Produktmanager behauptet, der neue Checkout-Flow habe die Konversionsrate um 5% erhöht. Der Test lief eine Woche mit 10.000 Benutzern pro Variante. Ist dieses Ergebnis statistisch signifikant?

Eine vollständige Antwort adressiert Stichprobengröße, statistische Power und praktische Signifikanz:

1. Standardfehler berechnen: Für Konversionsraten gilt SE = sqrt(p(1-p)/n). Bei einer Basis-Konversionsrate von 10% und n=10.000 beträgt der SE etwa 0,003.

2. Z-Score berechnen: Eine 5%ige relative Steigerung bedeutet, die neue Konversionsrate beträgt 10,5%. Die Differenz von 0,5 Prozentpunkten geteilt durch den gepoolten SE bestimmt die Signifikanz.

3. Praktische Signifikanz berücksichtigen: Selbst wenn p < 0,05, rechtfertigt eine Steigerung von 0,5 Prozentpunkten möglicherweise nicht die Entwicklungskosten des neuen Flows.

4. Auf Störfaktoren prüfen: Eine Woche erfasst Wochenend- vs. Wochentagsmuster, verpasst aber möglicherweise monatliche Zyklen oder saisonale Effekte.

Interviewer schätzen Kandidaten, die Annahmen hinterfragen, anstatt mechanisch p-Werte zu berechnen.

Frage: Erkläre den Unterschied zwischen Korrelation und Kausalität mit einem Geschäftsbeispiel.

Eisverkäufe und Ertrinkungsfälle korrelieren positiv. Beide steigen im Sommer aufgrund der Störvariablen Temperatur. Die Empfehlung, die Eisproduktion zu reduzieren, um Ertrinken zu verhindern, verwechselt Korrelation mit Kausalität.

In der Geschäftsanalytik: Werbeausgaben und Umsatz korrelieren oft, aber die Beziehung kann widerspiegeln, dass Unternehmen Werbeausgaben erhöhen, wenn Umsatzprognosen bereits stark sind, nicht dass Werbung den Umsatz antreibt. Die Etablierung von Kausalität erfordert kontrollierte Experimente oder kausale Inferenztechniken wie Difference-in-Differences.

Business-Case-Fragen: Probleme in Abfragen übersetzen

Case-Fragen testen die Fähigkeit, mehrdeutige Geschäftsprobleme in konkrete analytische Schritte zu zerlegen.

Frage: Die Benutzerbindung ist im letzten Monat um 15% gesunken. Wie würdest du dies untersuchen?

Ein strukturierter Ansatz:

1. Metrik validieren: Bestätige, dass die Retention-Definition mit historischen Berechnungen übereinstimmt. Prüfe auf Datenpipeline-Probleme oder Tracking-Änderungen.

2. Den Rückgang segmentieren: Teile die Retention nach Benutzerkohorte, Akquisitionskanal, Gerätetyp und Geografie auf. Ein 15%iger Gesamtrückgang könnte ein 50%iger Rückgang in einem Segment sein, der Stabilität anderswo maskiert.

3. Timing identifizieren: Sank die Retention allmählich oder plötzlich? Ein plötzlicher Rückgang deutet auf eine Produktänderung oder einen Bug hin. Ein allmählicher Rückgang weist auf Markt- oder Wettbewerbsfaktoren hin.

4. Mit Ereignissen korrelieren: Gleiche die Timeline mit Produktreleases, Marketingkampagnen, Wettbewerbsstarts und externen Ereignissen ab.

5. Hypothesen bilden: Basierend auf Segmentierungsmustern testbare Erklärungen vorschlagen und die Daten identifizieren, die benötigt werden, um jede zu bestätigen oder zu widerlegen.

-- 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;

Diese Kohortenanalyse-Abfrage liefert die für Schritt 2 benötigten Daten.

Take-Home-Aufgaben: Was Evaluatoren bewerten

Viele Unternehmen nutzen Take-Home-Aufgaben mit einer Dauer von 2 bis 4 Stunden. Evaluatoren bewerten Einreichungen nach Codequalität, analytischer Strenge und Kommunikation.

Typische Aufgabe: Bei einem Datensatz von E-Commerce-Transaktionen Faktoren identifizieren, die Kundenabwanderung vorhersagen.

Starke Einreichungen teilen diese Eigenschaften:

• Explorative Analyse zuerst: Zusammenfassende Statistiken, Verteilungsplots und Bewertung fehlender Werte vor der Modellierung
• Feature Engineering: Erstellung relevanter Features wie Recency, Frequency, Monetary Value (RFM) und Trendindikatoren
• Begründung der Modellauswahl: Erklärung, warum logistische Regression oder Random Forest zum Problem passt, nicht nur Standardwerte ausführen
• Validierungsansatz: Zeitbasierte Splits statt zufälliger Splits verwenden, um Data Leakage zu vermeiden
• Klare Kommunikation: Executive Summary am Anfang, technische Details im Anhang, Visualisierungen, die Schlussfolgerungen unterstützen

# 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:
    """Erstelle Recency, Frequency, Monetary Features pro Kunde."""
    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:
    """Evaluiere Modell mit zeitbasierter Kreuzvalidierung."""
    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

Der Code demonstriert domänenrelevantes Feature Engineering und eine angemessene Validierungsmethodik für Zeitreihendaten.

Wichtige Erkenntnisse für Data Analyst Interviews 2026

• SQL Window Functions mit PARTITION BY und ORDER BY erscheinen in den meisten technischen Screenings. Übe das Berechnen von laufenden Summen, Prozentsätzen und Rankings.

• Python-Pandas-Fragen betonen Method Chaining, Groupby-Aggregationen und Merge-Operationen mit korrekter Behandlung fehlender Werte.

• Statistische Fragen erfordern die Erklärung von Konzepten in Geschäftsbegriffen. Interviewer bewerten die Kommunikationsfähigkeit, nicht nur technisches Wissen.

• Business-Case-Fragen testen strukturierte Problemzerlegung. Beginne mit der Validierung der Metrik, dann segmentiere, um das Problem zu isolieren.

• Take-Home-Aufgaben werden nach Codequalität und Kommunikation genauso bewertet wie nach analytischer Genauigkeit. Füge eine Executive Summary hinzu und erkläre deine Entscheidungen.