4 proyectos de SQL para tu portfolio de analista: window functions, joins y un dashboard que cuenta una historia

Resumen ejecutivo

• Cuatro proyectos chicos de SQL que podés subir a GitHub y mostrar en una entrevista de analista de datos: modelo estrella, window functions, cohortes y un dashboard con una pregunta de negocio.

• Cada proyecto incluye qué demuestra, un dataset público sugerido, consultas de ejemplo y qué poner en el README.

• Las window functions (ranking, acumulados, comparaciones con el período anterior) son de lo más pedido en entrevistas técnicas de data y lo que más diferencia un portfolio junior.

• Cerramos con cómo contar cada proyecto en una entrevista en menos de dos minutos.

Hiciste un curso de SQL, sabés hacer SELECT, WHERE, GROUP BY y algunos JOIN, pero cuando te piden «mostrame algo que hayas hecho» no tenés nada para enseñar. Es el problema más común de quien busca su primer trabajo como analista: el conocimiento está, pero no hay evidencia. Un portfolio con proyectos concretos resuelve eso, siempre que cada proyecto responda una pregunta de negocio y no sea solo una lista de consultas.

Por qué ahora: los procesos de selección para analistas junior suelen incluir una prueba técnica de SQL, y los proyectos con window functions y análisis de cohortes muestran que estás un paso más allá de lo básico. Además, documentar bien los proyectos en GitHub es lo que permite que un recruiter no técnico entienda tu trabajo. Si estás arrancando, repasá primero SQL para analistas de datos que vienen de Excel.

Antes de empezar: dónde conseguir datos y dónde practicar

• Datasets públicos: en Kaggle Datasets hay datos de e-commerce, ventas minoristas, suscripciones y más. También podés usar portales de datos abiertos de gobiernos o datasets públicos de BigQuery.

• Motor de base de datos: PostgreSQL es una gran opción gratuita y muy pedida. SQLite o DuckDB sirven si querés algo más liviano.

• Repositorio: una carpeta por proyecto, con las consultas en archivos .sql numerados y un README.

Proyecto 1: limpieza y modelo estrella simple

Qué demuestra: que sabés pasar de una tabla «sucia» a un modelo ordenado para análisis, con una tabla de hechos y dimensiones.

Dataset sugerido: un dataset de ventas de e-commerce con pedidos, clientes y productos.

Qué hacer:

1. Cargá los datos crudos en una tabla de staging.

2. Limpiá duplicados, valores nulos y formatos de fecha inconsistentes.

3. Creá una tabla de hechos (fact_pedidos) y dimensiones (dim_clientes, dim_productos, dim_fecha).

4. Documentá las reglas de limpieza que aplicaste.

-- Eliminar duplicados quedándote con el registro más reciente
CREATE TABLE stg_pedidos_limpios AS
SELECT *
FROM (
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY id_pedido ORDER BY fecha_carga DESC) AS rn
  FROM stg_pedidos
) t
WHERE rn = 1;

-- Eliminar duplicados quedándote con el registro más reciente
CREATE TABLE stg_pedidos_limpios AS
SELECT *
FROM (
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY id_pedido ORDER BY fecha_carga DESC) AS rn
  FROM stg_pedidos
) t
WHERE rn = 1;

-- Eliminar duplicados quedándote con el registro más reciente
CREATE TABLE stg_pedidos_limpios AS
SELECT *
FROM (
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY id_pedido ORDER BY fecha_carga DESC) AS rn
  FROM stg_pedidos
) t
WHERE rn = 1;

-- Eliminar duplicados quedándote con el registro más reciente
CREATE TABLE stg_pedidos_limpios AS
SELECT *
FROM (
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY id_pedido ORDER BY fecha_carga DESC) AS rn
  FROM stg_pedidos
) t
WHERE rn = 1;

Proyecto 2: análisis con window functions

Qué demuestra: dominio de funciones de ventana, uno de los temas más evaluados en entrevistas técnicas. La documentación de PostgreSQL las define como cálculos sobre un conjunto de filas relacionadas con la fila actual, sin agruparlas en una sola.

Preguntas de negocio para responder:

• ¿Cuáles son los 3 productos más vendidos de cada categoría? (ranking)

• ¿Cómo evoluciona la facturación acumulada mes a mes? (running total)

• ¿Cuánto creció cada mes respecto del anterior? (comparación con LAG)

-- Top 3 productos por categoría
SELECT *
FROM (
  SELECT categoria, producto, SUM(importe) AS ventas,
         RANK() OVER (PARTITION BY categoria ORDER BY SUM(importe) DESC) AS puesto
  FROM fact_pedidos
  JOIN dim_productos USING (id_producto)
  GROUP BY categoria, producto
) r
WHERE puesto <= 3;

-- Facturación mensual, acumulado y variación vs el mes anterior
WITH mensual AS (
  SELECT DATE_TRUNC('month', fecha_pedido) AS mes, SUM(importe) AS ventas
  FROM fact_pedidos
  GROUP BY 1
)
SELECT mes, ventas,
       SUM(ventas) OVER (ORDER BY mes) AS acumulado,
       ventas - LAG(ventas) OVER (ORDER BY mes) AS diferencia_mes_anterior
FROM mensual
ORDER BY mes;

-- Top 3 productos por categoría
SELECT *
FROM (
  SELECT categoria, producto, SUM(importe) AS ventas,
         RANK() OVER (PARTITION BY categoria ORDER BY SUM(importe) DESC) AS puesto
  FROM fact_pedidos
  JOIN dim_productos USING (id_producto)
  GROUP BY categoria, producto
) r
WHERE puesto <= 3;

-- Facturación mensual, acumulado y variación vs el mes anterior
WITH mensual AS (
  SELECT DATE_TRUNC('month', fecha_pedido) AS mes, SUM(importe) AS ventas
  FROM fact_pedidos
  GROUP BY 1
)
SELECT mes, ventas,
       SUM(ventas) OVER (ORDER BY mes) AS acumulado,
       ventas - LAG(ventas) OVER (ORDER BY mes) AS diferencia_mes_anterior
FROM mensual
ORDER BY mes;

-- Top 3 productos por categoría
SELECT *
FROM (
  SELECT categoria, producto, SUM(importe) AS ventas,
         RANK() OVER (PARTITION BY categoria ORDER BY SUM(importe) DESC) AS puesto
  FROM fact_pedidos
  JOIN dim_productos USING (id_producto)
  GROUP BY categoria, producto
) r
WHERE puesto <= 3;

-- Facturación mensual, acumulado y variación vs el mes anterior
WITH mensual AS (
  SELECT DATE_TRUNC('month', fecha_pedido) AS mes, SUM(importe) AS ventas
  FROM fact_pedidos
  GROUP BY 1
)
SELECT mes, ventas,
       SUM(ventas) OVER (ORDER BY mes) AS acumulado,
       ventas - LAG(ventas) OVER (ORDER BY mes) AS diferencia_mes_anterior
FROM mensual
ORDER BY mes;

-- Top 3 productos por categoría
SELECT *
FROM (
  SELECT categoria, producto, SUM(importe) AS ventas,
         RANK() OVER (PARTITION BY categoria ORDER BY SUM(importe) DESC) AS puesto
  FROM fact_pedidos
  JOIN dim_productos USING (id_producto)
  GROUP BY categoria, producto
) r
WHERE puesto <= 3;

-- Facturación mensual, acumulado y variación vs el mes anterior
WITH mensual AS (
  SELECT DATE_TRUNC('month', fecha_pedido) AS mes, SUM(importe) AS ventas
  FROM fact_pedidos
  GROUP BY 1
)
SELECT mes, ventas,
       SUM(ventas) OVER (ORDER BY mes) AS acumulado,
       ventas - LAG(ventas) OVER (ORDER BY mes) AS diferencia_mes_anterior
FROM mensual
ORDER BY mes;

Proyecto 3: cohortes básicas de retención

Qué demuestra: que sabés responder una pregunta clave de producto y marketing: ¿los clientes vuelven a comprar?

Qué hacer: asigná a cada cliente su mes de primera compra (la cohorte), calculá en qué meses posteriores volvió a comprar y armá una tabla de retención por cohorte.

WITH primera AS (
  SELECT id_cliente, DATE_TRUNC('month', MIN(fecha_pedido)) AS cohorte
  FROM fact_pedidos
  GROUP BY id_cliente
),
actividad AS (
  SELECT DISTINCT p.id_cliente, pr.cohorte,
         DATE_TRUNC('month', p.fecha_pedido) AS mes_actividad
  FROM fact_pedidos p
  JOIN primera pr USING (id_cliente)
)
SELECT cohorte,
       (EXTRACT(YEAR FROM AGE(mes_actividad, cohorte)) * 12
        + EXTRACT(MONTH FROM AGE(mes_actividad, cohorte))) AS meses_desde_inicio,
       COUNT(DISTINCT id_cliente) AS clientes_activos
FROM actividad
GROUP BY 1, 2
ORDER BY 1, 2;

WITH primera AS (
  SELECT id_cliente, DATE_TRUNC('month', MIN(fecha_pedido)) AS cohorte
  FROM fact_pedidos
  GROUP BY id_cliente
),
actividad AS (
  SELECT DISTINCT p.id_cliente, pr.cohorte,
         DATE_TRUNC('month', p.fecha_pedido) AS mes_actividad
  FROM fact_pedidos p
  JOIN primera pr USING (id_cliente)
)
SELECT cohorte,
       (EXTRACT(YEAR FROM AGE(mes_actividad, cohorte)) * 12
        + EXTRACT(MONTH FROM AGE(mes_actividad, cohorte))) AS meses_desde_inicio,
       COUNT(DISTINCT id_cliente) AS clientes_activos
FROM actividad
GROUP BY 1, 2
ORDER BY 1, 2;

WITH primera AS (
  SELECT id_cliente, DATE_TRUNC('month', MIN(fecha_pedido)) AS cohorte
  FROM fact_pedidos
  GROUP BY id_cliente
),
actividad AS (
  SELECT DISTINCT p.id_cliente, pr.cohorte,
         DATE_TRUNC('month', p.fecha_pedido) AS mes_actividad
  FROM fact_pedidos p
  JOIN primera pr USING (id_cliente)
)
SELECT cohorte,
       (EXTRACT(YEAR FROM AGE(mes_actividad, cohorte)) * 12
        + EXTRACT(MONTH FROM AGE(mes_actividad, cohorte))) AS meses_desde_inicio,
       COUNT(DISTINCT id_cliente) AS clientes_activos
FROM actividad
GROUP BY 1, 2
ORDER BY 1, 2;

WITH primera AS (
  SELECT id_cliente, DATE_TRUNC('month', MIN(fecha_pedido)) AS cohorte
  FROM fact_pedidos
  GROUP BY id_cliente
),
actividad AS (
  SELECT DISTINCT p.id_cliente, pr.cohorte,
         DATE_TRUNC('month', p.fecha_pedido) AS mes_actividad
  FROM fact_pedidos p
  JOIN primera pr USING (id_cliente)
)
SELECT cohorte,
       (EXTRACT(YEAR FROM AGE(mes_actividad, cohorte)) * 12
        + EXTRACT(MONTH FROM AGE(mes_actividad, cohorte))) AS meses_desde_inicio,
       COUNT(DISTINCT id_cliente) AS clientes_activos
FROM actividad
GROUP BY 1, 2
ORDER BY 1, 2;

En el README, explicá qué cohorte retiene mejor y una hipótesis de por qué. Esa conclusión vale más que la consulta.

Proyecto 4: un dashboard que cuenta una historia

Qué demuestra: que podés comunicar resultados a personas que no leen SQL.

Qué hacer: elegí una pregunta de negocio (por ejemplo, «¿qué categorías conviene impulsar el próximo trimestre?») y armá un dashboard con 3 a 5 gráficos que la respondan, conectado a las tablas de los proyectos anteriores. Podés usar Metabase, que es open source y se conecta directo a PostgreSQL, o Looker Studio, que es gratuito. Para lo segundo, te sirve esta guía de Looker Studio desde cero.

La clave: un título que sea la respuesta («Hogar y Deportes concentran el crecimiento») y no solo el tema («Ventas por categoría»).

Qué poner en el README de cada proyecto

1. La pregunta de negocio en una línea.

2. El dataset, con link a la fuente y licencia.

3. Las herramientas (PostgreSQL, Metabase, etc.).

4. Los hallazgos principales en 3 bullets, con números.

5. Capturas del resultado o del dashboard.

6. Cómo reproducirlo: orden en que se ejecutan los archivos.

Para el resto del portfolio, seguí esta guía para armar tu portfolio de data para conseguir trabajo.

Cómo explicarlo en una entrevista

Usá una estructura de cuatro partes y no te pases de dos minutos por proyecto:

• Contexto: «Quería entender si los clientes de una tienda online vuelven a comprar».

• Qué hice: «Armé cohortes por mes de primera compra con SQL en PostgreSQL».

• Qué encontré: el hallazgo principal, con un número.

• Qué haría después: una mejora o un análisis siguiente.

Estar preparado para explicar por qué usaste RANK y no ROW_NUMBER, o cómo manejaste los nulos, suma muchísimo. Si estás armando tu camino completo, mirá cómo convertirte en analista de datos sin experiencia.

Curso recomendado de Coderhouse

Si querés ganar soltura para resolver estos proyectos, el Curso de SQL te enseña a consultar y normalizar bases de datos relacionales. Si buscás una formación completa para trabajar como analista, la Carrera de Data Analytics cubre la extracción, limpieza y visualización de datos con SQL y dashboards interactivos.

Preguntas frecuentes

¿Cuántos proyectos de SQL necesito para conseguir trabajo como analista? No hay un número mágico, pero tres o cuatro proyectos bien documentados, que respondan preguntas de negocio distintas, suelen alcanzar para mostrar tu nivel.

¿Qué motor de base de datos conviene usar para el portfolio? PostgreSQL es una buena elección porque es gratuito, muy usado y soporta window functions completas. Lo importante es que el proyecto se pueda reproducir.

¿Qué son las window functions y por qué las preguntan tanto? Son funciones que calculan valores sobre un grupo de filas relacionadas (rankings, acumulados, comparaciones) sin perder el detalle de cada fila. Aparecen mucho en pruebas técnicas porque resuelven problemas reales de análisis.

¿Puedo usar datasets de Kaggle en mi portfolio? Sí, siempre que respetes la licencia y aportes un análisis propio. Para diferenciarte, elegí datasets menos usados o combiná varias fuentes.