About StackYak

StackYak is building the infrastructure layer for AI.

We are an early-stage, funded company building software that brings compute, GPU infrastructure, networking, and inference together into one product. The opportunity is large, the market is moving quickly, and we are building for real production workloads from the start.

This is not internal IT. This is not a slow-moving infrastructure team maintaining someone else’s platform. The infrastructure is the product.

We are a small, senior team with very little bureaucracy. The platform already exists: customers can buy GPU capacity, deploy models, connect privately, and pay for it, all through software we built. You would be one of the first engineers to join a codebase with real customers, real standards, and real decisions already in it, and to take ownership of large parts of it.

Treat this document as a starting point rather than a boundary. The people who do well here take ground early and are not asked to give it back.

We move quickly. We do not have months for someone to learn the fundamentals of their discipline. You should already be very good at what you do, be able to ramp into adjacent areas quickly, and be comfortable operating without perfect requirements or neatly defined boundaries.

The Role

We need a backend engineer who can own the system that runs StackYak: the data model, the workflows, the APIs, and the rules that decide who is allowed to do what.

Underneath the product sits a control plane. It records what every customer has asked for, drives long-running and failure-prone work against machines and providers we do not fully control, and keeps an accurate account of who owns what, what is running, and what it costs. It is built to strict standards, and it is yours to push further.

This is a backend role, primarily. The hard engineering lives in data modeling, state, correctness, and failure, and that is where we need your judgment first. Want to own the console and the customer experience too? Plant the flag. It’s yours to claim.

This is not an architecture-only role. You will design, build, deploy, debug, and operate the platform, and carry it in production.

What You Will Own

Not tasks. Outcomes, and the authority that comes with them. We expect this list to grow as fast as you can take it.

The data model. A SQL-first Postgres core with tenancy enforced in the database itself. How it changes while customers are using it, and how we stop a migration from becoming an incident.
Workflows. Provisioning, fulfillment, model installs, billing runs: operations that take minutes, cross several systems, fail halfway through, and must still end up correct.
Identity, tenancy, and authorization, for people and for machines. Who did this, on whose behalf, and whether they were allowed to.
Every way a customer drives the platform: console, API, CLI, Terraform, and agents. All of them should tell the same truth.
Integrations with the outside world. GPU and network providers, payments, and identity, and the gap between what each of them advertises and what it actually does.
The contract with the infrastructure underneath. The interface our compute, networking, and inference engineers build against, and the standing to tell them it has to change.
Commerce. Orders, quotes, billing, and usage, where a correctness bug is somebody’s money.
Production. On-call, reliability, and the engineering standards the codebase holds itself to, including the right to argue that one of them is wrong.

Where You Will Start

Our customers are engineers, and more and more often the thing acting for them is a script, a pipeline, or an agent. Your first area of ownership is the platform’s programmatic surface: making sure everything a person can do at the console, a program can do as well, with exactly the access it was granted and no more.

That covers scoped machine credentials, the management API, infrastructure-as-code, and agent access over MCP. They are clients of the same few design decisions, so we want them designed together, by one owner.

The interesting problems are not in the wiring:

What a machine principal is, and how it is authorized and attributed in a system built around tenants and people.
How declarative desired state, the kind a plan file expresses, maps onto operations that happen in steps with waits in between.
Which internal interfaces should become public contracts, and what we are prepared to support for years once they do.
What an autonomous agent should be allowed to do with a customer’s money, and how it asks first.

We expect you to shape these, not just implement them. Then we expect you to keep going.

What Success Looks Like

You can be handed any part of the platform, along with a business requirement and a security requirement, and turn it into something customers can automate against, engineers can build on, and the business can trust with its money.

You will help us answer questions such as:

Where should the line between internal interfaces and public contracts sit, and what does crossing it commit us to?
What is a machine principal, and what does it need that a user does not?
When should a write be declarative and when should it be an explicit state transition?
What keeps working while the control plane is degraded or down?
How do we change a data model under live tenants without downtime or surprises?
Which of our standards are protecting us, and which are just slowing us down?

Stack

Python 3.14 across services, workflows, and tooling.
PostgreSQL, with a SQL-heavy data layer and row-level security doing real work. This is not an ORM shop. ClickHouse for analytics.
Temporal for durable workflows.
GraphQL between the product and its frontends.
TypeScript and React 19 on the frontend, with Vite, TanStack Router and Query, Relay, and Tailwind.
GCP and Terraform for our own infrastructure.
Go where it is the right tool for the job.
We work agent-first with AI coding tools, behind written standards, design records, and CI gates that are enforced rather than aspirational.

What We Need

The bar is what you have already done, not what you could learn. You should have done most of this:

Owned a backend end to end, not a single service inside someone else’s system.
Designed an API that other people built on, and lived with it long enough to regret part of it.
Modeled data in Postgres at a depth where the database enforced the rules, not only the application.
Built authentication and authorization for customers who were not permitted to see each other, including non-human callers.
Built long-running operations where idempotency, retries, and partial failure were real problems rather than interview topics.
Evolved a production schema under live traffic.
Written Python that other people run in production, at the level where you care how it is tested, deployed, and debugged.
Carried production on-call for a system you built, and changed it because of what on-call taught you.
Debugged a problem that started in your service and ended somewhere underneath it.

You Will Be Especially Strong If

You have built a control plane, orchestrator, or developer platform at a cloud provider, neocloud, GPU cloud, hosting company, or infrastructure SaaS.
You have written a Terraform provider, or a Kubernetes operator, CLI, or SDK that people used without reading the source.
You have built an OAuth authorization server, an MCP server, or a scoped-credential system.
You have built billing or usage pipelines and been the person who answered when a customer disputed a number.
You work agent-first with AI coding tools, and have opinions about where they help and where they lie.
You understand enough about compute, networking, or GPU infrastructure to argue with a specialist on their own ground.
You build things on the side because systems are interesting to you, not only because an employer assigned a ticket.

This Is Probably Not For You If

You want a narrowly scoped project or a single service to call your own.
Your backend experience is mostly CRUD behind an ORM that made the hard decisions for you.
You are uncomfortable writing SQL by hand or reading a query plan.
You are primarily a frontend engineer.
You need a spec before you can start.
You find it hard to work inside someone else’s strong standards, or you find it hard to push back on them.
You treat infrastructure as someone else’s problem and would rather not know what happens beneath the API.
You prefer designing systems that someone else implements.
You want months to become productive in the core areas of the role.

How We Work

Small, senior team with direct access to the founders.
Strong opinions, loosely held.
Everyone is expected to participate in technical decisions.
Everyone shares responsibility for production and on-call.
We value people who can move between design, implementation, debugging, and operations.
We care much more about what you have built and operated than degrees, certifications, or academic credentials.
We expect people to leave ego at the door, argue the technical case, make a decision, and then execute.
We are remote and distributed across time zones. Whether a role is an employment or a contract engagement depends on where you are, and we work that out at offer.
Hiring here is a few real conversations with the people you would actually work with, not a recruiter screen followed by a panel of strangers.
We are hiring across the platform, inference, infrastructure, and networking. The boundaries between the four are blurry on purpose. If you sit between two of them, say so.
This is an early-stage startup. The pace is high, the problems are hard, and the scope will change as we grow.

Compensation

Competitive compensation plus meaningful equity. Exact structure will depend on location, engagement model, and experience.

A Note For Agencies

We are not using external recruiters or agencies for this role, and we will not be persuaded otherwise by an email. We do not want your spam. We will not read the CVs you send, we will not reply to your follow-up, and no candidate you put in front of us creates a fee obligation of any kind. Do not contact us.

Senior Software Engineer, Control Plane

Similar jobs

Software Engineer 5 - Open Connect Control Plane