Preguntas de Entrevista para Data Analyst 2026: Guía Completa de SQL, Python y Analytics

Las entrevistas para puestos de data analyst en 2026 evalúan tres competencias fundamentales: dominio de SQL, manipulación de datos con Python y resolución de problemas de negocio. Empresas como Google, Meta y Amazon han estandarizado sus evaluaciones técnicas en torno a estas habilidades, con las funciones window de SQL y las operaciones de pandas presentes en más del 80% de las entrevistas.

Funciones Window SQL: El Tema de Entrevista Más Frecuente

Las funciones window aparecen en prácticamente todas las entrevistas técnicas para data analysts. A diferencia de las funciones de agregación que colapsan filas, las funciones window realizan cálculos sobre un conjunto de filas relacionadas con la fila actual preservando los datos individuales.

Pregunta: Calcular el salario de cada empleado como porcentaje del salario total de su departamento.

-- employee_salary_percentage.sql
SELECT 
    employee_id,
    department,
    salary,
    -- SUM as window function preserves each row
    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;

La cláusula PARTITION BY crea ventanas separadas para cada departamento. El salario de cada empleado se divide por el total de su departamento, no por el total de la empresa. Esta distinción atrapa a muchos candidatos que utilizan una subconsulta o un join en su lugar.

Pregunta: Calcular el acumulado de ventas por fecha, reiniciando cada mes.

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

Los reclutadores esperan que los candidatos conozcan el comportamiento predeterminado del frame de ventana. Sin una cláusula ROWS o RANGE explícita, el frame se extiende desde el inicio de la partición hasta la fila actual, produciendo un acumulado. Estos patrones se practican con el módulo de funciones window SQL.

CTEs y Subconsultas: Organizar Consultas Complejas

Las Common Table Expressions hacen las consultas legibles y mantenibles. Los reclutadores evalúan si los candidatos estructuran sus consultas de manera lógica en lugar de escribir sentencias monolíticas.

Pregunta: Encontrar clientes que realizaron compras en meses consecutivos.

-- consecutive_month_purchasers.sql
WITH monthly_purchases AS (
    -- Step 1: Get distinct customer-month combinations
    SELECT DISTINCT
        customer_id,
        DATE_TRUNC('month', purchase_date) AS purchase_month
    FROM orders
),
with_prev_month AS (
    -- Step 2: Add previous purchase month for each customer
    SELECT
        customer_id,
        purchase_month,
        LAG(purchase_month) OVER (
            PARTITION BY customer_id 
            ORDER BY purchase_month
        ) AS prev_purchase_month
    FROM monthly_purchases
)
-- Step 3: Filter to consecutive months only
SELECT DISTINCT customer_id
FROM with_prev_month
WHERE purchase_month = prev_purchase_month + INTERVAL '1 month';

Este patrón combina CTEs con la función window LAG. Descomponer la consulta en pasos nombrados demuestra el proceso de razonamiento, algo que los reclutadores valoran tanto como la respuesta correcta.

Python Pandas: Fundamentos de Manipulación de Datos

Las preguntas de pandas evalúan habilidades de limpieza, agregación y transformación de datos. Los reclutadores presentan conjuntos de datos desordenados y piden a los candidatos extraer insights.

Pregunta: Dado un DataFrame de sesiones de usuario, calcular la duración promedio de sesión por segmento de usuario, excluyendo sesiones menores a 10 segundos.

# session_analysis.py
import pandas as pd

def analyze_sessions(df: pd.DataFrame) -> pd.DataFrame:
    """Calculate average session duration by user segment.
    
    Args:
        df: DataFrame with columns [user_id, segment, session_start, session_end]
    
    Returns:
        DataFrame with average duration per segment
    """
    # Calculate duration in seconds
    df['duration_seconds'] = (
        df['session_end'] - df['session_start']
    ).dt.total_seconds()
    
    # Filter short sessions and aggregate
    return (
        df[df['duration_seconds'] >= 10]
        .groupby('segment')
        .agg(
            avg_duration=('duration_seconds', 'mean'),
            session_count=('user_id', 'count')
        )
        .round(2)
        .reset_index()
    )

La respuesta demuestra encadenamiento de métodos, manejo de fechas y la función agg con salidas nombradas. Los reclutadores verifican que los candidatos filtren antes de agregar en lugar de después, lo cual sesgaría los promedios.

Pregunta: Fusionar dos DataFrames y manejar correctamente los valores faltantes.

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

def merge_user_data(
    users: pd.DataFrame,
    transactions: pd.DataFrame
) -> pd.DataFrame:
    """Merge user demographics with transaction history.
    
    Users without transactions get total_spent = 0.
    Transactions without user data are excluded.
    """
    merged = pd.merge(
        users,
        transactions.groupby('user_id')['amount'].sum().reset_index(),
        on='user_id',
        how='left'  # Keep all users, even without transactions
    )
    
    # Fill NaN for users with no transactions
    merged['amount'] = merged['amount'].fillna(0)
    merged.rename(columns={'amount': 'total_spent'}, inplace=True)
    
    return merged

El parámetro how='left' y el manejo explícito con fillna muestran atención a los casos límite. Los candidatos que usan how='inner' pierden usuarios sin transacciones, lo que modifica la población de análisis.

Conceptos Estadísticos: Lo que los Analistas Deben Explicar con Claridad

Las preguntas estadísticas evalúan si los candidatos pueden aplicar conceptos a problemas reales de negocio y comunicar hallazgos a las partes interesadas.

Pregunta: Un product manager afirma que el nuevo flujo de checkout aumentó la conversión en 5%. La prueba duró una semana con 10,000 usuarios por variante. ¿Es este resultado estadísticamente significativo?

Una respuesta completa aborda el tamaño de muestra, la potencia estadística y la significancia práctica:

1. Calcular el error estándar: Para tasas de conversión, SE = sqrt(p(1-p)/n). Con una conversión base del 10% y n=10,000, SE equivale aproximadamente a 0.003.

2. Calcular el z-score: Un incremento relativo del 5% significa que la nueva conversión es 10.5%. La diferencia de 0.5 puntos porcentuales dividida por el error estándar combinado determina la significancia.

3. Considerar la significancia práctica: Incluso si p < 0.05, un incremento de 0.5 puntos porcentuales puede no justificar el costo de ingeniería del nuevo flujo.

4. Verificar factores de confusión: Una semana captura patrones entre semana y fin de semana pero puede omitir ciclos mensuales o efectos estacionales.

Los reclutadores valoran candidatos que cuestionan supuestos en lugar de calcular mecánicamente p-values. El módulo de principios de visualización de datos cubre cómo presentar estos hallazgos.

Pregunta: Explicar la diferencia entre correlación y causalidad con un ejemplo de negocio.

Las ventas de helados y las muertes por ahogamiento están correlacionadas positivamente. Ambas aumentan en verano debido a la variable confusora de la temperatura. Recomendar reducir la producción de helados para prevenir ahogamientos confunde correlación con causalidad.

En analytics de negocio: el gasto publicitario y los ingresos frecuentemente están correlacionados, pero esta relación puede reflejar que las empresas aumentan su gasto publicitario cuando las proyecciones de ingresos ya son favorables, no que los anuncios generen ingresos. Establecer causalidad requiere experimentos controlados o técnicas de inferencia causal como diferencia en diferencias.

Preguntas de Casos de Negocio: Traducir Problemas a Consultas

Las preguntas de caso evalúan la capacidad de descomponer problemas de negocio ambiguos en pasos analíticos concretos.

Pregunta: La retención de usuarios cayó 15% el mes pasado. ¿Cómo investigar?

Un enfoque estructurado:

1. Validar la métrica: Confirmar que la definición de retención coincide con los cálculos históricos. Verificar problemas en el pipeline de datos o cambios en el tracking.

2. Segmentar la caída: Descomponer la retención por cohorte de usuario, canal de adquisición, tipo de dispositivo y geografía. Una caída global del 15% podría ser una caída del 50% en un segmento enmascarando estabilidad en otros.

3. Identificar el timing: ¿La retención cayó gradualmente o de repente? Una caída súbita sugiere un cambio de producto o bug. Un declive gradual apunta a factores de mercado o competitivos.

4. Correlacionar con eventos: Alinear la línea temporal con lanzamientos de producto, campañas de marketing, lanzamientos de competidores y eventos externos.

5. Formar hipótesis: Basándose en los patrones de segmentación, proponer explicaciones testeables y los datos necesarios para confirmar o rechazar cada una.

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

Esta consulta de análisis de cohortes produce los datos necesarios para el paso 2. El módulo de retención de cohortes cubre variaciones de este patrón.

Ejercicios para Casa: Lo que Evalúan los Revisores

Muchas empresas incluyen ejercicios para casa de 2 a 4 horas. Los evaluadores califican las entregas por calidad de código, rigor analítico y comunicación.

Ejercicio común: Dado un conjunto de datos de transacciones de e-commerce, identificar factores que predicen el churn de clientes.

Las entregas sólidas comparten estas características:

• Análisis exploratorio primero: Estadísticas descriptivas, gráficos de distribución y evaluación de valores faltantes antes del modelado
• Feature engineering: Crear variables relevantes como recencia, frecuencia, valor monetario (RFM) e indicadores de tendencia
• Justificación de selección de modelo: Explicar por qué la regresión logística o random forest se ajusta al problema, no solo ejecutar valores por defecto
• Enfoque de validación: Usar splits basados en tiempo en lugar de splits aleatorios para evitar fuga de datos
• Comunicación clara: Resumen ejecutivo al inicio, detalles técnicos en apéndice, visualizaciones que respalden las conclusiones

# 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:
    """Create Recency, Frequency, Monetary features per customer."""
    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:
    """Evaluate model using time-based cross-validation."""
    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

El código demuestra feature engineering relevante al dominio y metodología de validación apropiada para datos temporales.

Puntos Clave para Entrevistas de Data Analyst en 2026

• Las funciones window SQL con PARTITION BY y ORDER BY aparecen en la mayoría de las entrevistas técnicas. Practicar el cálculo de acumulados, porcentajes y rankings.

• Las preguntas de Python pandas enfatizan encadenamiento de métodos, agregaciones groupby y operaciones de merge con manejo apropiado de valores faltantes.

• Las preguntas estadísticas requieren explicar conceptos en términos de negocio. Los reclutadores evalúan la capacidad de comunicación, no solo el conocimiento técnico.

• Las preguntas de casos de negocio prueban la descomposición estructurada de problemas. Comenzar validando la métrica, luego segmentar para aislar el problema.

• Los ejercicios para casa se califican por calidad de código y comunicación tanto como por precisión analítica. Incluir un resumen ejecutivo y explicar las decisiones tomadas.

• El módulo avanzado de BigQuery y el módulo básico de Python pandas proporcionan preguntas de práctica adicionales alineadas con los patrones de entrevista actuales.