Anduril Maritime builds autonomous underwater/surface vehicles: autonomy computers running control and mission logic, payload computers driving sonar and other sensors, surface integration units, and ground control stations. We're past the "does it work in the lab" phase - vehicles are in the field, and field vehicles find bugs the lab never does. We need someone whose job, starting day one, is to pick up those bugs and actually close them: reproduce it, find the real cause, fix it, ship it, tell the team what happened.

To be clear about what this isn't: it's not a ticket-triage-and-forward job, and it's not "junior dev does the boring work while senior devs build features." You'll be shipping real fixes in the real codebase. You're just entering the codebase through "this broke on a vehicle" instead of "here's a clean feature spec." Once you've built up cross-subsystem fluency - which this role forces faster than sitting in one subsystem ever would - you move into owning subsystems and roadmap work like anyone else.

What you'll actually be doing

• Take a field-reported anomaly (sensor stopped publishing, mission faulted mid-track, data stream drifted for no obvious reason) and figure out what subsystem it's actually in - not just where it was reported.
• Reproduce it for real. Replay recorded sensor/mission data through the live pipeline, pull it into visualization tooling, don't guess.
• Use the metrics and log infrastructure that already exists (per-service metrics, dashboards, centralized logs) to reconstruct system state at the moment things went wrong, instead of re-running until you get lucky.
• Confirm the fix in a simulated environment first, hardware-in-the-loop where that matters, before it goes anywhere near a real vehicle.
• Write the fix in whatever language the subsystem actually uses - Rust, C++, Python, Go, whatever — with tests, through CI, out through the normal versioned rollout. No special "triage" shortcut path.
• Figure out whether the actual problem is a bug, a bad config, or a deployment mismatch, and fix it at the layer where it actually lives instead of patching around it one level up.
• Write down root cause and fix for every issue you close. Not for the paperwork — so we can see, over months, which subsystems keep breaking and which tests we're missing. Help build the on-call/triage runbook this team doesn't have yet.
• Push back to the owning team when the real fix is "this subsystem needs to change," not "patch the symptom and move on."

 What you need to already have

• Real experience debugging code you didn't write, under time pressure, with incomplete information. This matters more than which language you know best.
• Enough comfort in at least two of Rust, modern C++, Python, Go to read and fix bugs in them. You don't need to be an expert in all four - you need to not freeze up when you're dropped into one you know less well.
• Systems-debugging instincts: pull logs and metrics, reconstruct what happened, reproduce offline from recorded data instead of only live.
• Some real exposure to observability tooling (Prometheus/Grafana-class metrics, Loki/ELK-class logs) — you should already know how to use this stuff, not learn it here.
• Linux and systems fluency. Bonus if you've touched declarative/immutable OS setups (NixOS-style).
• The ability to write up what actually happened clearly, without padding it out or burying the cause. "The vehicle did something weird" is not an acceptable final answer from you.
• Willingness to work close to hardware and sensors even if you've never touched maritime or robotics before. We're not looking for domain background, we're looking for the debugging instinct.
• Willingness to travel 25%+ of the time on average

Nice to have, not required

• Robotics middleware, sensor drivers, or real-time data pipeline experience (sonar, radar, lidar, whatever).
• Time in simulation-in-the-loop or hardware-in-the-loop test setups.
• CI/CD and versioned deployment experience for embedded or fleet software.
• Actual on-call or field-support experience for hardware that ships to real users, not just internal tools.

Where this goes

• This is a real entry point, not a holding pen. Do this well and you'll know more of the stack than most people who joined doing greenfield feature work — and that's exactly who ends up owning subsystems and driving roadmap next.