Staff AI Infrastructure Engineer

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

8-figure ARR, growing 100%+ YoY (top 0.5% of all startups launched in 2024), and we do it with capital efficiency: there is a real chance we finish the year with more cash on our balance sheet than we have ever raised
Rapid merchant adoption and expanding market presence
On track to beat our budgeted sales target by 100%+
Industry-leading NPS score
70% of our new deals come as referrals from existing merchants
Venture-backed by a multi-billionaire ex-founder and direct response industry leaders
An executive team that has done this before: multiple leaders who have scaled a company from zero to unicorn status
A founder who builds from domain expertise: he bootstrapped $200M+ in DTC revenue as a direct response merchant before starting Reign, and is building the platform he always wanted as a merchant

Why Now

This is a rare opportunity for a technical leader to step into a company with proven revenue, product-market fit, an established team, and a large market opportunity.

Three things make this an inflection point:

1. Product-market fit is established. Demand continues to grow, merchant adoption is accelerating, and Reign is outperforming expectations.

2. There is an opportunity to define a category. While many companies are building AI tools for commerce, few are focused on helping sophisticated DTC operators automate revenue-generating decisions at scale.

3. Our customers are AI-ready. They adopt technology quickly when it drives measurable business outcomes, creating an ideal environment for agentic products.

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 Staff 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

Day 30. You have shipped through the factory yourself, spec to PR, using the brain, the pipeline, the sandboxes, and the harness, and you can say precisely where work stalls between working and merged for engineers and for the non-technical builders. Agent swarms run on infrastructure you stood up, and the cloud vs bare-metal vs on-prem call is made with numbers. The plan for the quarter is written, and the AI pod, the Storefronts lead, the Principal Platform Engineer, and the EVP have signed it.

Day 60. One lane has run unattended end to end: spec on a call, factory overnight, verified PR in a sandbox with evidence by morning. Sandboxes are seeded with synthetic data. The agent harness runs in CI. The first offshore power users run the same system as the onshore ones.

Day 90. At least two people outside engineering have merged PRs that went through the factory without an engineer rebuilding them. The output dashboard exists (PRs merged, PRs reverted, spec-to-PR lead time, cost per merged PR) and leadership reads it. The team brain and the watcher v1 run as services. The next two quarters of the AI SDLC are written down, and the engineers who depend on them have signed off.

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 Stack

AWS (EKS, RDS MySQL, ElastiCache Redis, S3), GCP, and Cloudflare Workers. Terraform for every production infrastructure change. GitHub Actions with a per-service matrix and queued production deploys. Request-isolated PR sandboxes on EKS. Datadog and OpenTelemetry. ClickHouse Cloud with CDC from MySQL and schema as code. Postgres with pgvector for the team brain. A TypeScript monorepo (NestJS, Node, pnpm, seven services, 26 shared packages) and a React portal. Claude Code with tiered models, the Anthropic SDK, an MCP server, a promptfoo-based agent harness with deterministic assertions and model judges, an anti-fabrication guard, multi-agent code review, and git worktree lanes. Claude Code is a real part of the daily workflow here, not a garnish.

Huge Plus

You have run self-hosted CI runners or browser test fleets at scale and can say what each run cost.

You have evaluated open-weight models on hosted providers for real workloads.

Bare-metal cost arbitrage with the receipts.

ClickHouse, MySQL, or Redis operations in production.

Commerce, checkout, or payments infrastructure, or any environment where PCI was real.

You've been a founder, or an early operator who owned the outcome.

Our Values

We are a value-driven company. These aren't words that we just put on a wall. They dictate how we hire, fire, and promote.

All In to Win. Operate with urgency and a relentless focus on excellence.

A Players Only. Build and maintain exceptional talent density. Pure meritocracy.

Merchant First. Every decision is measured by merchant impact.

Entrepreneurial Spirit. Move quickly, stay resourceful, and take ownership.

No Ego. The best ideas win regardless of title or tenure. No BS politics.

**Reign is mission-first and performance-driven. We operate with urgency, give direct feedback, and expect high ownership. If you thrive under pressure and love building in fast-moving environments, you'll do great here. If you strongly prioritize predictability, comfort, and work/life separation, this 100% isn't the right role.**

We operate as a flat, high talent density, meritocratic organization.