Head of AI Developer Infrastructure

Reign is the Autonomous Commerce Platform for DTC founders. We unify storefronts, checkout, payments, and operations into one AI-native platform where agents handle the operational grind and merchants focus on growth: making the most money, with the least headache, on their own terms.

We set out to build the "Shopify of Direct Response," and along the way we recognized something bigger. Direct response is roughly a third of all ecommerce transactions, a trillion-dollar market chronically overlooked by Silicon Valley. The merchants who run it are obsessive about tooling. They live and die by velocity, conversion, and margin. They have no brand moats, so they compete purely on operations, which is exactly what makes them the earliest and fastest adopters of AI agents in commerce.

This is a category-defining bet, and we are running at it from a position of strength.

Where We Are Today

Why Now

Why This Role Exists

Engineering already runs on an advanced AI-native SDLC. Our engineers ship with agents every day, on a shared team brain that hands work between people and their agents, through a multi-agent pipeline that plans, builds, reviews, and verifies. We ship 14x faster today than we did in January, measured in pull requests merged a month. We got there because a handful of people built their own systems and ran them hard. Now it has to become one system that everyone runs.

The builders are no longer only engineers. Our co-founders and product owners carry most of the domain expertise in the company, and with agents they already take features most of the way: the spec, the prototype, the first working version. What stops that work from reaching production is not ideas or effort. It is the thinking that has to happen before the build: architecture, security, data, caching, sequencing, and how the change ships safely. Today an engineer supplies it after the fact, by hand. This role exists to move that thinking to the front of the pipeline, so the people who know the business best can ship to the finish line, and the engineers behind them move faster instead of slower.

You own the factory. Spec to verified pull request in a sandbox, on a machine with no hands in between: plan, build, verify, sandbox, PR. The memory underneath it, the verification inside it, the compute and environments it runs on, and the enablement that gives every engineer, onshore and offshore, the same system with the same power. Two human gates stay in every loop: approving the spec and merging the PR. Security work stays manual. Everything in between is yours to automate, measure, and make boring.

How this fits. You sit in the platform group under our EVP Platform and Security, alongside a Principal Platform Engineer who built our sandboxes, feature flags, observability, and monorepo CI, and a Principal Backend Engineer hardening our data pipelines. The AI pod and the Storefronts lead are your most demanding users and your closest collaborators; they built the first version of the factory on their own machines. The SRE keeps production running. You build the system that lets everyone else go faster.

This is a Head-of seat at Principal level, on purpose. We would rather pay for one person who can design and run the factory than hire three people to hand-operate it. The scoreboard is the one we use for engineering itself: PRs merged, PRs reverted, time from spec to verified PR, how many people outside engineering ship each month, and eventually the revenue a PR generated or protected. The step up to leading the platform group comes from owning those outcomes, not from a countdown.

What You'll Own

We rank among the top 10% of technology companies in AI adoption across product and engineering. We’re looking for someone with even greater expertise who can challenge our thinking.

The factory: conversation to production. Any conversation can become a verified PR in a sandbox before the conversation ends. You take the overnight loops, the pipeline, and the handoff tooling our engineers built for themselves and make them the system: an orchestrator holding judgment and the team's context, cheaper models executing with exact instructions, success criteria at every step, the repo updated as it goes. Built on your own machine until it runs overnight against success criteria, then put in the cloud and replicated.

Verification that can see under the hood. Screenshots and video already cover UI. Checkout, billing, and payment internals cannot be verified by looking at a screen. You build the classic answer with modern parts: AI-written tests living in a real CI pipeline, sandboxes seeded with synthetic or sanitized data so a full sweep never touches production, parity checks against the analytics store, and experiment arms as release gates. The agent harness that runs outside CI today runs inside it.

Design first, then the last mile. Every build starts with the agent proposing how it will build, split, and ship the change, and an engineer approves that design as part of the spec gate. Sit with the co-founders and product owners who build with agents. Find exactly where their work stalls between working and merged. Build the step that carries it through, whether that is upfront planning, a review lane, a verification gate, a data fixture, or a skill the agent loads. Then measure how many of them ship each month and make the number go up.

Memory and the watcher, as services. The team brain (Postgres with vector and full-text search) and the watcher (a service that reads every log, metric, and pipeline, reports causes rather than symptoms, and drafts the fix) need to run 24/7 as managed services with an uptime number. You own the runtime, data, and access for both. The engineers who built the logic keep the logic.

Compute and environments. The runner fleet for agent swarms, cloud development environments with safe data, per-sandbox databases, and an isolated team AWS sandbox with real controls. Cloud, bare-metal, or on-prem decided with usage and cost data, and revisited as the numbers change.

Same system, same power. Every engineer, onshore and offshore, runs the same orchestrator on the same tier of account. You own the accounts and usage telemetry, the non-production vault, sandbox plus synthetic data, time-boxed production access, and a model supply that survives spend caps and provider changes, including a router for isolated workloads on other providers.

Guardrails that keep it safe. Production and shared infrastructure change only through Terraform PRs; inside the isolated sandbox account, agents provision what they need under policy-as-code guardrails, with no tickets. Automation proves itself in a sandbox before a PR exists. Production only ever sees a reviewed merge. Security work never runs unattended. No quota layer on top: we build the loop, not the whip.

What Success Looks Like in 90 Days

Who You Are

Cracked at this. You run agents all day, and you have built the systems that let other people do the same: runner fleets, preview environments, verification pipelines, model gateways. You can name the last three things you shipped with an agent and what they replaced.

A platform engineer, not a ticket taker. You have built infrastructure whose users were other engineers, at a dev-tools company (Vercel, Railway, Replit, Cursor, Modal, Fly.io) or at a startup doing the same thing. You measure yourself by how fast everyone else got.

Continuous delivery in your bones. We deploy about 2,000 times a month. You think in DORA metrics, find the slowest stage, and fix it, whether that is a 20-minute test run or a review queue. Weekly release trains and pre-prod cutovers are not part of your vocabulary.

Production Kubernetes on AWS. EKS, Terraform, and GitHub Actions for a real product, and you have carried the pager for what you built.

Verification-minded. You treat tests as the product’s immune system. You’ve built suites on the testing pyramid, managed test data as code with fixtures, seeding, and test-only APIs that put any account or order into a known state, and isolated third parties behind service mocks kept honest by contract tests. You think in ephemeral environments, deterministic assertions, synthetic data, and parallel runners.

Obsessed. You stay late because the work is that good, not because anyone asked. Our best engineers are the bar, and you will recognize them on day one.

A missile, not a passenger. You operate with a lot of autonomy and solve problems instead of escalating them. You don't bring us problems; you bring solutions and the resources you need to execute.

A clear writer and a careful thinker. Your designs are RFCs that others build against. You can hold your own in an architecture conversation with our EVP and our Principals because your opinions come from the work.

Startup-forged. You've thrived in fast, resource-constrained, high-intensity environments in the last few years, or you've built something of your own.

No tolerance for mediocrity. The people who thrive here hold themselves and others to an extremely high standard with no exceptions. We're here to build a generational company.

Our Values