Your path to design engineering
Design engineering is a discipline of ownership where the practitioner solves design problems while taking responsibility for their actual implementation.
Deep dive
- Design engineering is defined by taking responsibility for both the design solution and the code implementation.
- Frontend engineers should practice 'design judgment' by analyzing typography and hierarchy before opening an inspector.
- Designers should move beyond static screens by implementing state logic like validation and error recovery.
- The most effective way to learn is to work on small, complete projects that include error handling and keyboard accessibility.
- Use AI to explain code you don't understand, but perform the implementation changes manually to ensure comprehension.
- Projects should be shared early to invite critique on both the visual and behavioral trade-offs.
Original article
I’ve written about becoming a Design Engineer a few times, and the advice gets awkward when I try to give everyone the same starting point. An engineer who’s spent years shipping interfaces needs something quite different from a designer opening a codebase for the first time. Someone who’s just graduated might still be figuring out which part of the work they enjoy.
You bring something useful with you in each case. I’d start there, then look for the part of making a product that you currently need someone else to figure out.
For me, design engineering means being able to work through a design problem and take responsibility for its implementation. You can lean towards either discipline, and you’ll still need to ask for help along the way. What matters is understanding the decisions well enough to explain them, change them and deal with what happens when somebody uses the thing.
This is a little choose-your-own-adventure guide to practising that. Pick the closest starting point, even if your job title says something else. The exercises here focus on web interfaces so that you can try them in a browser and share the result easily.
You’re coming from frontend engineering
You already know how much happens after someone says a design is “done”. You’ve dealt with content that doesn’t fit, slow requests, missing states and components that have to work in places their author never imagined. That’s useful design knowledge, even if you haven’t been calling it that.
The next step is to get involved before the solution is settled. When someone gives you a screen to build, ask what the person using it needs to accomplish and which decisions are still open. Try proposing an alternative in the medium you know best. A small working comparison can make a conversation about hierarchy or behaviour much more concrete.
You’ll need to practise seeing, too. Pick an interface you think works well and explain why. Where does your eye go first? Which spacing decisions group related things? What changes when the copy gets longer? Rebuilding it can help, but spend time understanding the decisions before reaching for the inspector.
Build your foundations: redesign one decision
Take a settings form you’ve built, or make a small one with a name field, a notification preference and a save button. Keep the functionality fixed and make two versions of the layout. Change the grouping, type hierarchy and wording to make the consequences clearer.
Ask a designer to compare them with you. Be specific: “Can you tell which setting affects email?” is more useful than “Does this look good?” Then ask someone to use it without your explanation. Notice where their reading order differs from the one you intended.
Keep the working form and a short note about what you changed after the feedback. Try to connect each visual decision to something the person understood or managed to do. If all you can say is that it looks cleaner, there’s probably a bit more of the reasoning to work through.
Stretch your practice: own the brief
If you already make those visual decisions comfortably, take on a small problem before anyone has designed the answer. Find a confusing interaction in the product you work on and agree with your team what improving it would mean. That might be helping people recover from an invalid setting without losing their changes.
Write a short brief, build two plausible approaches and ask a designer and an engineer to challenge them. Choose one based on what you learn, then follow it through review and delivery. Keep the scope small enough that you can stay involved in the details.
Show the original problem and the alternatives you tried, including why you left one behind. That gives somebody else a way to follow how you arrived at the finished form.
You’re coming from design
You already have practice turning an ambiguous problem into something people can understand and use. Keep bringing that to the work. Learning to build will give you a way to test decisions that are difficult to settle in a static screen: how a layout responds, what happens during a request, or whether an interruption makes the interface confusing.
Start with a small piece of UI and follow it further than you normally would. A form is a good candidate because it quickly forces you to think about behaviour. Where does the data live while someone edits it? What happens if saving fails? Which element receives focus after an error?
Learn enough HTML, CSS and JavaScript to understand your answers. You can use AI to explain unfamiliar code and help with an implementation, but keep changing things yourself and checking what happens. If a suggested fix works, ask why the original broke and whether you could recognise the same problem elsewhere.
Build your foundations: make the states real
Design and build a small profile form. Start with labelled inputs and a button, then add validation, a saving state and a success message. A simulated request is fine for this exercise; make it possible to trigger a failure deliberately so you can design the recovery too.
Use the form with a keyboard. Try a narrow screen and a very long name. Make sure an unsuccessful save leaves the person’s edits intact. Ask an engineer to walk through your code with you, especially the relationship between the form’s state and what appears on screen.
Your deliverable is a working form with a short explanation of how it behaves. You should be able to change a validation rule, explain why the save button is available or unavailable, and trace an error back to its cause. Those are useful signs that you’re beginning to own the implementation.
Stretch your practice: work inside an existing product
If you can already build a convincing prototype, find a small improvement you can make in an existing codebase with the team’s agreement. Reuse its components and conventions. Work with its real data and error handling, and ask an engineer to review it as they would any other contribution.
This is where the interesting constraints show up. Your preferred interaction may conflict with an existing pattern. A component might serve several screens. You might discover that an apparently visual change affects keyboard navigation or the order in which data arrives.
Stay with the change through review, release and any fixes it needs. Keep a note of what changed from the prototype, because those are often the parts you’ll learn the most from and want to be able to explain later.
You’re starting out
You don’t need to decide your entire career before you’ve had a chance to try the work. If you’ve recently graduated, or you’re changing direction, a small complete project can help you discover which parts hold your interest and which ones you want help with.
Choose a problem close enough that you can speak to someone who has it. It could be finding the right room for a society meeting, keeping track of equipment you’ve lent out, or working out what information belongs in an event signup. Keep the first version deliberately small. One useful flow gives you plenty to learn.
Sketch it, build it, then watch someone try it. You’ll get more from that loop if you resist adding features until you understand what happened in the first version. A person hesitating over your carefully chosen label is excellent material to work with.
Build your foundations: finish one useful flow
Make a signup form for a fictional event. Explain who it’s for, what attending involves and what happens after submitting. Use HTML and CSS first, then add the JavaScript needed to validate the form and show a confirmation. Clearly label it as a demo so nobody expects a real booking.
Try it on your phone and with a keyboard. Ask someone to sign up and tell you what they expect to happen next. Revise the wording or behaviour where their expectation and your implementation disagree.
Keep the first version as well as the improved one. Write a short account of the problem, what you learnt from showing it to someone and what you changed. You now have a piece of work you can discuss in detail, including the bits you still need to learn.
Stretch your practice: invite a constraint you didn’t choose
If you’ve already built a few projects, make your next one involve another person’s requirements. Agree a small, low-risk contribution with a club, a community project or an open-source maintainer. Establish who will review it and look after it afterwards. If that isn’t available to you, ask a peer to write a brief and review what you make.
Work within an existing visual language or codebase. Share your work before it feels finished, explain your trade-offs and respond to the feedback. You’ll practise something that solo projects can avoid: making a good decision when other people also have a stake in it.
When you write it up, say which parts you owned, what you reused and where you had help. I’d like to understand the contribution well enough that we can talk through the decisions together.
Where the paths meet
Whichever route you take, give yourself a small enough piece of work that you can follow it all the way through. Explain the problem, make the design decisions, build the behaviour and check it with someone else. If you get stuck, that’s useful information about what to learn next.
Give yourself time for the less glamorous parts too. Long content, empty states, failed requests, keyboard access and maintenance all need some attention.
This is also where experience changes the next step. If you already do all of this, you may get more from helping a team do it consistently. Improve a shared component, make review easier, or pair with someone who’s learning the part you know well.
If a little structure would help
You can work through every exercise here independently. A colleague who gives thoughtful feedback, the documentation for the tools you’re using and a project you care about will take you a long way.
Once you’ve made something, take a bit of time to work out what you’re comfortable taking responsibility for now and where you’d still want help. It gives you somewhere useful to start the next conversation, whether that’s with a teammate, a mentor or somebody hiring.
Fresh dev news, AI-digested daily. Never miss a trend at devoured.fyi