When Your AI Team Grows Faster Than Your Ability to Manage It: Complete Notion + GCP Architecture

AI teams face a problem that no one anticipates: their asymmetrical growth. You hire a senior ML engineer and suddenly realize you need two data engineers. You bring on a research scientist and find you need three annotation specialists. And when you finally have everyone on board, confusion arises: who is working on what? What are the specific skills of your LLM engineers compared to your computer vision experts? And when will you need to add a reinforcement learning specialist?

Photo: Van Tay Media on Unsplash

Talent management in these teams doesn't resemble a traditional HR approach, even if it has a tech layer. Instead, it's about tracking very specific technical capabilities, documenting who can debug a Vertex AI pipeline and who knows how to optimize a Hugging Face model for production. Moreover, all of this needs to be synchronized with product sprints that change every two weeks. Notion can become your nervous system for managing this, but only if you connect it properly with Google Cloud to automate what truly matters: knowing your current talent, identifying gaps, and forecasting when you'll need more.

Step 1: Map Your Actual Roles (Not Just LinkedIn Job Titles)

A common mistake is transferring LinkedIn job titles directly into your database. "Machine Learning Engineer" doesn’t convey anything when you really need to know if that person can implement attention mechanisms from scratch or if they only use pre-trained APIs.

Build Your Technical Taxonomy from Capabilities

In Notion, I suggest creating a database called Skill Matrix with the following properties:

• Skill Name (title): "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): connect to another tools database
• Last Validated (date): date of last validation
• Market Demand (select): Low, Medium, High, Critical

Then, connect this to your Team Members database through a bidirectional relationship. Each person will have a multi-relational field pointing to their specific skills along with their proficiency level.

The critical point here is clear: don’t trust self-assessments. Instead, link this Skill Matrix to concrete outcomes. In the Projects database, each project should have a relationship field to the skills that were actually used. This will provide you with objective data about your team's capabilities based on what they've actually built.

Sync with GCP for Continuous Validation

This is where the difference between a glorified spreadsheet and a real system comes into play. Use Cloud Functions to read your team's activity logs and automatically validate skills. Did you know this can save you a lot of time?

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):
    # Read logs from 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:
            # Update last validation in Notion
            update_skill_validation(user_email, skill_signals[service])
    
    return {"status": "validated"}

Schedule this Cloud Function to run daily. The idea here is that your skills in Notion are validated automatically based on real activity in GCP, not on what people say they can do.

Step 2: Predict Your Needs Before They Become Bottlenecks

Photo: Nguyen Dang Hoang Nhu on Unsplash

Most teams hire reactively: the project stalls, someone shouts, "we need a data engineer," and you start searching. Honestly, in the AI space, this approach is detrimental, as the time between "we need someone" and "we have someone productive" can take 3 to 6 months.

Build Your Predictive Model in BigQuery

Automatically export your data from Notion to BigQuery using the API. You need three main tables:

projects_timeline: all your projects with start dates, estimated completion dates, and current status.

skills_required: relationship between projects and necessary skills, including an "intensity" field (how much that skill is needed).

team_allocation: who is working on what, with the percentage of time dedicated.

Now, the predictive model:

-- Detect future talent gaps
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;

This query tells you exactly what skills you will need, when you will need them, and whether your current team can cover them. Pretty neat, right?

Automate Alerts in Slack

Connect BigQuery with Cloud Scheduler and Pub/Sub to run this query weekly and send alerts to Slack when it detects critical gaps:

from google.cloud import bigquery
from slack_sdk import WebClient

def detect_talent_gaps(event, context):
    client = bigquery.Client()
    query = """[the previous query]"""
    
    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
            )

Now you have the ability to know 2 to 3 months ahead of time before facing a capacity problem. Enough time to act proactively.

Step 3: Automate Skill Mapping During Onboarding

When someone new joins your team, the typical process is: they fill out a form, someone from HR transcribes it into another system, and sadly, half of the technical information gets lost in translation. Frustrating, isn’t it?

Automated Technical Onboarding in Notion

Create an Onboarding Checklist database that auto-generates when adding someone new to Team Members. Use Notion’s automations (2026 already supports this natively):

• Trigger: when a new record is created in Team Members
• Action: duplicate an onboarding template and assign it to the manager

But here's where the real power comes in: link this to a specialized Google Form that the new hire must complete on their first day:

// Google Apps Script connected to the form
function onFormSubmit(e) {
  const responses = e.values;
  const email = responses[1];
  const skills_claimed = responses[2].split(','); // list of skills
  const github_username = responses[3];
  const portfolio_url = responses[4];
  
  // Call Cloud Function to validate 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)
  });
}

The Cloud Function does an impressive job: it analyzes the new hire's GitHub to validate the skills they claim to possess:

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)
    
    # Analyze repos to detect real skills
    skill_evidence = {}
    for repo in user.get_repos(sort='updated')[:20]:  # last 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('/')]:
            # Analyze dependencies to detect more skills
            reqs = repo.get_contents('requirements.txt').decoded_content
            if b'transformers' in reqs:
                skill_evidence['Hugging Face Transformers'] = True
    
    # Update Notion with validated skills
    notion = Client(auth=os.environ["NOTION_TOKEN"])
    # [code to update the team member's record]
    
    return {"validated_skills": skill_evidence}

The result is clear: on their first day, you already have an objective technical map of what your new hire can really do, not just what they put on their resume.

Step 4: Implement Succession Planning Based on Graphs

This is the step that many overlook, but it can save you when your ML engineering lead decides to jump ship for OpenAI without warning.

Model Knowledge Dependencies

In your Notion Skill Matrix, add a new field Critical Level (select): Low, Medium, High, Single Point of Failure. It’s crucial to mark any skill that only one person on your team masters and that is critical for current projects as "Single Point of Failure." Then, set up an automation in Notion to alert you when:

• Someone with skills marked as SPOF requests vacation for more than 2 weeks.
• An employee with 3 or more critical skills hits their 18-month mark at the company (a typical turnover point).

Visualize the Dependency Graph

Use BigQuery and Data Studio (now Looker Studio) to visualize the dependency graph:

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

To wrap up, these strategies may seem complex, but they are key to effectively managing a growing AI team. Are you ready to implement changes and avoid talent bottlenecks?