Software Engineer — System Integration

Ramona Optics•Durham, NC

4d•Onsite

About The Position

We are looking for a Software Engineer to own the moment our hardware meets our software — the system integration phase where a microscope goes from a collection of cameras, stages, boards, and optics into a working MCAM ready to ship, and the moments after, when a customer in the field needs help getting the most out of it. This role lives on the build floor as much as in the codebase. You will work shoulder-to-shoulder with our build and manufacturing engineers, writing the Python tooling that brings new microscopes up, debugging the messy problems that only appear when real hardware meets real software, and pushing our instruments to their performance limits on the bench so we know exactly what they can do before they reach a customer. You will also be the person our customers hear from when something goes wrong in the field — answering remotely most of the time, and traveling on-site (about 10% of the time) for the trickier hardware/software diagnostics that can only be done in person. We want someone who finds failure modes fast, gets them addressed, and gets instruments shipped with confidence. Roughly 60% of the work is system integration during builds — bring-up, characterization, and debugging across the hardware/software boundary. Another 20% is production test and validation of finished microscopes before they leave the building. The final 20% is customer support: helping customers remotely troubleshoot hardware and software issues, and traveling on-site (approximately 10% of your time) to diagnose and resolve the trickier failures in person. As builds and field issues reveal gaps in our procedures, you'll author the new SOPs and acceptance criteria that fill them. The problems you'll face haven't been solved before, often haven't been seen before, and rarely come with a clear path forward. Creative problem-solving isn't a bonus here — it's the core of the work.

Requirements

Bachelor's or Master's degree in Computer Science, Software Engineering, Electrical Engineering, or equivalent experience.
1–3 years of professional experience writing software that touches hardware.
Strong proficiency in Python on Linux.
Hands-on experience with at least some of: serial port communication, ARM-based microcontrollers, CAN bus, I2C, and image acquisition with OpenCV.
A debugging instinct that doesn't stop at the language boundary — comfortable reading firmware logs, sniffing a bus, and reasoning about timing.
Comfort working physically next to the hardware: on the build floor, at the bench, with cables and boards in hand when needed.
A bias toward shipping. We want someone who pushes our instruments hard on the bench to characterize their limits, but who also knows when a system is good enough to go out the door.
Strong written and verbal communication — you'll be writing SOPs and bug reports that other engineers and technicians rely on, and explaining tricky issues to customers who may not share your technical background.
Comfort working directly with customers: patient, professional, and able to keep a clear head when someone on the other end of the line is frustrated with their instrument.
Willingness to travel domestically and occasionally internationally (~10% of the time) to customer sites.
Ability to collaborate across disciplines: build technicians, hardware engineers, software engineers, scientists, and end customers.

Nice To Haves

Experience with cameras, motion control, or optical systems.
Experience building internal tooling for a manufacturing or build team.
Experience with CI/CD and automated test infrastructure.

Responsibilities

Bring up new MCAM instruments on the build floor: validate camera arrays, motion stages, illumination, and embedded subsystems behave correctly together.
Write Python tooling and scripts that build engineers and technicians use daily to characterize, calibrate, and verify instruments.
Debug issues that span the hardware/software boundary — the kind where it's unclear whether the bug is in firmware, a serial command, a driver, or the application layer — and drive them to the root cause.
Develop and run production test and validation procedures for finished microscopes before shipment.
Support customers remotely when their instruments have hardware or software issues — diagnosing problems over email, video, and logs, and guiding them through resolution.
Travel on-site to customer locations roughly 10% of the time to execute the trickier diagnostics and repairs that can't be handled remotely.
Triage and reproduce field issues reported from deployed systems, and feed fixes back into the build process so the next instrument off the line is better than the last.
Author new integration and test procedures (SOPs, acceptance criteria, checklists) as builds reveal gaps. You won't be handed a complete playbook — you'll help write it.
Work directly with build engineers, technicians, and the broader software team to shorten the time between "instrument assembled" and "instrument shipped."
Document known limitations, failure modes, and reliability guarantees so the rest of the team can trust the systems we ship.