Senior/Staff Integration Engineer

Stott and May; San Francisco (CA); On-site; USD 120,000 - 150,000; Full time

Job summary

Stott and May is seeking an Integration Engineer to develop production-grade integrations between Nexus and engineering software such as SolidWorks and CATIA. This role demands strong skills in C/C++, Python, and debugging instincts, with the goal of delivering multiple integrations each quarter.

Join a dynamic team focused on tackling complex software challenges that drive direct customer value, ensuring reliability in diverse environments.

Qualifications

• 5+ years building production software, with systems-level integration experience.
• Strong in C/C++, Python, or TypeScript, willing to adapt to SDK requirements.
• Experience with COM interfaces and native SDK bindings.

Responsibilities

• Own integrations from API research to production deployment.
• Navigate complex, underdocumented APIs.
• Deliver multiple production-ready integrations per quarter.

Skills

C/C++

Python

TypeScript

Debugging instincts

Production software development

Tools

SolidWorks API

COM interfaces

Native SDKs

Job description

Our company builds intelligent automation for mechanical engineering workflows. Our platform connects to the CAD, CAE, and PLM tools that engineers use every day — and makes them programmable. We're backed by leading investors, work with Fortune 100 companies, and are growing fast. Why Cosmon?

• Be part of AI that builds ships, planes, and rockets. Claude Code, but for mechanical engineers.
• Raised $32M from people who've seen this movie. Eric Schmidt, early backers of Anthropic and OpenAI, SV Angels, SPC, and Bison.
• Customers: Tesla. BMW. Meta. Amazon. Plus 1,000+ customers shipping production workflows on Nexus.
• A team that ships and publishes. Alumni of Google Brain, Airbnb, Stanford, and CMU, with research in Nature, NeurIPS, and ICLR.

The Role

You'll build production‑grade integrations between Nexus and complex desktop engineering software — tools like SolidWorks, Creo, Siemens NX, CATIA, ANSYS, Abaqus, and COMSOL. These aren't REST APIs with nice docs. They're COM interfaces, C/C++ toolkits, Java bridges, proprietary scripting layers, and thirty‑year‑old automation frameworks with sparse documentation. Your job is to make them all work reliably through a single platform.

You'll work on top of platform infrastructure owned by our platform team — they handle the desktop app framework, COM hosting, deployment, and enterprise packaging. You focus on what you're best at: figuring out how each engineering tool's API actually works, and shipping integrations that are reliable in the real world.

This is a focused, ship‑heavy role. We expect you to deliver multiple production‑ready integrations per quarter, each passing a defined acceptance checklist before handoff to the platform.

What You'll Do

• Own integrations end‑to‑end. From initial API research through production deployment. You scope the work, build it, validate it against acceptance criteria, and hand it off ready for the platform to consume.
• Navigate complex, underdocumented APIs. Many of these tools expose automation through COM, C/C++ SDKs, Java bridges, or proprietary scripting languages. You'll need to figure out what's actually possible, what's documented vs. what works, and where the gaps are.
• Ship at velocity. Deliver multiple production‑ready integrations per quarter. Our target is 2 integrations per engineer per month — you should be comfortable with that pace.
• Build for reliability in adversarial environments. Your integrations run on customer machines with different tool versions, license configurations, and environmental quirks. You design for graceful failure, not just the happy path.
• Contribute to integration patterns. Share learnings across the team. When you figure out a hard problem in one tool, document the pattern so the next integration benefits.
• Work cross‑functionally. Partner with the platform team on what infrastructure you need, with the agent team on what capabilities integrations should expose, and with domain experts who know the engineering workflows inside out.

What We're Looking For

• 5+ years building production software (8+ for Staff), with meaningful time spent on systems‑level integration work — connecting to third‑party tools, SDKs, or platforms where you didn't control the API.
• Strong in C/C++, Python, or TypeScript, with willingness to work in whatever language a given tool's SDK demands. Many of these integrations require C/C++ for native toolkits.
• Experience consuming COM interfaces, native SDK bindings, or IPC‑based APIs. You don't need to own COM infrastructure (the platform team does that), but you do need to be comfortable calling into it, understanding threading models, and debugging what goes wrong.
• Comfort with ambiguity and sparse documentation. You've shipped integrations where the official docs were incomplete or wrong, and you figured it out anyway — reading headers, experimenting, reverse‑engineering.
• Strong debugging instincts. When something breaks in a customer's environment but works in yours, you know how to isolate and fix it.
• Bias toward shipping. You'd rather ship a solid integration this week than architect a perfect abstraction next month.

Nice to Have

• Experience with engineering or scientific desktop software (CAD, CAE, FEA, CFD, PLM — any of it).
• Experience with vendor‑specific SDKs — SolidWorks API, Creo Toolkit, NX Open, CATIA CAA, ANSYS ACT, Abaqus Python API, etc.
• Background in mechanical engineering, aerospace, automotive, or adjacent industries.
• Experience writing integrations that needed to survive across multiple software versions and configurations.

Why This Role

• Hard, interesting problems. These are some of the most complex software integrations you can build — legacy APIs, real‑time desktop automation, thirty‑year‑old SDKs with undocumented behavior.
• Outsized impact. Each integration you ship unlocks an entire tool ecosystem for the platform. You'll directly see your work convert into customer value.
• Focused scope. You're not responsible for the desktop app, the deployment system, or the enterprise plumbing. You get to go deep on the integration craft.
• Early‑stage leverage. Small team, Series A, Fortune 100 customers. Your work shapes the product and the company.