Own every code and merchant fact from source to shelf — what enters, how it is normalized, and how fast it goes stale — across hundreds of thousands of stores.

Product.ai is the verified truth layer for shopping: when a person or an AI agent needs to know what is actually true about a purchase, we answer with proof. SimplyCodes is the first proof at scale — the code verification service that shows shoppers codes that actually work, earning about $22 million a year at roughly 60% margins. We are 100% founder-owned, profitable, and bootstrapped since 2009 — no outside investors, no board. Fewer than twenty operators, outbuilding companies 10x our size.

Why This Role Exists

Every claim we publish stands on a supply chain of facts. Codes and merchant facts arrive by the hundreds of thousands from sources we do not control — networks, feeds, merchant surfaces — each in its own shape, wrong in its own way. They resolve into one canonical shelf: this code, this merchant, these terms. And they start dying the moment they land — codes expire quietly, terms change without notice. Freshness is the fuel of the engine: a stale shelf reads as a wall of dead codes, and dead codes are what we exist to kill.

That supply chain has never had a single owner. The pipelines run and the revenue flows, but the decisions that matter most — what enters, the record it becomes, how fast each fact is rechecked or retired — have never sat in one seat. This is a founding seat: the whole intake-to-shelf path in one pair of hands, working directly with the founder. One layer is mid-transition — row-level validation, the industry's last manual stronghold, is becoming an agent fleet here: LLM pipelines reading and checking at machine scale, humans owning the verdicts. You inherit an agent-fleet design problem, not a headcount.

One boundary, drawn on purpose: downstream of you, a robot fleet proves codes at real checkouts — a sibling seat owns that proof. You own everything upstream: what enters, the record it becomes, and the clock that decides when it must be proved again. They prove what you shelve; you decide what is worth proving. Two seats, one loop.

The System You'll Need to Model

  • Ingestion from sources you do not control. The problem class every data platform lives with: dozens of third-party sources, each with its own schema, lag, and error habits. The craft is contracts at the edge — schema-drift detection, quarantine lanes for suspect rows, pipelines that fail loudly instead of silently.
  • Entity resolution as the load-bearing wall. The same merchant arrives under five names; the same code from three sources with two expiry dates. Record linkage and dedupe — the discipline behind every serious catalog, listings, and knowledge-graph system — decide whether the shelf holds one truth or three almost-truths. A precision error here becomes a public claim with our name on it.
  • Freshness as an economic frontier. Commerce facts decay on their own clocks — a code can die an hour after it lands. Every class of fact carries a staleness budget and a recheck cost: verify too often and the pipeline eats its own margin; too rarely and the shelf rots. You are setting data-quality SLOs where the SLO is the product.
  • Agent fleets as the validation workforce. The row-by-row judgment calls — does this code look real, does this merchant match, do these terms parse — running as LLM pipelines at machine scale, with humans owning the verdicts. The craft is evaluation design: golden sets, adversarial cases, precision floors that prove the fleet grades honestly, and a cost line that proves it earns its keep.
  • Cortex, the brain you build inside. You work inside Cortex — the shared AI brain that runs the company and the product family we sell; it answers its own questions from more than 8,600 documents. The company moves at that speed; no spec stays current for a quarter. Nobody hands you a brief — you model where the system is going and meet it there.

If reading that energizes you, keep going. If it feels overwhelming or underspecified, this isn't the right fit.

What You Will Own

  • The commerce data supply chain, end to end. Every code and merchant fact from source to shelf — what enters, the one canonical record it becomes, when it is retired. The system class behind every catalog, price-intelligence, and listings platform, pointed here at the data under the revenue engine that pays for everything we build. Agents write much of the code; you own the design, the failure modes, and the verdict on what ships.
  • The agent validation fleet. The fleet of LLM validators that does row-level judgment at machine scale. You design it, write the evals that prove its precision, and price it: fleet architecture, eval harnesses, human-verdict escalation paths, a cost line you can defend. No direct reports — the fleet is the team.
  • Freshness as your number. Verified-freshness coverage across hundreds of thousands of stores — how much of the shelf is machine-verified and inside its staleness budget. It is the fuel gauge of the business, and yours to move. Developers and AI agents now buy this data through paid keys — a stale row is a broken promise to a paying machine.
  • The seat, chartered. Inside your first quarter you co-sign a seat charter: one machine-checkable number that proves the seat works, plus a written split of what you decide alone and what you bring to the founder first. The craft you must own walking in: large-scale ingestion, entity resolution and dedupe, freshness SLAs, pipeline unit economics. What you grow into: agent fleets as a production workforce, LLM evaluation design, and a data platform run like a P&L.

Who You Are

You reason about data systems in invariants and lifecycles. Handed a shelf of facts you have never seen, you ask the structural questions first: where did this row come from, what would make it wrong, when does it die? You see the pattern behind the pile — the five sources behind one duplicate, the decay class behind one stale code. You notice when your model is wrong and update fast, and you write clearly, because on a team this small the written spec is the meeting.

You move between architecture and shipped code without ceremony — a resolution design in the morning can be processing real rows by night. Agents are your production workforce: you direct them and verify what comes back. You can do this job by hand and prove it — that mastery is what lets you trust, or reject, what an agent hands you. The expensive thing here is a redo cycle, never the compute.

You have built and run production data pipelines at real scale — ingestion from third parties you did not control, entity resolution or dedupe that mattered, data-quality guarantees someone else depended on. Where you earned it matters less than that it held: catalog and listings platforms, price intelligence, ad or affiliate data, search indexing, knowledge graphs — all the same discipline. Python and SQL are daily tools; Airflow, Dagster, or Temporal are familiar ground; your batch-versus-streaming opinions come with incident stories attached. If you have run LLM pipelines against golden sets, better still — if not, you will learn that here fast. We care about the artifact and the reasoning far more than where you did it — no degree to check.

Who this isn't for. This seat is wrong if you guard one lane and call the rest someone else's department — the supply chain runs from raw source to public shelf, and you own all of it. It is wrong if you need a finished spec and a groomed queue before you can move, or a platform team underneath you to feel senior. It is wrong if you pick tools for how they read on a resume rather than what the pipeline needs tonight. And it is wrong if you would ship what an agent handed you without being able to say why it is right — or let the fleet grade its own homework. You will be happiest here if your idea of craft is a shelf that is never quietly wrong, and a supply chain you can defend row by row.

How We Evaluate

We don't run traditional engineering interviews. We evaluate demonstrated performance on work-relevant tasks, in four steps.

  1. Async video screen. Brief and on your own time — about fifteen minutes. We want to see how you think, not how you present.
  2. Calls with company stakeholders. Short conversations with the people you would build beside.
  3. Conversation with the founder. How you reason about freshness, cost, and truth at supply-chain scale — and where you push back.
  4. Paid work trial. Four days, paid, on real work in our real environment — a live piece of the supply chain, taken from grounding to a change you can prove. We watch how you get grounded, whether you write the spec before the build, how you verify what your agents produce, and whether your self-assessment is honest. We both learn more in four days than in forty hours of interviews.

If the work above reads like yours but your resume is unconventional, apply anyway. We hire on the work and the reasoning, not the pedigree.

Compensation & Ownership

Total first-year comp: $400,000 – $500,000 — base, plus performance-based ownership and profit-share programs. Base: $260,000 – $330,000, top of market for senior data engineering.

Eligibility for the company's ownership and profit-share programs — grants are performance-based, with terms discussed at the offer stage; 100% family premium coverage; an AI tooling budget steered by return, never capped. The model is built to mint partners.

Based in Santa Monica, Los Angeles — in person, five days a week. The rooms are real rooms. Relocation support available for the right builder.