Senior Systems Engineer

Loophole Labs works on low-level problems in distributed systems, like eliminating application cold starts and migrating running workloads across regions. Our first product is Architect: a Kubernetes runtime that hibernates idle pods in place and wakes them in 50ms with TCP connections intact. Process state and mounted volumes survive too. Customers run it for workloads where cold starts hurt, e.g. real-time voice and video AI agents, long-warming JVM applications, and stateful data services that cannot be rescheduled cheaply.

We're seed-stage and VC-funded, with a few years of runway. Commercial first, with parts of the stack open-sourced where it doesn't compromise the business. The team is fully distributed across the Americas and Europe, and Slack is the office. We get together in person at off-sites a few times a year.

This role spans more of the stack than most. What follows is a snapshot: what we're working on this quarter, who's deep in what right now. Six months from now, who is working on what will look different. We hire for the range, so the team can move people across surfaces without breaking stride.

You'd be the 6th engineer. The checkpoint primitives are shared; the surfaces above them are split across storage and checkpointing, networking, and CUDA for remote GPUs. The GPU stack reaches into AI inference and training, and reuses the same checkpoint work the rest of Architect runs on.

Architect 1.0 shipped in Q1 2026; you will join mid-way through 2.0. Fresh eyes on the gnarly parts. New components are coming: CRUISE to replace CRIU, and our own microVM to replace gVisor (performance overhead, no live checkpoint, container-structure friction), building on years of PVM work (KubeCon 2023 talk).

What the team is shipping right now. We'll match the work to your strengths:

• ›Hibernation surface. Containerd shims and CRUISE, our Zig-native CRIU replacement.
• ›Control plane. A per-node DaemonSet streaming checkpoints; an admission controller resizing hibernated pods in place.
• ›Networking and migration. eBPF/XDP at line rate; cross-node live migration to production.

If you want layers of management between you and production, OKR cascades, and quarterly performance reviews, this isn't it.

• ›Your week. 70% deep work, 20% pull request reviews, 10% meetings. Daily overlap 4pm–7pm UTC. Slow is smooth, smooth is fast.
• ›Ship, mature, support. Consistent release cadence (see changelog). A handful of us are on-call. If you wrote it and it runs in production, you are responsible for it.
• ›AI-native workflow. AI runs across the team for code generation, documentation, and ramp-up into unfamiliar parts of the stack. Humans are still responsible for what we review and ship.

# Must Have

• ›Years across the stack. Assembly, drivers, networking, storage, virtualization, cloud, high-level languages, frontends, backends.
• ›Hardware-near chops. A driver from scratch (network, disk, or graphics), or firmware, or something equally close to silicon.
• ›Comfort with assembly (x86 minimum) and what sits underneath: instruction sets, registers, memory layouts, calling conventions.
• ›Scientific method, instinctively. Assumptions are bugs until measured. When you do not know, you say so and find out.
• ›Cross-layer debugging at scale. Kernel through control plane through network, with a track record of keeping production running through it.
• ›Adaptability. New tools, languages, subsystems. You ramp up without needing hand-holding.
• ›Strong proficiency in Go, plus the disposition to switch languages when the work demands it.
• ›Strong writing and communication. Senior engineering is half writing: PRs, RFDs, team discussion.
• ›The hard part is the human part. Writing code has never been easier; relating to teammates, customers, and the wider community has not gotten easier at all. Reviews, RFDs, mentoring, customer support, public writing are where senior engineers add the most value over time. If LLMs make you 10x faster at coding, we expect the extra capacity to go into those.

If you're strong on the systems depth and can learn the rest, apply. We have hired this way before, and the Must Have list above is meant as a starting bar.

# Strong Plus

• ›Hands-on with eBPF/XDP: BPF programs, maps, verifier constraints, line-rate benchmarking.
• ›Experience with checkpoint/restore (CRIU or equivalent), including test harnesses against real workloads.
• ›Deep with Linux kernel internals: namespaces, cgroups, process lifecycle, network stack.
• ›containerd internals, custom shim development, or CRI plugin work.
• ›Hands-on with Kubernetes admission controllers and DaemonSets.
• ›Familiarity with Zig.
• ›Live migration (VM or container) at scale.
• ›Public writing, talks, or open-source contributions in kernel, container, or eBPF adjacent spaces.

• ›Methodical and exact. The right answer is the measured one, even when measuring is the slow path. Correctness is never traded for speed; tests ship with the code.
• ›Peer-to-peer, decisions in writing. No engineering managers between you and the code. PR reviews raise the bar; pairing, shared incidents, and RFD threads fill the rest. Disagreements get worked out in writing; the person closest to the problem makes the call. The ladder runs senior to staff to principal; nobody climbs by managing.
• ›Close to customers, public about your work. Customer support is part of the job; you talk to people running Architect in production. A blog post every few months; talks and podcasts encouraged.

• ›Base salary. $150,000 – $195,000 USD.
• ›Meaningful equity. Grant numbers are for team members, not strangers. Get through the process, meet the team, and by offer we will have earned each other's trust. That is when we walk you through what you would own. Committed in writing; issued the following quarter, backdated to your start date.
• ›Unlimited PTO. 15 days per year minimum. Everyone is off for two weeks around Christmas.
• ›$5,000 hardware budget.
• ›Learning and conference budget.

We respond to applications within 4 business days. End-to-end is typically 2 weeks from application to offer.

1. 1.Apply to hiring@loopholelabs.io. Send your resume, plus a paragraph on what part of Architect 2.0 you'd want to dig into first, and what gap you'd close to do it well. What you already know is the baseline. How you'd think about Architect 2.0 is the signal.
2. 2.Share your feedback on Architect. Go through the docs, try it out, and let us know what worked well, what didn't, and what you would improve first. Your feedback goes to the engineers either way. We learn from it as much as we learn about you.
3. 3.Technical conversation with our CTO (45 mins). Deep dive on systems work you have shipped. We want to understand how you think about correctness, scale, and debugging.
4. 4.Founding engineer conversations (2 × 45 mins). Mutual fit, technical challenges worth nerding over.
5. 5.Offer. Within 3 working days of your last conversation.

# Read before applying

If these bore you, this job will too:

• ›XDP for egress traffic
• ›Rethinking spot instances