Tu equipo de IA ha crecido de tres a dieciocho personas en solo cuatro meses. Sin embargo, dentro de esta expansión, hay dos investigadores que aún no aparecen en el organigrama oficial. Además, cuentas con un freelance brillante en Singapur que colabora en tres proyectos a la vez. Recientemente, perdiste dos semanas intentando reconstruir quién revisó qué versión del modelo de clasificación. ¿Te suena familiar? Este no es un problema de recursos humanos tradicional: es un desafío de arquitectura de información.
La gestión de talento en equipos de IA es única. No se limita a contratar, realizar one-on-ones y revisar el rendimiento. Se trata de hacer un seguimiento de qué modelo ha tocado cada ingeniero, qué datasets conoce cada investigador, quién puede depurar ese pipeline de entrenamiento si falla a las 3 AM y cómo preservar la memoria institucional cuando la tasa de rotación es del 30% anual. Necesitas un sistema nervioso digital que conecte personas, proyectos y producción en tiempo real.
Por qué los sistemas tradicionales de HR no funcionan para equipos de IA
BambooHR y Workday son herramientas pensadas para empresas donde las funciones son estables y los organigramas tienen sentido por más de seis meses. En contraste, en una startup de IA, tu "ML Engineer" de enero podría estar liderando investigación en transformer models en marzo y diseñando infraestructura de serving en mayo. Ojo con esto, es clave.
Los sistemas tradicionales de HR conciben roles fijos. Lo que tu equipo de IA realmente necesita es rastrear capacidades dinámicas. La diferencia aquí no es solo semántica: es estructural. Cuando uno de tus investigadores publica un paper sobre attention mechanisms, ese conocimiento debe propagarse al instante a los proyectos que podrían beneficiarse. Lo curioso es que, cuando alguien resuelve un problema específico de TensorRT en producción, esa expertise debe quedar documentada y ser fácilmente accesible.
El verdadero problema es la desconexión entre el contexto técnico y el humano. El primero vive en plataformas como GitHub, Slack y Google Cloud logs, mientras que el segundo suele estar en tu sistema de HR, si es que tienes uno. Esta fragmentación te cuesta dinero: redescubres problemas ya resueltos, asignas mal el talento y pierdes conocimiento crítico cada vez que alguien se va.
El coste oculto de la fragmentación
En una auditoría reciente con una startup de computer vision de 25 personas, descubrimos que habían desperdiciado 140 horas-ingeniero resolviendo un problema de data augmentation que alguien había abordado ocho meses antes. La persona que había resuelto el problema seguía trabajando allí. Sin embargo, el conocimiento simplemente vivía en un Jupyter notebook en su directorio personal de GCS. Esto no es un caso aislado. Honestamente, se ha convertido en la norma.
La arquitectura: Notion como capa de inteligencia, GCP como capa de ejecución
La solución no radica en comprar más software de HR. La clave está en construir una arquitectura de información que refleje cómo realmente funciona tu equipo.
Notion se convierte en tu base de datos relacional de talento: conecta personas, habilidades, proyectos, modelos y documentación. No es un simple wiki glorificado. Es un CRM interno en el que cada persona se convierte en un registro con propiedades dinámicas que se actualizan automáticamente basándose en su actividad real.
Por otro lado, Google Cloud Platform proporciona los datos de actividad técnica: qué modelos entrena cada persona (Cloud AI Platform), qué código commitean (Cloud Source Repositories o tu GitHub sincronizado), qué recursos consumen (Cloud Monitoring), y qué errores encuentran (Error Reporting).
La verdadera magia ocurre en la integración: pipelines de Cloud Functions que leen actividad de GCP y actualizan automáticamente los perfiles en Notion. Así, tu sistema de gestión de talento deja de ser una hoja de cálculo que actualizas trimestralmente y se transforma en un dashboard en tiempo real.
Componentes clave de la arquitectura
1. Skills Database en Notion con tres categorías:
- Hard skills técnicas (frameworks, lenguajes, arquitecturas).
- Domain expertise (computer vision, NLP, recommendation systems).
- Operational capabilities (deployment, monitoring, debugging específico).
Cada habilidad tiene un nivel de confianza (self-reported, peer-validated, production-proven) y timestamps de última actualización, lo cual es vital.
2. Project-Person Relations que rastrean:
- Participación activa en qué modelos/proyectos.
- Contribuciones medidas (commits, reviews, experimentos ejecutados).
- Ownership de componentes específicos.
- Expertise adquirida durante el proyecto.
3. Integration Layer en GCP que incluye:
- Cloud Functions que escuchan eventos de Cloud Build, AI Platform, BigQuery.
- Firestore como caché intermedio de actividad.
- Cloud Scheduler para sincronizaciones periódicas.
- Pub/Sub para la propagación de cambios en tiempo real.
Implementación paso a paso: de cero a sistema funcional en una semana
Día 1-2: Estructura base en Notion
Crea tres bases de datos fundamentales:
People Database con propiedades:
- Nombre completo (Title)
- Email (Email)
- Current Projects (Relation → Projects DB)
- Skills (Multi-select)
- Skill Details (Relation → Skills DB)
- GCP User ID (Text)
- GitHub Username (Text)
- Last Activity Sync (Date)
- Activity Score (Number, auto-calculated)
Projects Database:
- Nombre del proyecto (Title)
- Status (Select: Active, Paused, Production, Deprecated)
- Team Members (Relation → People DB)
- Related Models (Relation → Models DB)
- GCP Project ID (Text)
- Repository URL (URL)
- Last Model Training (Date)
Skills Database:
- Skill Name (Title)
- Category (Select: Framework, Domain, Operational)
- People with this skill (Relation → People DB)
- Validation Level (Select: Self-reported, Peer-validated, Production-proven)
- Last Used (Date)
Asegúrate de configurar las relaciones bidireccionales. Esto es fundamental: al agregar una habilidad a una persona, debe aparecer automáticamente en la lista de "People with this skill" en la Skills Database.
Día 3-4: Pipeline de sincronización desde GCP
Crea un Cloud Function en Python que se active diariamente:
import functions_framework
from google.cloud import monitoring_v3
from google.cloud import resourcemanager_v3
import requests
import os
from datetime import datetime, timedelta
NOTION_TOKEN = os.environ['NOTION_TOKEN']
NOTION_PEOPLE_DB = os.environ['NOTION_PEOPLE_DB_ID']
@functions_framework.http
def sync_activity(request):
# 1. Query GCP activity por usuario
client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{os.environ['GCP_PROJECT_ID']}"
# Actividad de AI Platform jobs
interval = monitoring_v3.TimeInterval({
"end_time": {"seconds": int(datetime.now().timestamp())},
"start_time": {"seconds": int((datetime.now() - timedelta(days=7)).timestamp())},
})
results = client.list_time_series(
request={
"name": project_name,
"filter": 'metric.type = "ml.googleapis.com/job/completed_count"',
"interval": interval,
}
)
# 2. Procesar actividad por usuario
user_activity = {}
for result in results:
user_email = result.metric.labels.get('user_email')
if user_email:
if user_email not in user_activity:
user_activity[user_email] = 0
user_activity[user_email] += 1
# 3. Actualizar Notion
headers = {
"Authorization": f"Bearer {NOTION_TOKEN}",
"Content-Type": "application/json",
"Notion-Version": "2022-06-28"
}
for email, activity_count in user_activity.items():
# Query persona en Notion por email
query_response = requests.post(
f"https://api.notion.com/v1/databases/{NOTION_PEOPLE_DB}/query",
headers=headers,
json={"filter": {"property": "Email", "email": {"equals": email}}}
)
pages = query_response.json().get('results', [])
if pages:
page_id = pages[0]['id']
# Actualizar Activity Score
requests.patch(
f"https://api.notion.com/v1/pages/{page_id}",
headers=headers,
json={
"properties": {
"Activity Score": {"number": activity_count},
"Last Activity Sync": {"date": {"start": datetime.now().isoformat()}}
}
}
)
return {"status": "synced", "users_updated": len(user_activity)}
Despliega con:
gcloud functions deploy sync-notion-activity \
--runtime python311 \
--trigger-http \
--entry-point sync_activity \
--set-env-vars NOTION_TOKEN=secret_xxx,NOTION_PEOPLE_DB_ID=xxx,GCP_PROJECT_ID=tu-proyecto
Configura Cloud Scheduler para ejecutarlo diariamente:
gcloud scheduler jobs create http sync-daily \
--schedule="0 2 * * *" \
--uri="https://REGION-PROJECT.cloudfunctions.net/sync-notion-activity" \
--http-method=GET
Día 5-6: Detección automática de habilidades desde el código
Implementa un segundo pipeline que analiza commits recientes y detecta el uso de frameworks:
import functions_framework
from google.cloud import aiplatform
import requests
import re
import os
SKILL_PATTERNS = {
'TensorFlow': r'import tensorflow|from tensorflow',
'PyTorch': r'import torch|from torch',
'Hugging Face': r'from transformers|import transformers',
'scikit-learn': r'from sklearn|import sklearn',
'BigQuery ML': r'CREATE MODEL|ML\.PREDICT',
'Vertex AI': r'aiplatform\.|VertexAI',
}
@functions_framework.cloud_event
def detect_skills_from_commit(cloud_event):
# Triggered por Cloud Build cuando hay nuevo commit
commit_data = cloud_event.data
repo_name = commit_data['substitutions']['REPO_NAME']
commit_sha = commit_data['substitutions']['COMMIT_SHA']
author_email = commit_data['substitutions']['_AUTHOR_EMAIL']
# Fetch diff del commit (simplificado, en prod usa Cloud Source Repositories API)
diff_content = fetch_commit_diff(repo_name, commit_sha)
# Detectar habilidades utilizadas
detected_skills = []
for skill, pattern in SKILL_PATTERNS.items():
if re.search(pattern, diff_content):
detected_skills.append(skill)
# Actualizar Notion si hay habilidades nuevas
if detected_skills:
update_person_skills(author_email, detected_skills)
return {"detected_skills": detected_skills}
Día 7: Dashboard y automatizaciones
Crea vistas en Notion que te proporcionen insights accionables:
Vista "Model Owners": filtra Projects DB por Status = "Production", agrupa por Team Members y muestra qué modelos en producción dependen de cada persona. Esto responde a la pregunta: "¿Qué pasa si esta persona se va mañana?"
Vista "Skill Gaps": compara las habilidades requeridas en proyectos activos con las disponibles en el equipo actual. En mi experiencia, una fórmula en Notion podría ser:
if(empty(prop("Team Members")), "❌ No assigned",
if(length(prop("Team Members")) < 2, "⚠️ Single point of failure", "✅ Covered"))
Vista "Rising Stars": ordena People DB por Activity Score decreciente de los últimos 30 días. Identifica quién está entregando más.
Casos de uso avanzados: de tracking pasivo a inteligencia activa
Una vez que tienes el sistema base, puedes construir automatizaciones que transforman la gestión reactiva en gestión predictiva.
Alertas de riesgo de conocimiento
Cloud Function que se ejecuta semanalmente y detecta:
- Proyectos en producción con un único owner activo en los últimos 30 días.
- Habilidades críticas que solo posee una persona (según la Skills Database).
- Personas con alta actividad que no tienen un respaldo documentado.
Estas alertas se pueden enviar a Slack con contexto accionable: "El modelo de recommendations depende exclusivamente de @maria. Considera pair programming con @carlos en el próximo sprint."
Onboarding inteligente
Cuando agregas una persona nueva a la People Database, un workflow automático:
- Detecta qué proyectos tienen necesidad de sus habilidades (cruza Skills vs. Project requirements).
- Identifica mentores potenciales (personas con habilidades similares + experiencia + alta Activity Score).
- Genera un documento de onboarding personalizado en Notion con:
- Proyectos recomendados para contribuir.
- Personas clave para conocer.
- Documentación relevante según sus habilidades.
- Modelos en producción que podría ayudar a mantener.
Preservación del conocimiento durante offboarding
Cuando alguien cambia su estado a "Leaving", activa un checklist automático que:
- Lista todos los proyectos donde es el único owner.
- Identifica documentación faltante (proyectos sin README, por ejemplo).