iMerit

What Was Built

Ground Control was the enterprise-grade AI data-operations platform I created as product owner at iMerit. It gave customers one place to see throughput, quality, anomalies, workforce risk, and customer-specific governance across distributed annotation programs.

The platform unified fragmented annotation data across 6,000+ individual annotators, 20+ labeling tools, and 5 time zones, covering 80+ enterprise customers and 150+ unique projects running at any given time. Internal teams and enterprise customers could finally understand what was happening before delivery, quality, or compliance broke down.

What the product did:

• Turned fragmented labeling activity into shared operating dashboards for delivery, quality, and customer teams.
• Standardized metrics across projects, tools, customers, and time zones.
• Captured edge cases and anomalies from browser-based labeling environments.
• Supported role-based access, data lifecycle management, audit trails, encryption, and custom customer configurations.
• Gave enterprise customers evidence that data work was moving, exceptions were being handled, and risk was visible.

I also helped take Ground Control directly to market with enterprise customers. Alongside iMerit's go-to-market and delivery teams, I translated complex operating needs into configurable workflows, metrics, governance controls, and customer-ready proof that teams could trust, adopt, and scale.

Ground Control supported customer and internal operating programs across autonomous systems, industrial AI, inspection, mapping, and delivery operations. Each program had different tools, metrics, and review paths; the product work was turning that variation into reliable operating visibility without forcing every customer into the same workflow.

• Amazon
• Netflix
• John Deere / Blue River
• Cruise
• Athena
• UV Eye
• Nuro
• Bosch
• Internal finance and delivery operations

My Role

I was the product owner and Senior Product Manager for Ground Control. I owned product vision, roadmap, stakeholder discovery, feature requirements, prioritization, direct customer conversations, and alignment across engineering, program management, operations, compliance, go-to-market, and customer-facing teams.

The work was not just dashboard shipping. It required turning messy customer asks into reusable platform primitives: shared definitions, escalation workflows, anomaly lifecycle management, role-based access, and customer-ready proof.

The hardest product problem was not a single feature. It was turning many one-off operational requests into an enterprise platform that could flex by customer without becoming impossible to maintain.

That meant writing requirements for configurable workflows, clarifying ownership across technical and delivery teams, defining success metrics, and separating what should be custom from what needed to become reusable product infrastructure.

The clearest example was the Edge Case Module. The product needed to help teams capture a screenshot or event from a labeling workflow, route it into the right review path, preserve metadata, and make the resolved case usable for training and delivery improvement.

The product insight was that a captured edge case is not one thing. It is two, and they demand opposite responses:

• Genuinely novel data. Something that has never appeared in the dataset before, which a customer's engineering team needs to see because it changes what the model has to handle.
• An under-trained annotator. The data is ordinary, but the annotator has misread the labeling guidelines and does not know how to interpret what they are looking at.

Separating the two turned the module into a recursive improvement loop. Novel data reached the engineering teams who needed it. Guideline misreads went back into annotator training and into sharper labeling guidelines, so the humans in the loop got better over time and the instructions they worked from got clearer.

How We Measured Success

Before building dashboards, I defined what a working platform had to prove. These were the bars the work was measured against:

• Real-time visibility had to exist at all. Operating truth lived in spreadsheets. One wrong cell propagated into every dependent sheet and report, and teams made delivery decisions on data that had already broken. Bad data in, bad data out, with a domino effect nobody could trace. Giving internal teams and customers a live shared view was the first bar, because nothing like it existed.
• One definition, everywhere. Throughput and quality had to mean the same thing across every project, tool, customer, and time zone, instead of per-team spreadsheets that disagreed at delivery review.
• Edge cases classified, not just captured. Every case had to be sorted into novel data or guideline misread, then routed accordingly. Capture volume alone was not the measure.
• Governance a customer could audit. Access, audit trails, encryption, lifecycle controls, and customer-specific configuration had to hold up in an enterprise review, not just in a deck.
• Configurable without forking. New customer requirements had to be absorbed as configuration on shared primitives. If a customer needed custom code, the platform had failed the test.

Ground Control delivered that visibility in production. It orchestrated 6,000+ individual annotators across 80+ enterprise customers and 150+ concurrent projects in real time, visible to internal teams and customers at the same moment, and replaced spreadsheet reporting as the system of record.

The Edge Case Module captured, reviewed, and resolved 4,500+ dataset edge cases. Classifying each one by cause is what made the loop work in both directions. Catching guideline drift early cut individual annotation time by roughly 15% over the course of a pilot, mostly by shortening how long annotators spent learning to interpret ambiguous instructions.

Commercially, the platform supported enterprise accounts totaling more than $20 million in aggregate revenue, including Amazon, Netflix, John Deere, and Cruise. Its clearest role was decision support: giving delivery and go-to-market teams the evidence to guide contract renewal decisions, and justifying the value of lower-dollar pilot projects that had to prove themselves before they could expand.

Why It Mattered

Enterprise AI programs fail when the work behind the model is invisible. Customers need proof that data is moving, edge cases are being handled, and quality risk is being caught before it becomes model risk.

Ground Control made distributed human-in-the-loop AI work legible enough to manage, improve, and defend in front of customers.

What This Proves

I can create and own enterprise-grade AI platforms from customer discovery and direct sales through product delivery and scaled adoption: messy workflows in, clearer decisions out, with enough structure for teams, customers, and compliance requirements to trust the system.