Senior Network Engineer

About this role

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. This is a founding role in its discipline. There is no network team to join and no inherited design to defend — the architecture, the automation, and the operational model are yours to set.
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 someone who understands networks from Linux host to data-center fabric to carrier connectivity to cloud, and can automate the whole path.
A customer's traffic has to reach a GPU workload, securely and reliably, over a path that no single party controls: their edge, a carrier, our side, a provider's side. Any hop on it can be the reason something is slow, unreachable, or leaking, and the answer is rarely in the place the symptom appeared.
Making one such path work is a good week for a competent network engineer. That is not this job. This job is the second path, and the fiftieth — how much of it can be made to provision itself, which parts genuinely have to stay bespoke, and how little a customer should have to do to get connectivity they would call enterprise-grade. Those questions are open here, and whoever takes the role is the one who closes them. That is why networking is part of the product rather than a support function beneath it.
This is not a traditional network-operations role. We do not need someone who waits for a change ticket to configure a switch. We need a network engineer who codes, debugs systems end to end, participates in architecture, and owns production outcomes.
What You Will Own
Not tasks. Outcomes, and the authority that comes with them.

• The whole path from a customer to their workload. Customer edge, carrier, our fabric, the overlay, the host — and the requirement that the next customer's path cost a fraction of the effort of the first.

• Routing and segmentation. BGP, VLANs, VRFs, firewalling, and policy, including what all of it does during a failure rather than on a diagram.

• Tenant isolation, and the ability to define "isolated" precisely enough that it can go in a contract.

• Secure private access. WireGuard, IPsec, and overlays — where tunnels terminate, why there, and what happens when that site is unreachable.

• The fabric inside our facilities, and how it meets the fabric belonging to people we do not control.

• Carrier and cloud connectivity. Cross-connects, transit, private circuits, and NaaS, including the commercial and lead-time realities that come with them.

• Network observability and incidents, including the ones that arrive disguised as an application problem.

• The layer-boundary call. Host, overlay, cloud network, physical network, or carrier — you decide which, and you prove it instead of escalating it.

• Turning the above into product. Provisioning that runs without you, and connectivity patterns that engineers who are not you can deploy safely.

• Working alongside the infrastructure and inference engineers on RDMA, multi-node GPU traffic, topology, and performance.

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

• Run BGP in production, including on the day it did something you did not expect.

• Designed and operated VLANs, VRFs, segmentation, and firewall policy at a scale where mistakes were expensive.

• Troubleshot Linux networking on hosts carrying real traffic.

• Worked inside a data-center network rather than only in front of one.

• Operated cloud networking in at least one major cloud.

• Built connectivity on IPsec and/or WireGuard that customers depended on being up.

• Kept tenants apart from each other and been personally accountable for that claim.

• Chased a packet flow across administrative domains you did not control until you found the truth.

• Replaced manually managed device configuration with automation that kept working while you were on holiday.

• Written Python and Terraform that other people run in production.

• Reasoned about how a networking decision would change the behaviour of the distributed system sitting on top of it.

You Will Be Especially Strong If

• You have worked at a hyperscaler, neocloud, hosting provider, data-center operator, network provider, AI infrastructure company, or enterprise networking vendor.

• You have designed or operated networks supporting GPU, HPC, storage, or other high-bandwidth distributed workloads.

• You understand RDMA and the network requirements of multi-node GPU workloads.

• You have experience with carrier connectivity, cross-connects, internet transit, private circuits, or NaaS platforms.

• You have built network automation instead of relying on manually managed device configuration.

• You have turned a connectivity pattern into something repeatable enough that non-network engineers could deploy it safely.

• You are comfortable debugging from application symptoms down to packets and physical paths.

• You run labs, write tools, or experiment with networking outside your assigned day-to-day work.

This Is Probably Not For You If

• You primarily configure network devices through tickets and change windows.

• You do not code.

•…