Coordinator Software Localization Engineer Jobs in Phoenix, AZ

You will...
- Drive Technical Execution: Lead the end-to-end systems engineering lifecycle for the Sensing, Perception, Maps, and Localization domains, ensuring timely delivery of robust solutions across hardware and software teams.
- Architect Requirements: Create and refine Autonomous Vehicle (AV) Requirements using analytical and numerical methods, focusing on sensing capabilities, perception performance, sensor fusion, mapping, and pose estimation.
- Own the Contract: Own the definition and requirements development of the Sensing, - - - Perception, and Localization contracts, covering sensor performance, calibration, data quality, and system degradation strategies.
- Lead Cross-Functional Integration: Act as the primary technical liaison connecting AI and software engineers, hardware engineers, and safety teams to resolve complex system-level bottlenecks and build consensus on architectural trade-offs.
- Validate via Data: Create methods and use physical and simulated data to inform and verify principled requirements for the entire sensor suite and localization pipeline.
- Advance Simulation: Improve the simulation and synthetic data generation of sensor models for AVs.
- Build the Safety Case: Directly contribute to the system safety case by mapping high-level safety goals to deployed architecture, ensuring traceability from requirements through to verification and validation (V&V).
- Elevate the Team: Mentor junior and mid-level engineers, fostering a culture of rigorous systems engineering, proactive risk management, and flawless execution within the Platform team.

Qualifications:
- Experience: 3+ years of industry experience in autonomous vehicles, robotics, or aerospace, with a proven track record of taking complex autonomous systems from R&D to deployment.
- Domain Expertise: Strong foundation in AV systems, specifically in sensing (Lidar, Radar, Camera), perception algorithms, sensor fusion, mapping, and localization (e.g., GNSS/INS, SLAM, odometry).
- Technical Breadth: Deep knowledge of sensor physics, signal processing, data acquisition/management, and dealing with correlated system errors.
- Systems Rigor: Expert knowledge of Systems Engineering and Verification & Validation (V&V) best practices, including requirements decomposition from high-level safety goals into detailed, verifiable functional and technical specs for Level 4 AV systems.
- Safety Standards: Working knowledge of functional safety standards (e.g., ISO 26262) and translating probabilistic safety goals into physical, quantifiable metrics.
- Programming: Comprehensive coding skills in Python, C++, or other common programming languages used for data analysis and systems modeling.
- Simulation & Modeling: Extensive experience in sensor simulation, error modeling, and perception/localization requirements development.
- Communication: Exceptional communication and stakeholder management skills, with the ability to distill complex technical risks into actionable decisions for leadership.

Bonus:
- AI/ML Integration: Experience working alongside generative AI architectures or integrating ML-based perception algorithms into deterministic, verifiable safety cases.
- Advanced Safety: Familiarity with SOTIF (ISO 21448) and handling unknown-unsafe scenarios in autonomous driving.
- End-to-End Systems: Applied and proven experience in building end-to-end perception or localization systems (e.g., object detection, tracking, scene understanding, HD map integration).
- Calibration Operations: Experience with sensor calibration and synchronization methods specifically for commercial trucking or heavy machinery.
- Testing at Scale: Applied and proven experience with defining and executing test cases for perception/localization system performance (e.g., edge cases, challenging weather, GPS-denied environments).
- Domain Passion: A strong passion for robotics systems and an intuitive understanding of actual electro-mechanical problems in the context of self-driving or robotics.
- Tooling: Coding in Rust and using build and test automation tools.