Company Overview
Enablence USA Components, Inc. is a pioneering provider of integrated optical products serving the communications, aerospace, and bio-chemical sensing industries. Our innovative solutions are utilized globally, playing a vital role in fiber-optic networks worldwide. Recently, we have advanced into photonic integrated circuits (PICs) based on silicon platforms and launched high-speed optical sub-assemblies for metro-area and data center interconnection markets.
About the Role
We manufacture photonic chips—the optical engines solving the interconnect bottleneck in the AI compute buildout. They are built on wafers in our own fabs through deposition, lithography, etch, dicing, and test, and every wafer that runs throws off images, measurements, and traceability data. We run that line on systems we build ourselves, across multiple sites and time zones. We are building the physical backbone of the next computing era.
The software is the line. Our production system decides which wafers run, on which tools, in what order, and it holds the traceability record for every one of them. When it is wrong, wafers scrap. When it is slow, the line waits. You would join IT engineers, software developers, cloud engineers, and AI specialists building that system and the platform underneath it — the services, data pipelines, and interfaces that turn a fab floor into something engineers can reason about and operate at scale.
Our engineers work directly with the people who use what they build. You will spend time with process engineers, equipment engineers, and technicians on the floor, because the difference between software that helps the line and software that gets tolerated is usually a detail you only find by watching someone use it during a shift.
This is not a maintenance role. We are moving from systems that work to systems that scale: multi-site, hybrid cloud, containerized, deployed continuously, with the data layer to support process engineering and yield analysis rather than just recordkeeping.
The way software is built has also changed here, and we mean it. We use AI coding agents as working collaborators across the engineering org, and we expect you to work the same way — including in how we test, review, and ship.
What You Would Get to Build
1. The Production Platform
- Features the fab uses every shift: work order routing, metrology-driven wafer selection, batch and capacity constraints, and traceability across every process step.
- Integrations with fab equipment and metrology systems, where data arrives messy, late, or not at all, and the system has to stay correct anyway.
- APIs and service boundaries that let the rest of the engineering org build against the line without reaching into its internals.
2. Hybrid Cloud, Multi-Site Scale
- Services that span AWS and on-premise infrastructure at every site, because some workloads have to sit next to the tools they talk to and some belong in the cloud.
- Systems that hold up as wafer volume, site count, and user count all climb at once — and that degrade gracefully when a site loses its link rather than stopping the line.
- Containerized deployment and infrastructure as code across that footprint, with the operational work that comes from running your own platform rather than renting one.
- Data pipelines that move measurement, image, and traceability data from every site into a form process and yield engineers can actually query.
3. Interfaces People Trust
- Screens used under time pressure, where a confusing filter or an ambiguous state costs real wafers.
- Interfaces that work on the canvas the user actually has: a touchscreen at a tool with gloved hands, a tablet walking the floor, a workstation with three monitors and a hundred-thousand-row grid.
- Different audiences, deliberately served. A technician needs the next action and nothing else. A process engineer needs to compare across lots. A researcher needs the raw measurement. A manager needs to know whether the week is on track. Those are four different products sharing one data layer, and pretending they are one screen is how you end up with a screen nobody likes.
- A coherent design system rather than a per-page accumulation of decisions.
4. Secure by Design
- Authentication, authorization, and audit built in as the system is designed, not retrofitted before an audit.
- Least privilege across services, secrets handled properly, and dependencies you can account for.
- Threat modeling as a normal part of design review — knowing what an interface exposes before it ships. We go through security audits on a regular cycle, and clean code review is part of how we pass them.
5. Agentic Development and Delivery
- Workflows that let agents contribute safely to production code: clear conventions, current documentation, and tight test coverage where it matters.
- CI/CD that catches what human review misses — automated checks, coverage gates, and pipelines fast enough that nobody routes around them.
- Codebases structured so that both engineers and agents can work in them without guessing.
What We Look For
Core Engineering
- 5+ years building and running production software, with real depth in at least one of Python, TypeScript, or Go, plus enough scripting to be dangerous across Linux and Windows.
- Data modeling instincts. You have designed schemas that outlived the assumptions they were built on, and you know what it costs when they do not.
- Systems that cannot be wrong. Experience with software where incorrect state has physical or financial consequences — manufacturing, logistics, payments, healthcare, or similar.
- Security as a design constraint. You threat model before you build, you understand authentication and authorization boundaries, and you treat least privilege and secret handling as part of the work rather than a review gate to clear.
- Judgment about scope. You know which problems need architecture and which need a small change shipped today.
Cloud and Platform
- AWS in production. Compute, networking, IAM, and managed data services, with an understanding of what each choice costs.
- Hybrid and distributed reality. You have built systems spanning cloud and on-premise, or across sites, and you have opinions about state, latency, and what happens when the link drops.
- Containers and infrastructure as code. Docker, and Terraform or OpenTofu.
- Scaling under real constraints. Query performance, background job orchestration, and the point at which a working design stops working.
- CI/CD ownership. You have built and debugged pipelines, not just consumed them.
Users and Interfaces
- You care how it feels to use. You have sat with the people who use your software, and it changed what you built. This is not a nice-to-have here; it is most of the difference between a useful system and an ignored one.
- Multiple audiences and form factors. You can reason about what a technician needs versus an engineer versus a manager, and you have built for touch as well as desktop.
- Frontend depth is a plus. Component architecture, state management, and rendering large datasets without falling over. You can build a genuinely usable screen without waiting for a designer, and you know when to wait for one.
Also a Plus
- Data science or analytics background. Statistical process control, experiment design, yield or defect analysis, or ML on manufacturing data. A lot of what we build exists so that this work is possible, and someone who has done it builds it differently.
- Semiconductor, hardware, or process manufacturing exposure. Useful, not required. We can teach the fab; we cannot teach engineering judgment.
How We Work
- You already use coding agents daily. You have opinions about where they are reliable, where they need bounding, and how to review what they produce. We are not asking you to be curious about this; we are asking you to already do it.
- Review over authorship. When generating code is cheap, the work moves to interface boundaries, invariants, and verification. You read diffs carefully and you know what a plausible-looking wrong change looks like.
- Knowing when not to. A twenty-line script often beats an agent loop. You reach for the simpler thing.
- Writing things down. Documentation is what makes both your teammates and your agents effective. You do not treat it as overhead.
Tech Stack
Familiarity with modern equivalents counts. We are not looking for a checklist match.
- Languages: Python, TypeScript / Node.js, Go, Bash, PowerShell
- Application: Django, PostgreSQL, REST APIs
- Frontend: Modern JS frameworks, Bootstrap, component-driven CSS, responsive and touch interfaces
- Cloud and Infrastructure: AWS, Docker, ECS, Terraform / OpenTofu, Linux, Windows Server, on-premise at every site
- Data: Dagster, SQL at depth, warehouse and lakehouse patterns on S3 / Athena
- Delivery: GitHub Actions, containerized local development, automated testing and coverage gating
- Agentic Development: Claude Code, Model Context Protocol, structured tool calling
What We Offer
- You drive this. How the platform evolves is yours to shape — working with the cloud, IT, and software engineers who own the systems around it.
- Real consequences. Our fabs run around the clock. What you build either helps get wafers out or gets in the way, and you find out which within days.
- Users you can reach. The people who depend on your software are a conversation away, not behind a product organization.
- A team that already works this way. Agents are in our engineering lifecycle now, not on a roadmap. You will not be arguing for permission to work the way you already work.
- Flexibility and benefits. Remote-first with hybrid options, paid time off, and full benefits.
Benefits:
- 401(k)
- Dental insurance
- Health insurance
- Life insurance
- Paid time off
- Vision insurance
Work Location: Remote
