Senior Software Engineer

The second builder on the spine. Direct line to the founder and the architect.

Product.ai is the verified truth layer for shopping - the intelligence that tells you what's actually true about a product, including when not to buy. Profitable. Bootstrapped. No outside investors. No board. 20 people outbuilding companies 10× our size.

Strong people find us and keep finding us - they apply over months and years, because the field moves fast and the exact profile we need moves with it.

Why This Role ExistsThe platform that turns adversarial AI research into verified commerce truth was designed and built by one architect. It works, it's in production, it's profitable, and it's the spine everything else stands on - and it has outgrown one owner. We need a second builder on that spine.

"Builder," deliberately. In a shop where agents write most of the code, the scarce thing is judgment: the taste to design systems that stay correct, observable, and cheap as they scale. You will operate more like a product engineer for infrastructure than a heads-down backend developer - you decide what to build and how you will prove it holds, with a high technical bar underneath. Your leverage is judgment and taste, not keystrokes.

Your first surface is the verification platform - and specifically the part one architect never had time to build: the verification dashboard and eval plumbing that make correctness visible . Today the pipelines run and the truth is tiered, but whether a given claim is fresh, whether a verifier actually caught a regression, and what a re-verification cost are buried in logs. You will build the instrumented layer that turns all of that into a system you can watch - alongside the provider-portable adapter layer, the freshness economics, and the agent-facing APIs. And you won't stay boxed there - we hire builders who range across the whole stack.

The System You'll Need to Model

• Adversarial research at industrial scale. Frontier models are pitted against each other; what survives gets a confidence tier and a citation. Underneath sits pipelines, queues, caching, and cost physics across multiple model providers - latency, throughput, accuracy, and dollars in permanent tension.
• Freshness priced by claim class. Coupon and promotion truth decays in hours; product truth decays in months. The platform has to price re-verification per class - when to re-check, what staleness costs, what re-checking costs - and make that a scheduled, observable system rather than a guess.
• Delivery where the consumer is another AI. Machine SLAs: schema stability, context-budget-aware responses, trust thresholds, graceful degradation. A human tolerates a slow page; an agent mid-run does not.
• Verification as physics, not policy. A model cannot reliably grade its own output, so the architecture is external truth anchors, regression corpora, append-only verdict ledgers, and verifier agents that never see the implementation they judge. You build the rails those verifiers run on. This is the company's whole thesis, turned inward as infrastructure.
• Cost you can read, not just pay. Spend here is enormous by design - the expensive thing is a redo cycle, never tokens. Per-query and per-run cost ledgers read against what the spend actually moved. Your job is to make spend legible, not to make it small.

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

What You Will OwnYou own correctness, freshness, and cost as one system. The provider-portable adapter layer that keeps us free to switch models. The pipeline that moves research from raw claims to tiered, citable truth. The agent-facing API surface that other AI systems consume - schema, versioning, machine SLAs - and the instrumentation that proves they should trust it. The eval and verification layer that makes correctness visible, and the cost ledgers that turn token ROI from a slogan into a number.

The standard you hold: boring, observable, self-announcing infrastructure - queues that report their own health, failures that page before a human notices, and the architectural law it all runs under, written so the agents that build on it can execute it.

Who You AreYou reason in invariants, failure modes, and tradeoffs. When something breaks, your first question is "what's the structural cause?" You read a system you've never seen and can sketch its failure modes the same day. You move fluidly between architecture and shipped code - a freshness-pricing design in the morning can be a deployed scheduler by night - and you are as comfortable deciding what to build as how . You write clearly, because clear writing is evidence of clear thought, and here what you write becomes the law the agents execute.

You can do this job by hand, and you can prove it - and that mastery is exactly what lets you direct agents and trust the result. You have built data pipelines, queue-backed systems, high-throughput APIs, or ML-adjacent infrastructure at real scale, and you operated what you built. You treat agents as leverage you verify, not autocomplete you trust: you can point at a system you shipped, name the hardest failure you personally diagnosed in it, and say what you changed. We care about that artifact and that reasoning far more than where you did it.

Who this isn't for. This is wrong if you draw architectures you don't intend to operate, or if you need a platform team beneath you to make your designs real. It's wrong if you guard a single lane and call the rest someone else's department - we range across the stack here. It's wrong if you pick technologies for how they'll read on your next resume, or if you measure a job by the title on the org chart rather than by what you get to build. It's wrong if you think in projects, timelines, and programs rather than systems steered in real time. And it's wrong if your code is whatever the model handed you and you couldn't say why it's right - or if you're comfortable letting an agent grade its own work. You'll be happiest here if your idea of craft is infrastructure that announces its own health, and writing the law it runs under.

How We EvaluateWe don't run traditional backend interviews.

• Written artifact. Send a system you built and the hardest failure you personally diagnosed in it - and what you changed. A system-design doc, a postmortem, or an architecture decision you fought for all work. Writing quality and depth of ownership are our first filter.
• Video screen. Brief and async - about 15 minutes, 5 to 6 questions, done whenever works for you.
• Calls with company stakeholders. Short conversations with key members of the team.
• Conversation with the founder. How you reason about systems, cost, and truth at scale.
• Paid work trial. A paid 4-day engineering trial - real work, in our real environment, shipping to our real platform. We watch how you ground yourself in the system, 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 4 days than in 40 hours of interviews.

Compensation & OwnershipTotal first-year comp: $400,000 - $500,000 (base $280,000 - $340,000 - top of market for senior platform engineering).

Profits Interest Units (PIUs) - Class B Membership Interests at $0 strike, real ownership day one, capital-gains treatment; annual pro-rata profit sharing from free cash flow; annual tender liquidity; 100% family premium coverage; effectively unlimited token budget, steered by ROI, never capped.

Based in Los Angeles. Hybrid, with flexibility. For the right builder, we're open to remote.
#BI-Hybrid