Syed Saqib AI-first. Full-stack. Forward-deployed. Data scientist.

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.

Role
Team Lead (377 people) and builder of the program's operations platform
Client
A frontier AI lab
When
Mar – May 2026
Tracks
Full-stack & FDE · Evaluation · MLOps

Clients anonymized, no task content. The numbers are mine; the secrets aren't.

// recorded Mar – May 2026

377

People in the program I led, including 309 trainers and 26 pod leads

Mar – May 2026

// recorded Mar – May 2026

131

Python scripts (about 34,000 lines) running onboarding, delivery and dashboards

Mar – May 2026

// recorded Feb – May 2026

~3,500

Lines in the FastAPI + React/TypeScript review app prototype

Feb – May 2026

How it fits together

Sheets stay the record. Python does the work.

Hover or tap a box to see what it talks to.

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.

Want the walkthrough?

Code walkthroughs are available on request, within NDA limits. Email is fastest.

Email me +92-333-4141218 LinkedIn Upwork Résumé (PDF)