Software Engineer, Verification Fleet

Build the checkout robots that prove a code works - real browsers driving real carts 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 our first proof at scale: the code verification service that shows shoppers the codes that actually work instead of a wall of dead ones. It earns 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.

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 Exists

When SimplyCodes tells a shopper a code works, a machine should have proved it: a checkout robot that went to the store, added an item, applied the code, and watched what happened at the cart. You own that fleet.

Today the robots reach only a fraction of the stores beyond the big standardized platforms. Your job is to multiply that reach across hundreds of thousands of stores. Every store you add turns a guess into a verified claim. Coverage is what an AI agent pays us for.

Agents write most of the code here, so the scarce thing is judgment: the design taste that keeps a fleet correct and cheap while it multiplies. You decide what to build and how you will prove it holds, with a high technical bar underneath.

The System You'll Need to Model

• Browser automation against a thousand different carts. Every e-commerce platform breaks differently: the code field hides behind a different click on Shopify, Magento, WooCommerce, BigCommerce, and a long tail of custom storefronts. The leverage craft is classification - collapsing hundreds of thousands of merchants into a small set of platform families, so one automation recipe covers thousands of stores instead of one.
• Fleet economics. The unit-economics law every large crawler lives under: a check that costs more to run than the commission it protects is a loss. You are always trading how often you re-test against what the test is worth - the fleet has to earn its own keep, store by store.
• The coverage-accuracy frontier. Pushing coverage outward means automating messier, stranger stores, where a robot is likelier to misread the cart. Reach and certainty pull against each other - the same precision-recall tension every verification system lives inside - and holding both as you scale is the whole game.
• Evasion versus detection. Stores and their anti-bot vendors do not want to be automated. Fingerprint surface, rate limits, and challenge walls move constantly, and headless detection improves every quarter. You navigate that contest at scale without breaking the store or the law.
• Verdicts need tests; tests need verdicts. You build beside the seat that owns the scoring science - the machine verdicts that decide what we claim is true. Those verdicts are only as good as the checkout evidence your fleet produces, and your fleet only knows where to test because that scoring shows where the truth is thin. Two seats, one loop.
• Cortex, the brain you build inside. You work inside Cortex - the shared AI brain that runs the company and the product family we sell; the substrate answers its own questions from more than 8,600 documents. The company moves at that substrate's speed; no spec stays current for a quarter. You are not using AI on the side; you are building inside the thing we sell.

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

What You Will Own

• The fleet platform, end to end. Browser automation at fleet scale - the system class behind every serious crawler, price-intelligence engine, and synthetic-monitoring product - pointed here at real checkouts. Yours spans the automation layer, the classifier that collapses hundreds of thousands of merchants into a small set of platform families, and the scheduler that decides which stores to test and when. Agents write much of the code; you own the design, the failure modes, and the verdict on what ships.
• Coverage as your number. Machine-tested checkout reaches only a fraction of the long tail today; you own the line that multiplies it across hundreds of thousands of stores - the number an AI agent is really buying when it decides to trust us.
• Fleet economics. Cost per verified checkout, held below the commission each check protects. You run the fleet's spend the way a strong platform team runs infrastructure - as a business number you can defend, not a bill you discover.
• Anti-bot navigation. The evolving contest with fingerprinting, rate limits, and challenge walls - a craft scraping and automation engineers carry for a career - navigated at scale without breaking the store or the law.
• The instrumentation that proves it. Fleet observability and evidence capture: dashboards and ledgers that show, for any claim, when it was last tested, whether the robot really reached the cart, and what the check cost. Correctness you can watch, not correctness you assert.
• The number, co-signed. Within your first quarter you co-sign a seat charter. It names one machine-checkable number that proves the seat works and writes down what you decide freely versus what you propose for the founder to sign. You own a number, not a backlog.

Who You Are

You reason in invariants, failure modes, and tradeoffs. Handed a checkout flow you have never seen, you can sketch the three ways it will break before you write a line. You see the platform family behind a one-off store, and the shared recipe behind a hundred one-off stores. When a robot fails at 2 a.m., your first question is structural: what class of store did we just discover?

You move fluidly between architecture and shipped code - a classifier design in the morning can be a deployed test by night. 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. You can do this job by hand and prove it - that mastery is what lets you trust, or reject, what an agent hands back. The expensive thing here is a redo cycle, never the compute.

You have built browser automation, web scraping, or large-scale crawling systems and operated them in production - you know what a fleet of headless browsers does to your infrastructure bill and your on-call sleep. You have reverse-engineered a site that did not want to be automated, and won. That is the craft you must already own. Where you earned it matters less: price intelligence, ad verification, search crawling, synthetic monitoring, or test automation at real scale all carry the same physics. Playwright, Puppeteer, headless Chrome, proxy rotation, and queue-backed job systems are familiar ground; Node.js and Python are daily tools. Here you layer on the next decade of the craft: directing coding agents and verifying what they return, building evidence systems beside an LLM-evaluation seat, and running a fleet's economics like a P&L. 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 is wrong if you guard a single lane and call the rest someone else's department - you own the fleet across automation, classification, infrastructure, and cost, and "that's not my job" ends the conversation. It's wrong if you pick technologies for how they'll read on your next resume rather than for what the fleet needs tonight. It's wrong if you wait to be told what to test instead of reading the system and deciding. 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 a fleet of robots that quietly proves, store after store, that a code is real.

How We Evaluate

We don't run traditional engineering interviews.

Async video screen. Brief and on your own time - about fifteen minutes. We want to see how you think, not how you present.

Calls with company stakeholders. Short conversations with the people you'd build beside.

Conversation with the founder. How you reason about coverage, cost, and truth at fleet scale, and where you push back.

Paid work trial. A paid four-day engineering trial - real work, in our real environment, shipping to our real platform. We watch how you get grounded 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 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: $380,000 - $475,000 - base, plus performance-based ownership and profit-share programs. Base: $250,000 - $310,000, top of market for senior engineering.

Eligibility for the company's ownership and profit-share programs - grants are performance-based, with terms discussed at the offer stage. We cover 100% of family insurance premiums. Your token budget is effectively unlimited, 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.