Sponsored Content

Image-based design is dead: How code became a common language in product development

By Carrie Cousins

If you’ve ever been part of a design handoff process, you understand the challenge of turning an image into something more. You can have perfect prototypes with detailed annotations and documentation and still experience a massive disconnect between designers and engineers. 

Popular image-based design tools like Figma, Adobe XD, or Sketch come with challenges when it comes to fidelity and functionality. 

Simple product features like input validation, updating a shopping cart, date pickers, sign-up flows, and pagination, to name a few, don’t work in image-based tools as they do in the final product—limiting the value of prototypes for research and usability testing as well as creating dissonance between designers and developers.

It’s time to change the mindset that designers should create a flat model and then give it to engineers to develop a complex product. No one is to blame; it can be hard to break old design habits. But there is a better way. 

Image-based design tools are not dev-friendly

If you are still using traditional, image-based design tools, your product development is suffering. 

In short, design and development teams are creating the same product design twice. It’s a wholly inefficient, and inconsistent, way to do business. 

Teams design code-based products, but create the visual framework using vector or pixel-based prototypes. It doesn’t make sense.

One of the biggest challenges of scaling a product is maintaining a single source of truth while trying to code what’s been designed with an image-based tool. There’s no way to directly sync code and vector components of a design system—they speak different languages.

In most organizations, you have different product and design teams all working with different variations of the same but un-unified components—an absolute nightmare when it comes to design handoffs.

And consistency? It’s a constant struggle for many organizations as similar, yet non-identical variants of the same components start to pile up in the production environment. Just think of maintenance and refactoring costs.

Product drift

The reason designers and developers often misunderstand each other is because they’re working with different constraints. As Nathan Gitter demonstrates in Why Your App Looks Better in Sketch, there’s a drift between the design and end product. The limitations of vector-based design tools mean that designers can create pixel-perfect representations of the final product but the actual product has no chances to look like that in the real world, as designers cannot accurately account for code and browser constraints.

Designers are trying to find ways to imitate code and browser constraints, while engineers are trying to overcome them. 

This isn’t a harmonious yin and yang effect; it creates tension and an innate disconnect among design and development teams. 

Design evolution

Part of the problem with image-based design tools is that they haven’t evolved to meet the goals of today’s product design teams. 

Since their inception in the 1970s, image-based design tools have come a long way but lack the ability to merge design and development into one cohesive system. Think about how image-based design tools were originally used: for flat, static designs that were printed. 

Interactivity is a vital part of a modern design process. You need that element to truly show a project concept as it comes to life in design and development. 

Impact on design process

Image-based design accentuates the silos between UX, product, and engineering because each team is working to overcome different challenges.

The result is a longer time to market, more sprints, and more iterations to solve design-development inconsistencies rather than focusing on user experience and revenue opportunities.

Wouldn’t it make more sense if design tools were code-based, but designers could still use a familiar editor user interface?

Code-based design revolution

A new wave of design and development tools is on the horizon. 

Code-based design tools are the future of prototyping because they help teams work faster, and allow product development teams and businesses the ability to scale with more agility than their competitors. 

The benefits are three-fold: 

  • Superior, more interactive prototyping ability 
  • More consistent, error-free product design
  • Faster build with a quicker time to market

Here’s how it works. 

Instead of vector elements, designers use code-based components that work the same in the prototyping editor as the end product. Code-based design tools require no translation between design and code because the entire team is using the exact same components.

Design and function are part of the creative process from start to finish. 

These code-based tools enhance prototype fidelity with states, code-based interactions, conditional formatting, variables, data capture and validation, and more.

Furthermore, they help teams work more efficiently, save production time, and complete projects on goal without as many revisions. 

UXPin is one of the companies leading the design tool revolution. Their code-based approach aligns to DesignOps workflows with superior prototyping, fewer errors, and faster time to market. 

Merging development with design

Enter UXPin. A code-based design tool with proprietary Merge technology bridging the gap between design and development.

With UXPin Merge, every team member works with the exact same design system stored in a repository, thus solving the single source of truth dilemma.

UXPin’s components are made with HTML, CSS, and Javascript instead of vector graphics. The result—high-fidelity prototypes with interactivity enhanced by the power of Javascript.

What’s different about a UXPin Merge prototype? You get to use interactive UI blocks that save you from redesigning the same things over and over again. As these blocks are coded components, developers can just copy the code straight from your design. Using such components not only  increases the level of interactivity you wouldn’t be able to reach in an image-based tool, but also speeds up the prototyping process. It translates into more time that everyone involved can use to focus on bigger challenges. 

For designers, the interface is familiar in terms of function so usability isn’t a concern. They use a collection of components and settings (props) so that design and development teams work under the same set of constraints, helping create a smoother, more efficient design process. 

The hurdle of switching between tools from design to development goes away, and the entire team can get involved and see the visual design emerge from the start. This alone can unify product development with more realistic and interactive prototypes that look and feel more like a finished product. 

Single source of truth

UXPin Merge lets you sync the editor with a design system from a repository (via Git or Storybook), so designers, product managers, and others can work with the same components as developers. 

Designers can choose between editing components in code or via the properties panel. It opens a new dimension for designers to play with interactive components, while creating a visual design. 

Not only do teams work with a single source of truth, but they’re speaking the same language.

Collaboration becomes a more integrated part of the process because the tool allows designers to actually facilitate the design process, rather than draw and handoff to someone else to code. 

The result is a workflow with a frictionless design handoff because everyone is using the same components. When it comes to edits and changes, UXPin notifies team members and automatically updates the design system library. Now the entire organization is working with full control over the consistency of all components—a massive headache relief for DesignOps.

This type of design and development allows for earlier and more insightful usability testing and product evolution without a lot of starts and stops. 

The best part? Designers don’t have to know any code to use it and it can help expedite workflows for small teams. 

How PayPal Scaled Their Design Process with UXPin Merge

When Erica Rider joined PayPal as UX Manager for developer tools and platform experience, her primary task was to make the internal products more cohesive. 

The challenge: PayPal was experiencing a range of usability and design consistency issues—no two internal products looked the same. Plus, the team was made of three designers (including Erica) for over a 1,000 developers and more than 60 products – they all needed a sustainable way to support the ongoing product development process throughout the whole division.

Discovering Merge and UXPin opened the door to understanding how I could bridge the gap between design and development – Erica Rider, Senior Manager for UX – Developer tools and platform experience at PayPal. 

Merge allowed PayPal to sync their design system stored in the Git repository (Microsoft Fluent) with UXPin’s design tool. The components rendered the same in the production environment and UXPin, maintaining high interactivity and all the design standards. The high velocity and easiness of prototyping with ready elements empowered product teams to build prototypes on their own and scale the design process. 

PayPal’s managers (who had no UI/UX experience before using UXPin) now build fully functioning prototypes (not lo-fi mockups) to express their business needs in a matter of minutes..

Erica says that UXPin promotes smooth collaboration between managers, designers, and developers, helping to eliminate PayPal’s product drift, break down silos, and get rid of handoff process bottlenecks. 

Projects used to take two to three months just to do the design. Now products can be designed and delivered within the same timeframe. Probably one of the most significant impacts of Merge has been time to market. – Erica Rider, Senior Manager for UX – Developer tools and platform experience at PayPal. 

Who is UXPin?

Founded, Poland, UXPin is a design tool company whose mission is “to enable the best user experiences by merging design and engineering into one world of better, faster product development.”

The company turns 11 years old this year with offices in Poland, Japan, and the United States. PayPal, Johnson & Johnson, T. Rowe Price, and T-Mobile are just a few of the major international brands using UXPin’s code-based editor. 

UXPin has released several significant product updates in the last three years, including Merge, a revolutionary technology bridging the gap between design and development—solving many DesignOps challenges along the way.

We see design and development teams only working closer together in the future. Following our mission, UXPin strives to evangelize code-based design in product development processes. We’ve put a heavy focus on the Merge technology to support teams that want to accelerate design empowered by code”  – Yuga Koda, CEO at UXPin

Visit UXPin’s website to find out more about this exciting new technology.