Your AI team has grown from three to eighteen people in just four months. However, within this expansion, there are two researchers who still do not appear on the official org chart. Additionally, you have a brilliant freelancer in Singapore who is collaborating on three projects simultaneously. Recently, you spent two weeks trying to reconstruct who reviewed which version of the classification model. Sound familiar? This isn't a traditional human resources problem; it's an information architecture challenge.
Photo: Van Tay Media on Unsplash
Talent management in AI teams is unique. It's not limited to hiring, conducting one-on-ones, and performance reviews. It’s about tracking which model each engineer has worked on, what datasets each researcher is familiar with, who can debug that training pipeline if it fails at 3 AM, and how to preserve institutional memory when the turnover rate is 30% annually. You need a digital nervous system that connects people, projects, and production in real-time.
Why Traditional HR Systems Don't Work for AI Teams
BambooHR and Workday are tools designed for companies where roles are stable and org charts make sense for more than six months. In contrast, in an AI startup, your "ML Engineer" from January might be leading research on transformer models in March and designing serving infrastructure in May. Be careful with this; it’s crucial.
Traditional HR systems conceive of fixed roles. What your AI team truly needs is to track dynamic capabilities. The difference here is not just semantic; it’s structural. When one of your researchers publishes a paper on attention mechanisms, that knowledge must instantly propagate to projects that could benefit from it. Interestingly, when someone solves a specific TensorRT problem in production, that expertise needs to be documented and easily accessible.
The real issue is the disconnection between the technical and human contexts. The former resides in platforms like GitHub, Slack, and Google Cloud logs, while the latter typically exists in your HR system, if you have one. This fragmentation costs you money: you rediscover already solved problems, misallocate talent, and lose critical knowledge every time someone leaves.
The Hidden Cost of Fragmentation
In a recent audit with a 25-person computer vision startup, we discovered they had wasted 140 engineer-hours resolving a data augmentation problem that someone had tackled eight months earlier. The person who solved the issue was still working there. However, the knowledge simply lived in a Jupyter notebook in their personal GCS directory. This is not an isolated case; honestly, it has become the norm.
The Architecture: Notion as Intelligence Layer, GCP as Execution Layer
Photo: Nguyen Dang Hoang Nhu on Unsplash
The solution doesn’t lie in buying more HR software. The key is to build an information architecture that reflects how your team really functions.
Notion becomes your relational talent database: it connects people, skills, projects, models, and documentation. It’s not just a glorified wiki; it’s an internal CRM where each person becomes a record with dynamic properties that automatically update based on their actual activity.
On the other hand, Google Cloud Platform provides the data on technical activity: what models each person is training (Cloud AI Platform), what code they are committing (Cloud Source Repositories or your synced GitHub), what resources they are consuming (Cloud Monitoring), and what errors they encounter (Error Reporting).
The real magic happens in the integration: Cloud Functions pipelines read activity from GCP and automatically update profiles in Notion. Thus, your talent management system transitions from a quarterly updated spreadsheet to a real-time dashboard.
Key Components of the Architecture
1. Skills Database in Notion with three categories:
- Technical hard skills (frameworks, languages, architectures).
- Domain expertise (computer vision, NLP, recommendation systems).
- Operational capabilities (deployment, monitoring, specific debugging).
Each skill has a confidence level (self-reported, peer-validated, production-proven) and timestamps for the last update, which is vital.
2. Project-Person Relations that track:
- Active participation in which models/projects.
- Measured contributions (commits, reviews, executed experiments).
- Ownership of specific components.
- Expertise gained during the project.
3. Integration Layer in GCP that includes:
- Cloud Functions that listen to events from Cloud Build, AI Platform, BigQuery.
- Firestore as an intermediate activity cache.
- Cloud Scheduler for periodic synchronizations.
- Pub/Sub for real-time change propagation.
Step-by-Step Implementation: From Zero to Functional System in a Week
Days 1-2: Base Structure in Notion
Create three fundamental databases:
People Database with properties:
- Full Name (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:
- Project Name (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)
Make sure to set up bidirectional relations. This is crucial: when adding a skill to a person, it should automatically appear in the "People with this skill" list in the Skills Database.
Days 3-4: Synchronization Pipeline from GCP
Create a Cloud Function in Python that triggers daily:
import functions_framework
from google.cloud import monitoring_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 by user
client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{os.environ['GCP_PROJECT_ID']}"
# AI Platform job activity
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. Process activity by user
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. Update 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 person in Notion by 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']
# Update 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)}
Deploy with:
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=your-project
Set up Cloud Scheduler to run it daily:
gcloud scheduler jobs create http sync-daily \
--schedule="0 2 * * *" \
--uri="https://REGION-PROJECT.cloudfunctions.net/sync-notion-activity" \
--http-method=GET
Days 5-6: Automatic Skill Detection from Code
Implement a second pipeline that analyzes recent commits and detects the use of 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 by Cloud Build when there is a new 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 commit diff (simplified; in production, use Cloud Source Repositories API)
diff_content = fetch_commit_diff(repo_name, commit_sha)
# Detect used skills
detected_skills = []
for skill, pattern in SKILL_PATTERNS.items():
if re.search(pattern, diff_content):
detected_skills.append(skill)
# Update Notion if there are new skills
if detected_skills:
update_person_skills(author_email, detected_skills)
return {"detected_skills": detected_skills}
Day 7: Dashboard and Automations
Create views in Notion that provide actionable insights:
View "Model Owners": filter Projects DB by Status = "Production", group by Team Members, and show which models in production depend on each person. This answers the question: "What happens if this person leaves tomorrow?"
View "Skill Gaps": compare the skills required in active projects with those available in the current team. In my experience, a formula in Notion could be:
if(empty(prop("Team Members")), "❌ No assigned",
if(length(prop("Team Members")) < 2, "⚠️ Single point of failure", "✅ Covered"))
View "Rising Stars": sort People DB by declining Activity Score from the last 30 days. Identify who is delivering the most.
Advanced Use Cases: From Passive Tracking to Active Intelligence
Once you have the base system, you can build automations that transform reactive management into predictive management.
Knowledge Risk Alerts
A Cloud Function that runs weekly and detects:
- Production projects with a single active owner in the last 30 days.
- Critical skills that only one person possesses (according to the Skills Database).
- High-activity individuals who do not have documented backup.
These alerts can be sent to Slack with actionable context: "The recommendations model solely depends on @maria. Consider pair programming with @carlos in the next sprint."
Intelligent Onboarding
When you add a new person to the People Database, an automatic workflow:
- Detects which projects need their skills (cross-referencing Skills vs. Project requirements).
- Identifies potential mentors (people with similar skills + experience + high Activity Score).
- Generates a personalized onboarding document in Notion with:
- Recommended projects to contribute to.
- Key people to know.
- Relevant documentation based on their skills.
- Production models they could help maintain.
Knowledge Preservation During Offboarding
When someone changes their status to "Leaving," it triggers an automatic checklist that:
- Lists all projects where they are the sole owner.
- Identifies missing documentation (projects without README, for example).