Product Designer→UX Engineer
For product designers who want to build what they design: HTML and CSS depth, JavaScript and React, component architecture, performance and the constraints engineers work within.
- A trained eye for spacing, type and hierarchy
- Designing flows and states
- Running crit and taking feedback
- Talking to users and stakeholders
- Writing production-quality HTML, CSS and JavaScript
- Thinking in components, props and state
- Measuring and fixing performance
- Working inside a codebase and its review process
Who this is for
You design product interfaces. You run crit, you think in flows, and you notice when something is off by a few pixels. Maybe you are tired of handing off a careful design and seeing a rougher version ship. Or you want to prototype the interactions that static mockups can't show. That is a strong reason to move toward UX engineering.
Your advantage is taste and judgement. You already know what good feels like, and you know how to talk to users, product managers and other designers. Many engineers spend years building that eye.
The gap is the engineering. Building something that looks right in a demo is not the same as building something that works in a real codebase, on slow phones, with real data and for every user. Code that ships also has to be readable, reviewable and maintainable by other people. This path is long because that part takes reps.
How the work changes
Today your output is a design that describes what should happen. In UX engineering, your output is the thing that actually happens. That moves the hard questions earlier. You will find out quickly which parts of a design are cheap to build and which are expensive, and you will start to design with that in mind.
Day to day, you will spend most of your time in an editor, a browser and a terminal. You will read other people's code more than you write your own. You will open pull requests, get reviewed and review others. You will learn to break a screen into components and decide what each one owns.
Your design skills don't go away. They show up in new places: in the API of a component, in how a loading state is sequenced, in the copy of an error message. You will often be the person in the room who can say both "this is better for users" and "here is how we build it".
HTML / CSS depth
You can build any static screen you design, responsive and accessible, without a framework.
Learn it hereShip itA pixel-close coded version of one of your real designs, live on a public URL.
JavaScript & React
You can add behaviour to an interface: events, state, data loading and transitions between states.
Ship itA coded prototype of a real flow, with every state working and a note on what the prototype taught you.
Component architecture
You can design a component API that other engineers can use without breaking the design.
Ship itA small component library built from your own designs, with tokens and usage docs.
Performance
You can measure why an interface feels slow and fix the causes that matter to users.
Learn it hereRead, watch, useShip itA before-and-after performance write-up of one screen, with measurements and the changes you made.
Engineering constraints
You can ship a feature through a real codebase and make trade-offs engineers respect.
Ship itA case study of one shipped feature that shows the design, the code and the trade-off you made.
Common traps
- Learning frameworks before the platform. React is easier when you understand HTML, CSS and the DOM underneath it. Start with the platform, then add the framework.
- Building only the happy path. Designs often show the ideal state. Code has to handle loading, errors, empty data, long text and slow networks. Build those first.
- Treating code review as criticism of your taste. Reviewers are checking that code is safe and maintainable. Ask questions, learn the conventions and save design arguments for design questions.
- Staying in prototype mode. Prototypes are great for answering questions, but the role needs code that ships. Make sure at least one project reaches production.
- Hiding the design work. Your design background is an advantage. Show it alongside your code instead of trying to look like a pure engineer.
How to show it
Your portfolio needs to prove you can ship, so make everything playable. Link live demos and code, not just screenshots. Pick a few projects that show the full arc from a design decision to working code.
Use the structure in A UXE portfolio: the interaction, the constraint and the decision. A strong designer-turned-UXE portfolio often includes one detailed interaction built in code, one component or small system with its API and docs, and one piece about performance or another engineering constraint that changed your design. The breakdowns, like form choreography or empty states, show one way to present the thinking behind a single interaction.
In interviews, expect to write or talk through code. Practise explaining a component you built: how you split it, what props it takes, how it handles state and failure. Then talk about a time engineering reality changed your design and what you did about it. That story shows you can hold both sides of the work.