---
title: Software that ran a 377-person program
subtitle: The operations platform behind a
human-driven SFT agent-trace program
for a frontier AI lab
slug: operations-platform-377
hook: 131 Python scripts, about 34,000 lines,
and a FastAPI + React/TypeScript
review app. A handful of leads ran hundreds
of people from one source of
truth.
role: Team Lead (377 people) and builder of
the program's operations platform
employer: Turing (contract, remote)
client: A frontier AI lab
period: Mar – May 2026
tracks:
- full-stack-fde
- evaluation
- mlops
tags:
- operations automation
- FastAPI
- React
- TypeScript
- Google Workspace APIs
- team leadership
- SFT data
metrics:
- value: "377"
label: People in the program I led,
including 309 trainers and 26 pod
leads
when: Mar – May 2026
- value: "131"
label: Python scripts (about 34,000 lines)
running onboarding, delivery and
dashboards
when: Mar – May 2026
- value: ~3,500
label: Lines in the FastAPI +
React/TypeScript review app prototype
when: Feb – May 2026
---
## Context
A frontier AI lab wanted supervised
fine-tuning data: annotated traces of
agents doing real work, with a target of
10,000–20,000 of them. Producing that
takes people. In this program, 377 of
them, including 309 trainers and 26 pod
leads. From March to May 2026 I was the
Team Lead.
The job was half people, half plumbing. This
case study is about the plumbing.
## The problem
At that size, annotation isn't the hard part.
The hard part is knowing, today, who is
onboarded, who has access, what was
delivered, what passed review and who
needs help, across 26 pods. The work lived
in spreadsheets, and nobody could see
across all of them at once.
## Constraints
- **Google Sheets and Drive were the system of
record.** The platform had to work with
them, not replace them overnight.
- **People arrived in waves:** 29 onboarding
batches, each needing access and sandbox
accounts.
- **Quality had to hold while headcount
grew.** More people can mean more noise.
## What I built
**131 Python scripts, about 34,000 lines, on
the Google Sheets and Drive APIs.** They
covered:
- **Onboarding** for 29 batches.
- **Sandbox account provisioning** for the
people doing the work.
- **A delivery master** across 26 pod sheets:
one view of what every pod had delivered.
- **Performance dashboards** for pod leads and
for me.
**A review app.** Earlier in the same lab's
benchmark program (case study 03), I
prototyped a review application with
FastAPI, SQLAlchemy, React and TypeScript,
about 3,500 lines. The idea: reviewers
work from a queue with a real database
behind it, not from a spreadsheet tab.
## How it fits together
Sheets stay the record. Python does the work.
A new batch of trainers goes through the
onboarding scripts, which also provision
sandbox accounts. Each pod works in its
own sheet. The delivery master pulls from
all 26 pod sheets into one view, and
dashboards read the master. Pod leads and
I act on the dashboards: fix, coach,
reassign.
The review app sits beside this as a prototype
path: the same data, served through a
FastAPI and SQLAlchemy backend to a
React/TypeScript front end, for the day
the spreadsheets stop scaling.
## Stack
- **Automation:** Python, gspread, the Google
Sheets API, the Google Drive API, pandas.
- **App:** FastAPI, SQLAlchemy, React,
TypeScript.
- **Delivery:** Git and GitHub.
## Results
- **377 people run from one source of truth**,
on 131 scripts I built.
- **29 onboarding batches** and **a delivery
master across 26 pod sheets**, without a
spreadsheet war.
- **A handful of leads could run hundreds of
contributors**, because the questions they
asked every morning already had answers.
- **A review-app prototype** of about 3,500
lines, ready to replace the spreadsheet
queue.
## What I'd do differently
- **Move the record into a database sooner.**
Sheets were the right start, because
everyone already used them. By 26 pod
sheets, the master belonged in Postgres
with the review app on top and Sheets as
read-only views.
- **Treat 131 scripts as a platform.** They
deserved what a platform gets: shared
modules, logging, alerts and tests. I'd
refactor toward fewer, bigger pieces
earlier.
- **Make dry runs the default.** In the
benchmark program, QA write-back always
ran dry before it wrote. Every script that
writes to a shared sheet should work that
way, through one shared library rather
than per-script care.
- **Ship dashboards people can't misread.**
Every number on a performance dashboard
needs its definition one click away,
especially when people's work is being
measured.
## What I left out
This is client work under NDA. Not included,
on purpose:
- the lab's name and the program's internal
name;
- the traces, the annotation guidelines and
any task content;
- trainers' identities and performance data;
- sheet structures, the scripts' code and the
review app's code.
## How to verify
- **LinkedIn project** "Operations platform
for a 377-person AI data program (FastAPI
+ React/TypeScript)" (Turing, Mar – May
2026), pinned on the profile: the 131
Python scripts (~34K lines) and the
review-app prototype (~3,500 lines).
- **LinkedIn About:** led a 377-person AI data
program.
- **Employment check:** Turing, official title
Consultant, contract, Mar 2024 – present.
- **In an interview:** a walk-through of the
method, within NDA limits.
- **Code:** walkthroughs available on request.
Case study 05 · Turing (contract, remote) · Mar – May 2026
Software that ran a 377-person program
The operations platform behind a human-driven SFT agent-trace program for a frontier AI lab
131 Python scripts, about 34,000 lines, and a FastAPI + React/TypeScript review app. A handful of leads ran hundreds of people from one source of truth.
✓ Compiled from this page's own markdown.
Context
A frontier AI lab wanted supervised fine-tuning data: annotated traces of agents doing real work, with a target of 10,000–20,000 of them. Producing that takes people. In this program, 377 of them, including 309 trainers and 26 pod leads. From March to May 2026 I was the Team Lead.
The job was half people, half plumbing. This case study is about the plumbing.
The problem
At that size, annotation isn't the hard part. The hard part is knowing, today, who is onboarded, who has access, what was delivered, what passed review and who needs help, across 26 pods. The work lived in spreadsheets, and nobody could see across all of them at once.
Constraints
- Google Sheets and Drive were the system of record. The platform had to work with them, not replace them overnight.
- People arrived in waves: 29 onboarding batches, each needing access and sandbox accounts.
- Quality had to hold while headcount grew. More people can mean more noise.
What I built
131 Python scripts, about 34,000 lines, on the Google Sheets and Drive APIs. They covered:
- Onboarding for 29 batches.
- Sandbox account provisioning for the people doing the work.
- A delivery master across 26 pod sheets: one view of what every pod had delivered.
- Performance dashboards for pod leads and for me.
A review app. Earlier in the same lab's benchmark program (case study 03), I prototyped a review application with FastAPI, SQLAlchemy, React and TypeScript, about 3,500 lines. The idea: reviewers work from a queue with a real database behind it, not from a spreadsheet tab.
How it fits together
Sheets stay the record. Python does the work.
A new batch of trainers goes through the onboarding scripts, which also provision sandbox accounts. Each pod works in its own sheet. The delivery master pulls from all 26 pod sheets into one view, and dashboards read the master. Pod leads and I act on the dashboards: fix, coach, reassign.
The review app sits beside this as a prototype path: the same data, served through a FastAPI and SQLAlchemy backend to a React/TypeScript front end, for the day the spreadsheets stop scaling.
Stack
- Automation: Python, gspread, the Google Sheets API, the Google Drive API, pandas.
- App: FastAPI, SQLAlchemy, React, TypeScript.
- Delivery: Git and GitHub.
Results
- 377 people run from one source of truth, on 131 scripts I built.
- 29 onboarding batches and a delivery master across 26 pod sheets, without a spreadsheet war.
- A handful of leads could run hundreds of contributors, because the questions they asked every morning already had answers.
- A review-app prototype of about 3,500 lines, ready to replace the spreadsheet queue.
What I'd do differently
- Move the record into a database sooner. Sheets were the right start, because everyone already used them. By 26 pod sheets, the master belonged in Postgres with the review app on top and Sheets as read-only views.
- Treat 131 scripts as a platform. They deserved what a platform gets: shared modules, logging, alerts and tests. I'd refactor toward fewer, bigger pieces earlier.
- Make dry runs the default. In the benchmark program, QA write-back always ran dry before it wrote. Every script that writes to a shared sheet should work that way, through one shared library rather than per-script care.
- Ship dashboards people can't misread. Every number on a performance dashboard needs its definition one click away, especially when people's work is being measured.
What I left out
This is client work under NDA. Not included, on purpose:
- the lab's name and the program's internal name;
- the traces, the annotation guidelines and any task content;
- trainers' identities and performance data;
- sheet structures, the scripts' code and the review app's code.
How to verify
- LinkedIn project "Operations platform for a 377-person AI data program (FastAPI + React/TypeScript)" (Turing, Mar – May 2026), pinned on the profile: the 131 Python scripts (~34K lines) and the review-app prototype (~3,500 lines).
- LinkedIn About: led a 377-person AI data program.
- Employment check: Turing, official title Consultant, contract, Mar 2024 – present.
- In an interview: a walk-through of the method, within NDA limits.
- Code: walkthroughs available on request.