Product teams rarely lose the most time while designing or building. They lose it in between.
A designer finishes a flow in Figma. A developer interprets it, fills in the states nobody drew, and makes a few judgment calls close to the deadline. What ships is close to the design, but not quite. Design QA starts, tickets get reopened, and a feature that looked finished in review takes another sprint to reach users.
AI hasn't fixed this. Screens are faster to produce, but the gap between a design decision and the shipped product is still where the time goes. Product design engineering closes that gap by keeping product thinking, UX design, and frontend implementation in one continuous loop.
At Eleken, this is how our designers work on SaaS products, and it's how we've cut time to delivery roughly in half. Below, we explain what product design engineering is, why it's emerging now, how the work is divided, and when the model makes sense for your team.
What is product design engineering?
Product design engineering is an approach where the designer doesn't stop at the design file. They also design the interface in code, using the product's existing components, and stay involved until it ships and shows results.
Not to be confused with product design engineering in manufacturing, which deals with physical products, CAD models, and materials. Here, we're talking about software.
Product thinking, UX design, and frontend implementation stay in one continuous loop. The same person takes it through five steps:
- Find the problem. What isn't working for users or the business, and which metric should improve.
- Design the solution. Flows, screens, and all the states a user might see, tested with users and stakeholders.
- Build it. A working interface made from the existing product components.
- Send it for review. Developers check the code, connect the backend, and decide what goes live.
- Measure. See whether the metric moved, then use what you learn for the next round.
In a traditional setup, each step is passed to someone new, who has to pick up the context from scratch. Here, the context stays with the same designer.

This isn't a completely new idea. Product design has been moving in this direction for a while. As one designer on Reddit put it:
In some companies, a product designer is expected to research, model the problem, define interactions, create the interface, collaborate with engineering, and measure the outcome.
What's new is that AI tools made it realistic for a designer to build the interface. It doesn't turn designers into developers. The designer becomes responsible for both the design decision and how it looks and works in the real product. Engineers still handle the architecture, the data, and what gets released.
How it differs from product design and engineering
These three terms often get mixed up, but each one covers a different scope:
- Product design decides what to build and how it should behave. The designer's direct ownership usually ends when engineering picks up the files.
- Design engineering is the craft of building interfaces in code with polished UI, interactions, and components. Brad Frost calls this area the front of the front end. It usually focuses less on research and problem framing.
- Product design engineering combines the product judgment of product design and the hands-on build of design engineering, owned by one person from the problem to the measured result.
If you're weighing these as roles to hire, we compare product designers and product design engineers in detail in a separate article.
Where the traditional handoff model slows teams down
In most product teams, a feature moves through a chain. The designer makes decisions in Figma, adds notes for developers, and the developers build it. Each step happens in a different tool, often by a different person, so there is always some distance between the decision and what users get.
That distance slows teams down in three ways:
- Every handoff is a translation.
A developer reads the Figma file and turns it into code. Anything the file doesn't show, like UX logic, error states, or edge cases, gets decided during the build. Design QA then finds the differences and sends them back. Each round is small, but together they add days to every feature.
- Feedback comes too late.
Many problems with a design only show up once it runs in the product. By then, engineering time has already been spent, so even a simple change means rework and another review.
- The designer's influence ends at handoff.
Once the file is approved, the designer moves on to the next task. Decisions made during the build rarely come back to them, and the shipped version drifts from what was intended. Nobody owns the gap between the two.
Teams that keep designers close to the build see the difference. As one designer shared:
So the real bottleneck isn't how fast a team can produce screens. AI has already made that part cheap. The bottleneck is how far a decision has to travel before it reaches users. Good designer-developer collaboration can narrow the gap, but it doesn't remove the handoff itself.
Here's how the two models compare:
Why product design engineering is emerging now
AI tools can turn a prompt into a working interface in minutes. Producing a screen is no longer the hard part of building a product.
But AI will generate any screen you ask for without telling you whether that screen should exist. So the bottleneck in the product design development process has moved from making things to deciding things:
- which problem is worth solving first;
- which UX logic holds up for real users;
- which states and edge cases matter in this particular product.
These are product decisions, and they still need someone who understands both the users and the business.
Designers are already moving in this direction. The AI in Design 2026 report by Designer Fund and Foundation Capital surveyed more than 900 designers. Half of them, across product and brand design, said they had shipped AI-generated code to production. 65% said they're taking on more product or engineering responsibilities.
Speed on its own isn't enough, and neither is judgment on its own.
→ A team that relies ONLY on AI ships the wrong screens faster: features look fine, but the metric doesn't move.
→ A team with strong product thinking and the old product design workflow finds the right answer, but it arrives weeks later as a Figma file.
Teams that keep thinking and building apart will keep losing time to teams that keep them together. Product design engineering brings the two together. Product thinking sets the direction, AI speeds up the build, and one person stays in the loop from start to finish.

That's how we work at Eleken. Our designers use AI to get to a working prototype much faster than before. They spend the time saved on the decisions AI can't make, like what to build, how it should behave, and whether it worked.
Who owns what in product design engineering
When a designer starts working in code, the first question teams usually ask is who is responsible for what.
In product design engineering, the handoff disappears, but every part of the work still has a clear owner:
- The designer owns the experience. That means the user problem, the UX logic, the interface, its states, and a working frontend.
- The developer owns technical integrity. That means architecture, application logic, data, APIs, security, and production.
- The manager owns delivery. That means priorities, scope, deadlines, and the release.
The designer's part goes further than in a traditional setup, and it's also more concrete:
- UX logic. User flows, interaction patterns, decision points, and the acceptance criteria that define “done.”
- Every state of the interface. Empty, loading, error, success, and disabled states are covered before the code goes to review.
- Edge cases. Long names, missing data, and different user permissions are solved at the design stage, not after a pull request is open.
- Building with what exists. The interface is assembled from the product's existing components and design system, not drawn from scratch.
In fact, the designer changes what users see and interact with, including layout, components, states, interactions, copy, and responsive behavior. The developer, in turn, is responsible for the system that the interface runs on.
Some decisions sit in between, like component behavior, complex interactions, accessibility, frontend performance, and technical feasibility. The designer and developer make those decisions together.
When opinions differ, the team first agrees on which area the decision belongs to. The owner of that area has the final say, whatever their title:
On Eleken projects, we write these boundaries into the repository rules from day one. Our designers work in separate branches for screens. Shared components and tokens change only through their own review, and nothing reaches the main branch without an engineer's approval.
This split also changes the developer's job for the better. Rebuilding mockups, adjusting pixels, and working through design QA fix lists leave their plate. That time goes back to architecture, integrations, performance, and reliability, where their expertise matters most.

It also helps to be clear about what this role is not.
A product design engineer isn't a frontend developer, because the backend, data, and architecture stay with engineering. It isn't a Figma-to-code service, because the designer also decides what should be built and why. And it isn't prompt engineering. AI speeds up the build, but the decisions behind it come from the designer.
How the product design engineering process works
We run our product design engineering workflow as six phases, with the same designer involved in all of them. For a detailed overview, read our design-to-code workflow guide.
Here's a short overview of who leads each phase and what it saves compared to the traditional handoff:
The handoff in phase 5 is the only one left in the process, and what gets handed over is working code.
It’s also important that this design engineering process doesn’t run as a waterfall. Its phases form a loop:
Identify → Design → Build → Validate → Measure → Iterate
A prototype can send the team back to research. The results of one release become the evidence for the next one. Phases often overlap, too. While one flow is in review, the next one is already being prototyped.
What results to expect
At Eleken, we've seen product design engineering cut time to delivery roughly in half across the projects we've worked on.
The time savings come from changes to the process itself. Designers build working interfaces from the start, eliminating the need to rebuild designs in code. There are fewer rounds of design QA, and feedback arrives early enough to make changes quickly and at a lower cost.
Here's what that looks like in practice:
- About 2x faster delivery. The design decision travels straight into a working interface instead of being rebuilt and corrected along the way.
- Less rework and faster validation. Stakeholders react to a working product, so problems show up before engineering time is spent on them.
- States and edge cases are solved before review. Empty, error, and permission states reach engineers already built.
- What ships matches what was designed. The person who made the decision also handled the product design implementation, so nothing gets lost in translation.
Reusing existing components also adds to the speed. In a controlled study by Sparkbox, eight developers built the same contact form from scratch, then rebuilt it with IBM's Carbon design system, and the Carbon version was 47% faster on median time, even after counting the time spent learning the system.
Product design engineering builds on that effect. Every interface is assembled from the product's own design system, and the system grows with each feature.

To check whether the model works for your team, track a few delivery numbers before and after:
- time from an agreed decision to a release;
- rounds of design QA per feature;
- tickets reopened because the build didn't match the design.
Alongside those, track the product metric agreed at the start. If delivery gets faster but that metric doesn't move, the team is just shipping the wrong things sooner.
When product design engineering makes sense, and when it doesn't
Product design engineering isn't the right model for every team. It works best when the slowest part of delivery is the path from a design decision to working code.
It's usually a good fit for:
- Teams that need to ship faster without hiring more engineers. If developers spend a large part of their time rebuilding interfaces, the problem is the handoff. Removing that step frees up your team.
- SaaS products with an existing component library. When a design system is already in code, the designer can build new screens from it right away.
- Startups going from 0 to 1 or improving core flows. When onboarding, activation, or checkout directly affect revenue, every week saved on delivery matters.
- Internal tools. For admin panels and back-office tools, getting a working version to users quickly often matters more than pixel-perfect polish.
- Products carrying design debt from fast growth. Patched-together flows and inconsistent screens can be fixed step by step, without stopping the roadmap for a full rebuild.
- Product leaders who have worked with designers who only made good-looking screens. In this model, every design decision starts from a user problem and ends with a metric, so visuals alone are never the goal.
To make it work, a few things need to be in place: the designer needs access to the repository, and engineers need to be ready to review pull requests. If there's no component layer yet, building a design system is usually the first piece of work. We cover the setup in our article on designing in code.
It's also worth being honest about when the model won't help much:
- The real bottleneck is the backend. If features are waiting on APIs, data, or infrastructure, a faster frontend won't get them to users sooner.
- The team wants speed instead of clarity. Working code feels finished, so it's tempting to skip problem framing and start building. Done that way, the model just ships the wrong thing faster. Research always comes first.
- No one can review the code. A designer's code without engineering oversight turns into technical debt. Engineering review is what keeps it safe.
If you're not sure where your team's bottleneck is, a UX audit is usually where we start at Eleken. It shows what's slowing the product down before anyone decides how to fix it.
Conclusion
Most teams try to speed up delivery by adding people or new tools. Product design engineering takes a different approach by shortening the path each decision has to travel. When the person who understands the problem also builds the interface and checks the result, less gets lost, redone, or argued about along the way.
You also don't have to change your whole process at once. The easiest way to see whether the model fits your team is to test it on one flow, then compare how long it took to ship, how many fix rounds it needed, and whether the metric moved.
At Eleken, we provide product design engineering services for SaaS products, and we usually start with exactly that: one flow.







.webp)




