Beyond the Mockup: Why We Became Design Engineers

About the Author:
Simon Dziukiewicz is CEO and Creative Director at
Joyce Global, a product design and innovation studio. He brings more than a decade of experience across agencies, startups, and enterprises in the United States, Switzerland, and Germany.

For years, design projects followed a familiar path. Designers produced mockups, developers turned them into products, and the experience shifted slightly at every handoff. At Joyce, we have moved our practice beyond the mockup. Our team now works as design engineers, extending our design practice into building and validation.

Design engineering brings decisions about the user experience closer to the implementation. We can develop a concept, build a working version, observe how people use it, and refine it within one connected process. Our design expertise keeps shaping the experience as it becomes functional.

This shift changed how our team works, which tools we rely on, and what clients get from a project. Here is how it plays out in practice.

From product designers to design engineers

Our team has evolved from product designers into design engineers. The same people now bring UX thinking, creative judgment, and hands-on implementation to a project.

The people shaping an experience can also build a working version, evaluate how it behaves, and refine it. That continuity shortens the distance between a design decision and something a user can experience. The person who makes a decision is also the one who sees it working and notices when it falls short.

That’s why we describe part of our work as creative engineering. Our studio’s work spans progressive web apps, native mobile experiences, 3D-driven interfaces, and responsive websites. In each of those, much of the experience lives in behavior: how an element moves, how a screen responds, how a 3D scene reacts to input. 

Those qualities are hard to judge in a static file and easier to judge once something runs.

Creative ownership starts on the canvas

Tools help us execute and explore ideas. Our contribution starts earlier. We work to understand the problem, imagine alternatives, find an original direction, shape the visual language, and interpret feedback.

Those creative decisions look different on every project. On one, it might be how much information a first-time user sees before reaching the main screen. On another, it might be whether a recurring task deserves a shortcut, or what tone a confirmation message should take. These choices come from understanding the people who will use the product.

We use Figma and other canvas tools to explore these ideas and keep creative ownership of our work. The canvas gives us space to shape interfaces through deliberate decisions about structure, hierarchy, layout, typography, and interaction. Working there helps us articulate our intentions, compare alternatives, and develop original concepts.

It also creates a strong sense of ownership. We understand why the interface looks and behaves the way it does, and we can explain the choices behind it to a client or a teammate. Those decisions then guide what we build in code, and they keep evolving through testing and iteration.

The team stays responsible for deciding what deserves to be built and whether the result serves the people using it. Generated code can speed up execution. We still decide the direction, quality, and fit.

Code as a medium for design exploration

Today, a big portion of projects happens in code. Working in code lets us shape interactions and evaluate ideas in a functioning environment.

Building an interface helps us investigate how it behaves. Depending on the project, that might mean entering information, moving through a flow, changing a selection, or seeing how the interface responds to an unexpected action. Each behavior gives us material for the next design decision.

This matters most in the work our studio is known for. In a WebGL scene, lighting, camera movement, and performance on an average phone all shape the experience. We can only judge them properly once the scene runs on real devices.

Our stack supports fast, directed iteration. We mainly use cloud-based tools and Codex for building and iteration, alongside Figma or another canvas for exploration and visual development. In plain terms, these tools help us turn ideas into working versions and revise them quickly. Our team provides the direction, evaluates the output, and refines the experience, the same judgment experienced designers bring to any interface.

What clients gain from working versions

Because our team can build, design discussions turn into working versions sooner. Clients can interact with a proposed experience and give feedback on how it behaves. That makes conversations about priorities, scope, and expectations more concrete. It is easier to agree on what matters when everyone has tried the same thing.

We start by defining the vision with the client, then create a blueprint covering the product’s architecture, technical stack, and steps toward market fit. During the build, we work in weekly sprints through a shared Slack channel, with async updates and regular meetings. Working versions arrive throughout those sprints, so feedback stays grounded in something real.

Working versions and user feedback also reveal which ideas deserve further development. Our team can test an assumption, simplify a feature, or change direction before committing more effort. Part of the value is the confidence to stop pursuing a weak idea. 

Learning that from a working version is usually far cheaper than learning it after launch, and clients can put their budget into the features that proved their worth.

An MVP that stands out in a crowded market

Building and launching an MVP is becoming more accessible. As a result, a distinctive and thoughtfully designed experience is becoming more valuable.

We help clients differentiate their products through a recognizable brand, carefully crafted interactions, and attention to everyday use: how easily people navigate, complete recurring tasks, and understand what happens next. These details often decide whether people return after the first visit.

Our design engineering approach carries these decisions into the working product early. Because our team works as both app designers and builders, we design and test motion, transitions, and interface details in the product itself, so they survive the move from concept to launch.

More room for the work that makes products better

Shorter implementation cycles create room for work that often gets squeezed out of a project. We use that capacity for additional user conversations, alternative concepts, and improvements to the details people notice in daily use. 

In practice, that can mean another round of usability sessions before launch, a third visual direction for a key screen, or time to tune animation timing until it feels right. These are refinements UI/UX designers rarely get time for in a traditional handoff.

For clients, the benefit lies in what that time enables: more learning and a better product. Speed matters to us because it lets us do what’s next.

Moving beyond the mockup has changed our tools, our roles, and our process. The core of the work stays the same. We still start with the problem and the people who have it, and we still care about craft, from the first sketch to the last transition. The difference is that our designs now meet reality sooner, while we still have time to act on what we learn.

 ⁠

Find more Community stories on our blog Courtside. Have a suggestion? Contact stories@dribbble.com.

内容来自 Dribbble,版权归原作者所有。

阅读原文 ↗

把喜欢的内容,留在你的新标签页。

打开我的订阅