Design system : a component library, or a product in its own right
You want a design system delivered with your screens, and you wonder what difference it makes ?
Our job is design : components with their different states and their responsive behaviour (through Figma's auto layout), variables and a naming logic, all in a clean working file. Two deliverables are possible, the component library or the design system, and the choice can be made late, once the mockups are well along. It follows on from our UI design work.
When people call on us
The request most often comes at the end of an interface project.
- You order UX and UI, and you want a design system among the deliverables. This is by far the most frequent request.
- Your developers will have to extend screens that were never mocked up, and they need what it takes to do it without building the missing pieces themselves.
- Your identity is changing and you don't want to redo the whole site. For Tytl, the new art direction was the occasion to rebuild a design system and to add variables to the existing components.
- Several platforms must share the same components to stay consistent with one another.
A design system is not a design kit
A component library does one thing : it gives your developers a single handoff (the file that passes the work from design to development), to integrate the planned mockups and extend those that were not planned. A design system is a product within the product, with its life cycle, its maintenance, its governance and therefore its trade-offs. It takes resources and hands, on our side as on yours, and on your side a dedicated team that keeps your products consistent. As we write on our UI page : everyone wants a design system, but few can afford to build it and keep it alive.
How we go about it
We start from the screens we design
The components, the design patterns, the templates and the variable logic are produced from the start, on the scope of the mockups you called us in for.
Each component and its different states
A component is built with all its possible states (hover, disabled, focus…) and its responsive behaviour. This work is what lets you extend later without starting from scratch.
We plan a little for what comes next
The mockups don't always cover every page. For the ones we identify with you, we extend the components beyond the screens already designed, so nothing critical is missing at integration. We don't aim for completeness.
We speak to your developers
Opquast Web Quality certified and trained in the language and constraints of front-end development, we know what integrators need to go from mockup to code without guessing.
The choice doesn't have to be made right away
The components and templates are there from the start. Extending the work to a tokenisation logic aligned with your front-end framework (the tool your developers build the interface on) is a heavier workstream, which can be decided almost at the last minute.
We name what holds back adoption
A design system lives if it is adopted, and what holds back adoption is well known : lack of time against short-term priorities, ingrained habits, tools and processes that are not aligned, unclear responsibilities, teams that are poorly informed. These are the obstacles pointed out by the design system training we took, and the ones we can open up with you when the project is scoped.
What you get
A component library
All the planned components, in their different states, with the design patterns and the templates. A simple naming logic, made for a single handoff to your developers.
Or a design system
The same work, plus the extra effort that turns it into an internal product : all the variables, tokenisation in the naming, an extremely clean working file, for your designers and your developers alike.
A file ready for the handover
Figma offers a code conversion in its handoff space, which plugins translate into different front-end frameworks. It is automatically generated code. We do the design, not the development, and we don't deliver code.
What makes the effort vary
The extra effort a design system takes depends on the number of components and states, the tokens, the documentation and the time spent talking with your developers. It is an effort separate from the rest of the project.
A new identity without redoing the whole site
Addland becomes Tytl, and the new art direction helps developers take ownership of the redesign's graphic rules. It is the occasion to rebuild a clean design system, rethink how the components are built and add variables to them. Resetting the design system lets us rework small elements that have a global impact, while keeping the structure of the old components so the whole site doesn't have to be redone.
Read the case studyA site and a tool, a mandates platform, shared components
Neosigna: the lifecycle of thousands of contracts, now collaborative
When thousands of contracts start flowing smoothly
When social impact auditing becomes a tool-enabled platform
Diving into a social impact audit turned platformFrequently asked questions
So your screens stay consistent as the product grows, and the handover between design and development happens without guesswork. When that is all you need, a component library already covers it: the design system adds the logic of an internal product, with its maintenance and its trade-offs.
We start from the screens we design and from your existing components. We build each component and each of its states, set up the variables and the naming convention, extend the scope a little to the pages we identify with you, and prepare the file for handoff to your developers.
The detailed definitions are in our glossary. In practice, here is what matters to you: a component library is there to integrate and extend your mockups, whereas a design system is an internal product, with its own life cycle and governance, and it takes resources.
When what you deliver is meant to be picked up, extended and maintained by several people, and you have the means to keep it alive: time, people, trade-offs. Without those, a component library is most often the answer.
Yes. The components, the templates and the variables for the ordered scope are produced from the start. Tokenisation aligned with your framework is a separate workstream, which can be decided almost at the last minute.
A design system is never finished: it is a living product. Keeping it alive means collecting feedback from designers, developers and product teams, prioritising changes in a roadmap, and keeping responsibilities clear. These are the principles of the design system training we took, and we can help you lay out the broad lines when the project is scoped. Running it day to day stays with you.