Web Developer Internship Jobs in Pittsburgh, PA (NOW HIRING)

About Phlux
Industrial robots are fast, heavy, and unforgiving, so they get fenced off. The devices that guard them - light curtains, laser scanners, safety mats - mostly protect a flat plane or a patch of floor, which forces a big rectangular cage around the machine, eats floor space, and halts production every time somebody steps too close.
We build a 3D safety sensor that changes the shape of that problem, literally. It monitors a programmable three-dimensional protection zone around a robot, detects in real time when someone enters it, and drives safety outputs wired into the customer's safety controller. Safety itself is table stakes - every plant already has to meet it. What a 3D zone adds is flexibility: cells shaped to the actual work instead of a rectangle, people and robots far closer together, less floor space, and far fewer stoppages.
Getting there means solving a hard set of problems at once: optical sensing, real-time detection on constrained hardware, precise timing, calibration, and designing something that has to keep behaving correctly even when parts of it fail.
We're a small, NSF-funded team in Pittsburgh. We've deployed units, tested them with real customers, and have more in front of us - this isn't a research project hunting for an application.
Your role
You'd work on the software that surrounds the sensor: the applications engineers use to configure and commission it, the visualizations that show what the device is actually seeing, the services that move data off the hardware, and the tooling we use to test all of it. Some of that is polished product. Some of it is a rough prototype built to answer a question in a week.
Because the team is small, you wouldn't be siloed. You'd work alongside engineers across mechanical, optical, firmware, and software - often on the same problem in the same room. Most interns and co-ops spend a term on a walled-off side project that gets archived when they leave. You'd be in the middle of how the product actually gets built, and you'd see the whole path from an idea to something running on real hardware in front of a customer.
What you could work on
Depending on where you're strongest and what we need at the time, this could include:
- Desktop and web applications that engineers use to set up, monitor, and troubleshoot the sensor
- Real-time 3D visualization - rendering sensor data and geometry so people can see what the device sees
- Device communication - services that move data between hardware and applications, including binary protocol work
- R&D and prototyping - quick exploratory code for things we're evaluating: new sensors, embedded hardware, approaches we want to try before committing to them. Some of it turns into product; some of it answers a question and gets thrown away
- Data pipelines and analytics tooling for turning raw sensor output into something people can reason about
- Test tooling and automation - fixtures, simulators, and the harnesses that let us verify behavior without hardware in the loop
- Documentation and written procedures, so what you build survives you
We'd shape your first project around what you're actually good at - figuring that out is part of what the interview is for. Whatever it ends up being, it's real work that ships, not something invented to keep a co-op busy.
What we're looking for
Minimum qualifications
- 3rd or 4th year undergraduate, or Master's student, in Computer Science, Computer/Electrical Engineering, Robotics, or a related field
- You can write working code yourself - strong in at least one of Python, TypeScript, C, C++, or Rust. Most of what you'd write here is Python and TypeScript, but real depth in a systems language transfers fine, and you'd pick up the rest as you go
- You can read unfamiliar code and judge it. Handed a 500-line file you've never seen, you can say what it does - and whether it's doing it correctly. Code that compiles and passes its tests can still be wrong, and noticing that is a large part of this job
- You know what "right" should look like before you see it. You can hold a picture of how something ought to behave, then recognize when what's in front of you doesn't match
- You debug by reasoning, not by guessing. When something breaks you form a hypothesis and test it, rather than changing things until the symptom goes away
- Able to read C. A lot of our codebase is C. You wouldn't be writing it, but you'd be reading it regularly to understand what the hardware is doing and what the data actually means
- Comfortable with Git and normal collaborative development
- You can write clearly. You'd be documenting what you build and explaining your reasoning to people who weren't in your head when you built it
- Something you built that nobody assigned you. A game, a tool you made because you needed it, something that talks to an Arduino or a Pi, a robotics project, a mod, an open-source contribution. This matters more to us than GPA or coursework.
Preferred qualifications
- Microcontroller or embedded work (Arduino, STM32, ESP32, Raspberry Pi)
- 3D graphics or game development - WebGL, Three.js, Unity, shaders, or similar
- Anything that talks to hardware over a serial port or a socket
- Robotics or computer vision background (ROS, point clouds, camera calibration, 3D math)
- React, Node, or desktop application development
- Experience with binary formats, wire protocols, or serialization
Not required: knowing our exact stack. You'll learn it.
What you'd gain
- Ownership. Your work ships. Nothing you build sits in a branch waiting on a committee, and nobody quietly rewrites it after you leave the room. You'd watch your own code run on real hardware.
- Problems that are actually hard. Real-time detection, 3D geometry, optics, hardware timing, safety-critical reasoning. These aren't problems you solve by wiring a form to a database - you'll hit things nobody has written the answer to yet, and have to reason your way through them.
- Breadth. Application development, 3D rendering, hardware communication, R&D prototyping, and test infrastructure - in one role, in under a year. At a large employer you'd get one of those and wait three years for the next.
- Mentorship you can actually reach. You'd work directly with experienced engineers across mechanical, optical, firmware, and software. There's no layer between you and the people who know the answers.
- Pace. Decisions happen in a conversation, not a quarterly planning cycle - something broken on Tuesday can be fixed by Thursday. It cuts both ways: priorities move, and work you started last week can get reordered by a customer call.
Being honest about what this is
- We're a small, early-stage team. You'd be joining early enough that what you build genuinely matters.
- The codebase is large and established. A real part of this job is reading code you didn't write, understanding it quickly, and reasoning about whether it's correct. If you only enjoy greenfield work, this isn't the right fit.
- We're rigorous about verification. We're building toward formal third-party safety certification, so "the tests passed" is not the same as "it works." You'll be expected to think about what your tests can't catch - that habit is most of what we're hiring for.
Logistics
- Hours: Full-time during the rotation. We'll work out timing and schedule with you.
- Pay: ~$20-30/hr, depending on experience and where you are in your program
- Location: On-site in Point Breeze. The hardware is here, and being in the room is how you get up to speed fastest. Once you're established, we're flexible about remote days.
- Eligibility: Junior, senior, or Master's student in CS, CE, ECE, Robotics, or similar.
To apply
Submit your résumé and a link to something you've built - GitHub, a project write-up, a demo video, a thing that mostly works - anything. In two sentences: what it does, and what was hard about it.