Why this role

Most engineering roles hand you a slice. A product owner sets the “what,” a manager sets the “how,” and you build your piece inside someone else’s sprint. This role starts one step earlier — before the problem even has a name.

We don’t build the product our customers log into. We build the tools that make the whole company faster, and the systems that catch a problem before a customer ever feels it. When what we build works, everyone ships and resolves faster. When it doesn’t, everyone feels it. At the Principal level, you own that leverage for the whole org: you decide what should exist, and you build it.

Here is how the work actually starts. Sometimes a friction point lands overnight and someone has to own it end to end by morning. More often, nobody has named the problem yet — and you are the one who sees it, frames it so the rest of us understand it, and sets the direction we build toward. You dig into an ambiguous system until you understand it better than the people living inside it, then you reach for code, AI, and systems to remove or replace the bottleneck — not to optimize around it. What you ship did not exist before, scales across the company, and becomes something other engineers build on.

This is blue-water work. There is frequently no tool to configure, no vendor to call, and no best practice to copy — the thing does not exist yet, and your job is to invent it, then make it something the org can run without you. If your best year would be spent tuning one system a few percent faster, you will be bored here. If you’d rather build the thing that goes to Mars — and you’ve already been the person whose designs your org couldn’t ship fast enough — keep reading.

What you’ll do

• Decide what should exist. Find the highest-leverage problem no one has scoped yet, frame it so engineers and executives both get it, and set the technical direction the team aligns to.

• Build it end to end. Whiteboard, prototype, architecture, production — you take ambiguous problems (sometimes the overnight fire-drill) all the way to something operable, and you can still go deep in code when it matters.

• Build with AI as a first-class tool. Extend our in-house, cloud-hosted agentic AI platform — including self-hosted models that already resolve a meaningful share of alerts with no human in the loop — and use it to make previously impractical problems tractable.

• Replace bottlenecks, don’t optimize them. Re-architect the risky, manual pathways people fight today into secure, self-service tools with the right guardrails and audit built in.

• Multiply the org. Create the platforms, patterns, and standards other engineers build on; decompose big problems and hand off well-scoped pieces; grow a bench of builders and hold the quality bar on work you didn’t write — so you’re free to go work the next hard thing.

• Make the work legible. Socialize designs with senior leaders, defend an architecture to a room of principals and to the exec team in the same afternoon, and keep plans and outcomes visible as you go — real influence, not death by process.

• Own what you ship. Including light, event-driven on-call for the things you build — not a rotation for systems you didn’t.

What sets a Principal apart here

At this level, raw building is not the differentiator — with modern AI, strong engineers can produce in any stack. What separates a Principal is business translation and a company-scale mental map, plus the shift from out-building your peers to multiplying them. You find the problem no one has named, understand it more deeply than the people living it, turn “here’s what I want” into “here’s what you actually need,” and set a direction the org builds on. You’ve started making yourself replaceable on execution — because your time is worth more on the next unscoped problem. A great Senior out-builds the room; a Principal changes what the room can build.

What we’re looking for

• A builder’s track record at scale. You’ve shipped tools and platforms others now depend on — things that didn’t exist before you built them, used well beyond your own team.

• Systems you can hold in your head. You reverse-engineer and understand complex, cross-team systems before you change them.

• AI as a build accelerant. Fluency with LLMs, agents, and self-hosted models, and the judgment to know where they create leverage and where they don’t.

• Force multiplication. You can name specific engineers you’ve made materially better, and patterns or platforms others now build on.

• Strong, general engineering ability. Full-stack and production-quality. We work primarily in C# and Go, with Python everywhere — we care that you can build, not that you’ve memorized our stack.Friction as opportunity. You can’t leave a normalized bottleneck alone.