Dualite started as a a pseudo-marketing agency, providing interactive creatives for Web and Mobile. After rigorous ups and down, we understood the sales process that would help us secure clients, and we were doing fairly well. However, the problem with this agency model was the lack of awareness and visualization that clients had, especially mid-sized firms. We had to create ‘interactive samples’ for every potential lead, and that process eventually turned out to be inefficient and exhausting for us.

Taking into account numerous discussions and feedback received from clients/advertising experts, we have found that today interactivity, although much more in demand and in dire need, is not a separate entity within websites and apps that can be isolated and used for a particular marketing creative or deliverable, but is rather an inherent characteristic to be explored and deployed in apps and websites to enhance the overall UX, especially through transitions, micro-interactions and animations.

Where we’re heading

The fierce contrast between designers and developers is quite apparent. You have these different personas synergising together to get quality products out to market, providing services from food to medicines, delivered on time. Some companies, like Slack, Apple or Stripe, do it extremely well.

And yet, some teams find it extremely hard to do it. Deploying a strong product UI necessitates a strong set of tools. However, transitioning between design libraries, the codebase, and other project management tools can lead to inefficiencies, particularly when components and style names do not align with the code or when the team fails to track and document tasks.

Our vision is to disrupt front-end development by making developers’ work in UI minimal, something just as simple as copy-and-paste. That is our moonshot.

Developers would prefer to invest double the time in writing new code from scratch rather than attempting to modify the generated code. The difference in terms of coding style, libraries in use, and variable naming conventions between any two codebases can be staggering to a high degree. Adhering to these code conventions is crucial for developer adoption. If the generated code is good quality but doesn’t adhere to the team coding style, it won’t be used.

So, it’s a reasonable assumption that what we’re pursuing with Dualite as an organisation is to solve a difficult problem at scale. However, merely marketing a ‘design-to-code Figma tool’ won’t work well for us. There are just not enough who would understand the jargon and be willing to pay for such a concept.

What we’re trying to sell is Accelerated Development. A tool that lets the developer only work on the problems that really matter, while our tool handles the entire design and its repetitive work on its head and generates the code based on your settings and parameters of your codebase.

The definition of ‘good code’

That’s the question we started thinking around when building Alpha. After building our Figma plugin, but realised that after a point there’s stagnancy. We also understood that this is not a retentive product, but a use-and-throw which is impulsively used when the need arises.

We realised that Figma will always be a design-first product and design-to-code was an illusory luxury that wasn’t simply attainable due to how design is done on Figma.

We decided to take the tough decision of not pursuing and over-building the plugin. No matter what we do, we realised there was a limiting point of how much good quality code we can churn out since we relied on Figma’s REST API, and development flexibility as a plugin was limited.

Building for Tech Teams That Move Fast

We saw two key trends:

1. People slowly trusting AI, accepting its mistakes and trying multiple ways to get it work better in writing code and optimising design for them.

2. We saw people, especially small tech teams, ditching Figma to directly start building.

After interacting with 100+ tech teams and builders that move fast, we realised that:

• After a product feature is described, two parallel processes begin:
  Backend development and design starts.

• Once those two processes commence, then the frontend is integrated by stitching the design with its relevant API endpoint.

It is that point where the frontend developer needs to merge the design and backend API that we aim to automate.

Alpha: 0 → 1

Alpha is an AI frontend engineer that lets you build your MVP or ‘alpha’, which can also be integrated with your code and design systems as you scale.

How It Works

• Start off with a prompt, add reference images or import Figma designs.

• Import codebase for personalised code.

• Generates a preview with the generated codebase.

• Build iteratively through a chat-like interface.

• Integrate REST APIs through simple copy-paste.

Specialised Over Frontend

At Dualite, our goal is to achieve end-to-end frontend automation and allow teams to iterate faster bespoke to their systems and needs. The vision is to augment any new change required in a product on a frontend level by using your own components.

A natural question that comes is why not do full-stack development with the technological advancements that are in place. The metric we’re targeting is retention around the product, something that we feel can only be done by focusing on the frontend at depth.

We like to assert the age-old wisdom of “jack of all but master of none” as we build and specialise around frontend for teams.