Los equipos de IA enfrentan un problema que nadie anticipa: su crecimiento asimétrico. Contratas un ML engineer senior y, de repente, te das cuenta de que necesitas dos data engineers. Fichas un research scientist y te encuentras con que necesitas tres annotation specialists. Y cuando finalmente tienes a todos, surge la confusión: ¿quién está trabajando en qué? ¿Cuáles son las habilidades específicas de tus LLM engineers en comparación con tus computer vision experts? ¿Y cuándo necesitarás incorporar a un especialista en reinforcement learning?
La gestión del talento en estos equipos no se asemeja a un enfoque tradicional de HR, aunque tenga una capa tecnológica. Por el contrario, se trata de rastrear capacidades técnicas muy específicas, documentar quién puede debuggear una pipeline de Vertex AI y quién sabe optimizar un modelo de Hugging Face para producción. Además, todo esto debe sincronizarse con sprints de producto que cambian cada dos semanas. Ojo, Notion puede convertirse en tu sistema nervioso para gestionar esto, pero solo si lo conectas adecuadamente con Google Cloud para automatizar lo que realmente importa: conocer tu talento actual, identificar brechas y prever cuándo lo necesitarás.
Paso 1: Mapea tus roles reales (no los que aparecen en LinkedIn)
Un error común es trasladar los job titles de LinkedIn a tu base de datos. "Machine Learning Engineer" no dice nada cuando realmente necesitas saber si esa persona puede implementar attention mechanisms desde cero o si solo utiliza APIs pre-entrenadas.
Construye tu taxonomía técnica desde las capacidades
En Notion, te sugiero crear una base de datos llamada Skill Matrix con las siguientes propiedades:
- Skill Name (título): "PyTorch optimization", "Vertex AI deployment", "RLHF implementation"
- Category (select): Infrastructure, Modeling, MLOps, Research, Data Engineering
- Proficiency Levels (multi-select): Basic, Intermediate, Advanced, Expert
- Related Tools (relation): conecta con otra base de datos de herramientas
- Last Validated (date): fecha de la última verificación
- Market Demand (select): Low, Medium, High, Critical
Luego, conecta esto con tu base de datos de Team Members a través de una relación bidireccional. Cada persona tendrá un campo multi-relacional que apunte a sus habilidades específicas junto con su nivel de proficiency.
El punto crítico aquí es claro: no confíes en auto-evaluaciones. Más bien, conecta esta Skill Matrix con resultados concretos. En la base de datos de Projects, cada proyecto debe tener un campo de relación hacia las habilidades que realmente se utilizaron. Esto te proporcionará datos objetivos sobre las capacidades de tu equipo basándote en lo que han construido realmente.
Sincroniza con GCP para validación continua
Aquí es donde se marca la diferencia entre un spreadsheet glorificado y un sistema real. Utiliza Cloud Functions para leer los logs de actividad de tu equipo y validar habilidades automáticamente. ¿Sabías que esto puede ahorrarte mucho tiempo?
from google.cloud import logging_v2
from notion_client import Client
import os
notion = Client(auth=os.environ["NOTION_TOKEN"])
logging_client = logging_v2.Client()
def validate_skills_from_activity(request):
# Lee logs de Vertex AI, Cloud Build, GKE
filter_str = 'resource.type="cloud_function" OR resource.type="gke_cluster"'
entries = logging_client.list_entries(filter_=filter_str, page_size=1000)
skill_signals = {
"vertexai.googleapis.com": "Vertex AI deployment",
"container.googleapis.com": "Kubernetes orchestration",
"cloudbuild.googleapis.com": "CI/CD for ML"
}
for entry in entries:
user_email = entry.payload.get('user_email')
service = entry.resource.type
if service in skill_signals:
# Actualiza última validación en Notion
update_skill_validation(user_email, skill_signals[service])
return {"status": "validated"}
Programa esta Cloud Function para que se ejecute diariamente. La idea aquí es que tus habilidades en Notion se validen automáticamente basándose en la actividad real en GCP, no en lo que la gente dice que sabe hacer.
Paso 2: Predice tus necesidades antes de que se conviertan en cuellos de botella
La mayoría de los equipos contratan de manera reactiva: el proyecto se atasca, alguien grita "necesitamos un data engineer" y comienzas a buscar. Honestamente, en el ámbito de IA, esta forma de proceder es perjudicial, ya que el tiempo entre "necesitamos a alguien" y "tenemos a alguien productivo" puede ser de 3 a 6 meses.
Construye tu modelo predictivo en BigQuery
Exporta tus datos de Notion a BigQuery automáticamente usando la API. Necesitas tres tablas principales:
projects_timeline: todos tus proyectos con fechas de inicio, finalización estimada y estado actual.
skills_required: relación entre proyectos y habilidades necesarias, incluyendo un campo de "intensity" (cuánto se necesita esa habilidad).
team_allocation: quién está trabajando en qué, con porcentaje de tiempo dedicado.
Ahora, el modelo predictivo:
-- Detecta gaps futuros de talento
WITH future_demand AS (
SELECT
sr.skill_name,
SUM(sr.intensity) as total_demand,
pt.estimated_end_date,
EXTRACT(MONTH FROM pt.estimated_end_date) as demand_month
FROM `project.dataset.projects_timeline` pt
JOIN `project.dataset.skills_required` sr
ON pt.project_id = sr.project_id
WHERE pt.estimated_end_date > CURRENT_DATE()
AND pt.status != 'cancelled'
GROUP BY skill_name, estimated_end_date, demand_month
),
current_capacity AS (
SELECT
sm.skill_name,
COUNT(DISTINCT tm.member_id) as available_experts,
AVG(ta.allocation_pct) as avg_allocation
FROM `project.dataset.team_members` tm
JOIN `project.dataset.skill_matrix` sm
ON tm.member_id = sm.member_id
LEFT JOIN `project.dataset.team_allocation` ta
ON tm.member_id = ta.member_id
WHERE sm.proficiency IN ('Advanced', 'Expert')
GROUP BY skill_name
)
SELECT
fd.skill_name,
fd.demand_month,
fd.total_demand,
COALESCE(cc.available_experts, 0) as current_experts,
COALESCE(cc.avg_allocation, 0) as current_utilization,
CASE
WHEN COALESCE(cc.available_experts, 0) = 0 THEN 'CRITICAL_GAP'
WHEN fd.total_demand > (cc.available_experts * (100 - cc.avg_allocation) / 100)
THEN 'HIRE_NEEDED'
ELSE 'COVERED'
END as status
FROM future_demand fd
LEFT JOIN current_capacity cc
ON fd.skill_name = cc.skill_name
ORDER BY fd.demand_month, fd.total_demand DESC;
Esta consulta te dice exactamente qué habilidades necesitarás, cuándo las necesitarás y si tu equipo actual puede cubrirlas. ¿No es genial?
Automatiza las alertas en Slack
Conecta BigQuery con Cloud Scheduler y Pub/Sub para ejecutar esta consulta semanalmente y enviar alertas a Slack cuando detecte brechas críticas:
from google.cloud import bigquery
from slack_sdk import WebClient
def detect_talent_gaps(event, context):
client = bigquery.Client()
query = """[la query anterior]"""
results = client.query(query)
slack_client = WebClient(token=os.environ["SLACK_TOKEN"])
for row in results:
if row.status in ['CRITICAL_GAP', 'HIRE_NEEDED']:
message = f"""
🚨 *Talent Gap Detected*
Skill: {row.skill_name}
Timeline: {row.demand_month}
Status: {row.status}
Current experts: {row.current_experts}
Projected need: {row.total_demand}
"""
slack_client.chat_postMessage(
channel="#hiring-alerts",
text=message
)
Ahora tienes la capacidad de saber de 2 a 3 meses antes de que enfrentes un problema de capacidad. Suficiente tiempo para actuar de manera proactiva.
Paso 3: Automatiza el skill mapping durante onboarding
Cuando alguien nuevo se une a tu equipo, el proceso típico es: llenan un formulario, alguien de HR lo transcribe a otro sistema y, tristemente, la mitad de la información técnica se pierde en la traducción. ¿No es frustrante?
Onboarding técnico automatizado en Notion
Crea una base de datos Onboarding Checklist que se auto-genera al agregar a alguien nuevo en Team Members. Utiliza las automatizaciones de Notion (2026 ya soporta esto nativamente):
- Trigger: cuando se crea un nuevo registro en Team Members
- Action: duplica un template de onboarding y lo asigna al manager
Pero aquí es donde viene el verdadero poder: conecta esto con un Google Form especializado que el nuevo hire deberá completar el primer día:
// Google Apps Script conectado al form
function onFormSubmit(e) {
const responses = e.values;
const email = responses[1];
const skills_claimed = responses[2].split(','); // lista de skills
const github_username = responses[3];
const portfolio_url = responses[4];
// Llama a Cloud Function para validar skills
const url = 'https://your-region-your-project.cloudfunctions.net/validate-onboarding';
const payload = {
email: email,
skills: skills_claimed,
github: github_username,
portfolio: portfolio_url
};
UrlFetchApp.fetch(url, {
method: 'post',
contentType: 'application/json',
payload: JSON.stringify(payload)
});
}
La Cloud Function realiza una tarea impresionante: analiza el GitHub del nuevo hire para validar las habilidades que dice poseer:
import requests
from github import Github
from notion_client import Client
def validate_onboarding(request):
data = request.get_json()
github_username = data['github']
claimed_skills = data['skills']
g = Github(os.environ["GITHUB_TOKEN"])
user = g.get_user(github_username)
# Analiza repos para detectar skills reales
skill_evidence = {}
for repo in user.get_repos(sort='updated')[:20]: # últimos 20 repos
languages = repo.get_languages()
if 'Python' in languages and 'tensorflow' in repo.get_contents('/').lower():
skill_evidence['TensorFlow'] = True
if 'requirements.txt' in [f.name for f in repo.get_contents('/')]:
# Analiza dependencias para detectar más skills
reqs = repo.get_contents('requirements.txt').decoded_content
if b'transformers' in reqs:
skill_evidence['Hugging Face Transformers'] = True
# Actualiza Notion con skills validadas
notion = Client(auth=os.environ["NOTION_TOKEN"])
# [código para actualizar el record del team member]
return {"validated_skills": skill_evidence}
El resultado es claro: el primer día, ya tienes un mapa técnico objetivo de lo que realmente sabe hacer tu nuevo hire, no solo lo que puso en su CV.
Paso 4: Implementa succession planning basado en grafos
Este es el paso que muchos pasan por alto, pero que puede salvarte cuando tu lead de ML engineering decide irse a OpenAI sin previo aviso.
Modela dependencias de conocimiento
En tu Skill Matrix de Notion, agrega un nuevo campo Critical Level (select): Low, Medium, High, Single Point of Failure. Es crucial marcar como "Single Point of Failure" cualquier habilidad que solo una persona en tu equipo domina y que es crítica para los proyectos actuales. Luego, establece una automatización en Notion que te alerte cuando:
- Alguien con habilidades marcadas como SPOF pide vacaciones de más de 2 semanas.
- Un empleado con 3 o más habilidades críticas cumple 18 meses en la empresa (un momento típico de rotación).
Visualiza el grafo de dependencias
Utiliza BigQuery y Data Studio (ahora Looker Studio) para visualizar el grafo de dependencias:
-- Identifica single points of failure
WITH skill_coverage AS (
SELECT
skill_name,
COUNT(DISTINCT member_id) as expert_count,
STRING_AGG(member_name) as experts
FROM `project.dataset.skill_matrix`
WHERE proficiency IN ('Advanced', 'Expert')
GROUP BY skill_name
),
critical_skills AS (
SELECT skill_name
FROM `project.dataset.skill_matrix`
WHERE critical_level = 'High'
)
SELECT
sc.skill_name,
sc.expert_count,
sc.experts,
CASE
WHEN sc.expert_count = 1 THEN 'IMMEDIATE_RISK'
WHEN sc.expert_count = 2 THEN 'HIGH_RISK'
ELSE 'ACCEPTABLE'
END as risk_level
FROM skill_coverage sc
JOIN critical_skills cs ON sc.skill_name = cs.skill_name
WHERE sc.expert_count < 3
ORDER BY sc.expert_count ASC, sc.skill_name;
Para cerrar, estas estrategias pueden parecer complejas, pero son clave para gestionar adecuadamente un equipo de IA en crecimiento. ¿Estás listo para implementar cambios y evitar cuellos de botella en tu talento?