Head of AI Native Operations

About Supabase

Supabase is the Postgres development platform, built by developers for developers. We provide a complete backend solution including Database, Auth, Storage, Edge Functions, Realtime, and Vector Search. All services are deeply integrated and designed for growth.

About the Role

We are looking for a Head of AI Operations to own how Supabase works.

Supabase is building an AI-native internal operating system: a common way of working across the company where AI carries a meaningful share of the operational load rather than sitting alongside it as an assistant. We are standing up a new central team to build those systems, enable the teams, and embed AI operations throughout the organization. This is the role that runs it.

You will own the maturity model teams are assessed against, the standards that define how work happens here, and the operating cadence, under one design rule: every recurring meeting has to justify why an automated report cannot replace it. You will lead a small team of senior individual contributors, one building the platform and one running enablement.

The premise is that process encoded as agents scales where process enforced by people does not. Your job is to prove that is a repeatable pattern rather than an anomaly, across teams you have no authority over.

We are fully remote and async. The document is the enforcement mechanism here, which means the standards themselves are your deliverable.

What You'll Be Responsible For

In this role, you'll

• Own the maturity model end to end: The rubric, the scoring method, the evidence standard, and the appeals path. Every team ends up with a published assessment and a written plan to its next level.
• Run assessments and commitments: Conduct assessments with department heads yourself, landing them as commitments with named owners and dates rather than opinions.
• Own the standards layer: Define how work gets tracked, decisions get proposed and resolved, teams migrate onto shared tooling, and stale documentation gets retired. Standards ship as documents teams follow without being chased.
• Fix the decision process: Ensure written proposals reach resolution instead of accumulating unresolved by defining stages, exit criteria, and closing mechanisms.
• Run the operating cadence: Lead automated weekly reporting, a regular blockers-and-decisions forum, a monthly leadership review, and a quarterly board-level format. Delete meetings a report could replace.
• Manage rollouts: Execute private assessments first so leads see only their own and have time to move, followed by a pre-committed public transparency date.
• Wire standards into onboarding: Ensure every cohort arrives pre-trained rather than inheriting nearby habits.
• Build and direct the team: Hire, grow, review, and direct two senior individual contributors (platform and enablement) without doing their work for them.
• Measure and publish outcomes: Measure and publish whether the thesis holds by tracking how much coordination work agents absorb versus what a human program office would cost.

How You'll Think

Recursive Thinking

Every standard you write should be the input to something that enforces it, and every enforcement mechanism should produce the evidence that grades it. When you write the rule that work must carry a current status, you are not finished until a report finds the stale items and tells their owners without you in the loop. The same applies to your own function: the team you build gets assessed by the model you own, published next to everyone else's, and you should want that.

Inversion Thinking

The default outcome for a company-wide standard is that teams politely ignore it. So the first question about any standard is not "is this correct" but "what will make people route around this," and the design follows from that answer. Same for meetings: rather than asking what a new sync would accomplish, ask what report would make it unnecessary and build the report. Same for the public transparency date: it gets committed before anyone has a score to defend, because afterwards the lobbying is rational.

AI-Native Execution

You direct agents rather than doing the work by hand, and you can tell whether the direction was any good. That means reading an agent workflow definition and knowing the procedure is too broad, reading a data model and challenging the metric behind it, reading a pull request from your own team and sending it back. Your working artifacts are files in version control that agents can read, not chat transcripts. You will not build the platform. You will be the person who says whether what got built is right.

You Might Be a Good Fit If You

Must Have

• Scale & Cadence Experience: Have run operating cadence and program discipline at a company crossing ~200 to 800 people while remote and async.
• Agentic AI Expertise: Have personally built agentic AI workflows that others depended on. You can read/review an agent workflow definition, a data model, and a pull request to judge quality.
• Standard Adoption Track Record: Have taken a standard from zero to company-wide without direct authority over adopters, with a clear mechanism that made it stick.
• Async Communication Skills: Are an exceptional writer who leverages documents as enforcement mechanisms.
• Accountability: Are comfortable being graded publicly by the system you build alongside every other team.

Strong Signal

• Have run a maturity model or capability assessment across teams you did not own, published results, and driven organizational reallocations.
• Are native to Git, Markdown, and Pull Requests (whether through engineering or technical operations background).
• Have permanently eliminated a recurring meeting by replacing it with an automated system.
• Deep software engineering background is a plus, but not required.

What Success Looks Like

• Standards land without chasing: Rules are written, published, wired into onboarding, and followed because non-compliance is automatically visible.
• Universal coverage: Every team has an evidence-backed assessment, owner, and written path to the next level, with disagreements handled through published appeal channels.
• Firm transparency dates: Assessments transition from private to public on pre-committed dates without exception.
• Net-negative meeting time: By year end, the operating rhythm consumes less calendar time across the organization than when you arrived.
• Autonomous operational function: Your two reports operate independently against written charters, at least one non-reference team runs a genuinely automated production workflow, and you focus on review rather than execution.

What We Offer

• Fully Remote

  We hire globally. We believe you can do your best work from anywhere. There are no Supabase offices, but we provide a WeWork membership or co-working allowance you can use anywhere in the world.

• ESOP

  Every team member receives ESOP (equity ownership) in the company. We want everyone to share in the upside of what we’re building together.

• Tech Allowance

  Use this budget to set up your ideal work environment—laptop, monitor, headphones, or whatever helps you do your best work.

• Health Benefits

  Supabase covers 100% of health insurance for employees and 80% for dependents, wherever you are. Your wellbeing and your family’s health are important to us.

• Annual Off-Sites

  Once a year, the entire company gathers in a new city for a week of connection, collaboration, and fun. It’s a highlight of our year.

• Flexible Work

  We operate asynchronously and trust you to manage your own time. You know what needs to be done and when.

• Professional Development

  Every team member receives an annual education allowance to spend on learning—courses, books, conferences, or anything that supports your growth.

About the Team

Supabase was born-remote and open-source-first. We believe our globally distributed team is our secret weapon in building tools developers love.

• ~400 team members
• 60+ countries
• 20+ languages spoken
• Over $1B raised (including our $500M Series F)
• 540,000+ community members

We move fast, build in public, and use what we ship. If it’s in your project, we probably use it in ours too. We believe deeply in the open-source ecosystem and strive to support—not replace—existing tools and communities.