Who to Call When the Model Starts Demanding a Raise: Core Roles on AI Teams

You scoped the project, ran prioritization frameworks, and even survived a vendor pilot evaluation. Congratulations — you now own a roadmap and the delightful responsibility of building the team that’ll actually deliver it.

This piece builds directly on Choosing and Scoping AI Projects (you remember — selecting high-impact, feasible projects and defining success). Now we take the natural next step: who actually turns that scoped idea into a repeatable product. Spoiler: it takes a small village, a bit of orchestration, and someone who understands both cloud bills and human feelings.

---

Why roles matter (and no, you can't just hire 'an AI person')

If your project is a play, the previous module gave you the script and stage. Now you need the cast and crew. The wrong mix leads to beautiful proofs of concept that never leave notebooks, or to production pipelines that break during business hours with nobody to blame.

Think of roles as functions that reduce three big risks: data risk (bad input, unlabeled chaos), model risk (overfit, wrong objective), and operational risk (security, cost, reliability).

---

Core roles (the ones you actually need) — starring cast and backstage heroes

Below are the core roles for most AI projects. For each: what they do, how they measure success, and when to involve them.

1) AI/Product Manager (PM)

• What: Translates business goals into ML success metrics, prioritizes features, coordinates stakeholders.
• KPI: Clear success criteria (precision/recall targets, business ROI), roadmap milestones hit.
• When: From day zero — ties back to your prioritization frameworks and roadmap.

2) Data Engineer

• What: Ingests, cleans, transforms, and warehouses data. Makes data available reproducibly.
• KPI: Data freshness, ETL latency, percent of data covered by tests.
• When: Early — without good data, nothing else works.

3) ML Engineer / Research Scientist

• What: Experiments with model architectures, trains models, evaluates performance.
• KPI: Model metrics on validation/test sets and experiments reproducibility.
• When: Once data is accessible and the PM has defined success criteria.

4) MLOps / Platform Engineer

• What: Deploys models, sets up CI/CD for models, monitoring, and certification for production readiness.
• KPI: Deployment frequency, mean time to recovery (MTTR), inference latency and uptime.
• When: Before first production run. Prefer earlier involvement to design for deployability.

5) Software Engineer (Backend/Frontend)

• What: Integrates model endpoints into product, builds interfaces, scales systems.
• KPI: API reliability, feature lead time, user-facing latency.
• When: With product scoping — need to align product hooks with model outputs.

6) UX / ML Designer

• What: Designs human-AI interactions, error states, and feedback loops (think: what happens when model is wrong?).
• KPI: Task completion rates, user satisfaction, reduced misinterpretation incidents.
• When: Early in scoping to prevent bad UX decisions that no retraining will fix.

7) Business Subject Matter Expert (SME)

• What: Provides domain knowledge, defines edge cases, validates outputs.
• KPI: Reduction of false positives in domain-critical scenarios.
• When: Always — especially during labeling and evaluation.

8) Data Labeling / Annotation Lead

• What: Designs labeling schema, manages quality control, scales annotations.
• KPI: Inter-annotator agreement, label quality score, cost per label.
• When: Before training datasets are finalized.

9) Security / Privacy / Legal (Ethics Lead)

• What: Ensures compliance (GDPR/CCPA), threat modeling, fairness checks.
• KPI: Compliance sign-offs, incidence of privacy breaches, bias audit results.
• When: From scoping through production — legal often needs runway for audits.

10) Analytics & Monitoring Specialist

• What: Builds dashboards, monitors model drift, telemetry for product/ML metrics.
• KPI: Time to detect drift, number of detected production issues.
• When: Before first production inference — retroactive monitoring is useless.

---

Quick reference table: who does what

Role	Core skills	Key deliverable	When to involve
AI/Product Manager	Strategy, metric design	Success criteria & roadmap	Day 0
Data Engineer	ETL, SQL, pipelines	Clean, versioned datasets	Early
ML Engineer	Modeling, experiments	Trained models & notebooks	After data access
MLOps Engineer	CI/CD, infra, Kubeflow	Deployment & monitor pipelines	Pre-prod
Software Engineer	APIs, scaling	Integrated product feature	From scoping
UX / ML Designer	Research, prototyping	Usable AI flows	Early
SME	Domain expertise	Validation & rules	Always
Label Lead	Ops, QA	High-quality labels	Before training
Ethics/Legal	Policy, audits	Compliance reports	From scoping
Analytics	Dashboards, ML metrics	Drift & performance dashboards	Pre-prod

---

How these roles interact — a tiny RACI to stop blame games

Task                | PM | Data Eng | ML Eng | MLOps | SWE | UX | SME | Legal
--------------------|----|---------:|-------:|------:|----:|----|-----:|-----:
Define success      | A  |    C     |   C    |   C   |  C  | R  |  I   |  I
Data pipeline build | I  |    A     |   C    |   C   |  I  | I  |  R   |  I
Model training      | I  |    C     |   A    |   C   |  I  | C  |  R   |  I
Deploy to prod      | I  |    C     |   C    |   A   |  R  | I  |  I   |  C
Monitoring & alert  | I  |    C     |   R    |   A   |  I  | I  |  I   |  C

Legend: A = Accountable, R = Responsible, C = Consulted, I = Informed

---

Team sizing patterns: pilot vs production

• Small pilot (startup or vendor pilot): PM + Data Engineer (part-time) + ML Engineer + 1 SME. UX & MLOps lean or outsourced.
• Production (enterprise): Full cast: PM, Data Eng team, ML Eng team, MLOps, SWE, UX, Legal, Monitoring. Expect cross-functional pods per product line.

Tip: when you did vendor pilot evaluation, you probably outsourced some infra. If vendor remains, re-evaluate which roles become internal (e.g., MLOps, Security).

---

Practical questions to decide hiring priorities

• Do you have reliable, labeled data? If no → hire Data Engineer + Label Lead.
• Is deployment trivial (batch) or real-time? Real-time -> prioritize MLOps + SWE.
• Is model performance business-critical? If yes -> SME + Ethics early.
• Do you plan a fast vendor-to-internal transition? If yes -> hire Platform/MLOps before sunset.

Ask these as part of your roadmap tasks — aligning roles with milestones from your prioritization framework reduces wasted hires.

---

Closing: TL;DR and the one weird trick

• Core idea: AI projects fail when roles are mismatched to risks. Hire for the risks your roadmap exposes.
• Minimum viable cast for a meaningful pilot: PM + Data Engineer + ML Engineer + SME. Add MLOps/SWE/UX when you plan to ship.
• Favorite rule of thumb: involve the person who will be blamed for a failure before the failure happens (hint: usually MLOps, Legal, or PM).

Final thought: models are math; products are people. Build a team that speaks both languages.

---

Version: "The No-Chill Breakdown of AI Team Roles"