Qué es un design system (y qué no es)
Un design system es el conjunto de decisiones de diseño, convertidas en piezas reutilizables y documentadas, que comparten diseñadores y desarrolladores. No es una carpeta de Figma con botones bonitos. Tampoco es una guía de estilo en PDF que nadie abre.
Esta es la confusión más habitual. Mucha gente cree que un design system es un UI kit y ya está. Un UI kit te da piezas; un sistema te da piezas, reglas para usarlas, código que las implementa y un proceso para cambiarlas. Si falta alguna de las cuatro cosas, tienes un kit con ínfulas.
Y ojo, que no todos los proyectos lo necesitan. Si eres una persona sola haciendo una landing, un sistema completo es matar moscas a cañonazos. Pero en cuanto hay dos diseñadores, tres desarrolladores y un producto que crece, la falta de sistema se paga: botones con cinco tonos de azul, espaciados que nadie recuerda por qué son así y reuniones eternas para decidir algo que ya se decidió hace seis meses.
Antes de empezar: la auditoría de interfaz
El primer paso no es abrir Figma para dibujar componentes, sino mirar lo que ya existe. Haz una auditoría: captura todas las pantallas del producto y agrupa lo que se repite.
El método es aburrido, pero funciona:
- Captura pantallas de todos los flujos principales (registro, compra, ajustes, errores).
- Recorta y agrupa botones, campos de formulario, tarjetas, modales y navegación.
- Anota las variaciones: cuántos radios de borde distintos, cuántos tamaños de texto, cuántos grises.
- Marca lo que es una variación con sentido y lo que es puro descuido.
Lo normal es que te lleves un susto. Productos con 14 grises distintos y 9 tamaños de fuente que en realidad deberían ser 5 o 6. Esa lista de incoherencias es tu argumento para que el equipo apoye el proyecto, y también tu punto de partida real.
Un consejo con opinión: no intentes rediseñar todo a la vez. Elige los diez componentes que más se usan y empieza por ahí. Un sistema pequeño que se usa vale más que uno enorme que se queda a medias.
Tokens: la capa que sostiene todo lo demás
Los tokens son las decisiones de diseño más pequeñas guardadas con nombre: un color, un espaciado, un radio, una tipografía. En vez de escribir `#1F4FFF` en cien sitios, escribes `color-primary-500`. Cambias el valor en un lugar y se actualiza en todos.
Lo importante, y donde la gente se equivoca, es la jerarquía de nombres. Se suele trabajar en tres niveles:
- Tokens primitivos: los valores en bruto. `blue-500`, `gray-100`, `space-4`.
- Tokens semánticos: lo que significan. `color-action-primary`, `color-text-muted`, `space-component-padding`.
- Tokens de componente: casos específicos. `button-primary-background`, `input-border-error`.
El nivel semántico es el que te salva la vida. Si mañana quieres un modo oscuro, no tocas los componentes: cambias a qué primitivo apunta cada token semántico. Si has nombrado los tokens por su color (`azul-boton`), tendrás que renombrar medio sistema. Nombra por función, no por apariencia.
En Figma esto se monta con variables: colores, números y cadenas de texto, con modos para claro y oscuro o para distintas marcas. Del lado del código, herramientas como Style Dictionary transforman un archivo JSON de tokens en variables CSS, constantes de JavaScript o lo que necesites. Un solo origen, varias salidas.
Para la escala de espaciado, elige una base y no la traiciones. Una escala de 4 u 8 píxeles (4, 8, 12, 16, 24, 32, 48...) cubre casi todo. Lo mismo con la tipografía: define una escala corta y deja de inventar tamaños intermedios que nadie va a mantener.
De los átomos a la librería de componentes
Un componente bien hecho no es el que se ve bien en el caso feliz, sino el que aguanta todos sus estados y variantes sin romperse. Aquí es donde se separa el trabajo de verdad del trabajo de portfolio.
Puedes pensar en capas, aunque no hace falta ser purista con la metáfora atómica:
- Básicos: botón, campo de texto, checkbox, etiqueta, icono.
- Compuestos: campo con etiqueta y mensaje de error, tarjeta, elemento de lista, pestañas.
- Patrones: formulario de login, cabecera con navegación, tabla con filtros.
Tómate un botón. Parece lo más sencillo del mundo y no lo es. Necesita variantes (primario, secundario, terciario, destructivo), tamaños, estados (normal, hover, foco, pulsado, desactivado, cargando) y versiones con icono a izquierda, derecha o solo icono. Multiplica y tienes decenas de combinaciones.
Por eso en Figma tienes que dominar las propiedades de componente y las variantes. Una buena librería usa propiedades booleanas para mostrar u ocultar el icono, propiedades de texto para el contenido y auto layout en todo, de modo que el componente se adapte solo cuando cambias el texto. Si tus componentes se rompen al escribir una palabra larga, no están terminados.
Y hay una regla que casi nadie cumple al principio: diseña los estados incómodos. El error, el vacío, la carga, el texto de tres líneas, el nombre de usuario kilométrico. Ahí es donde las interfaces se rompen en producción, y donde el sistema demuestra su valor.
No olvides la accesibilidad desde el componente, no como parche final. Contraste suficiente entre texto y fondo, un estado de foco visible para quien navega con teclado, áreas táctiles de un tamaño razonable. Si lo metes en el componente base, lo heredan todas las pantallas. Si lo dejas para después, nunca llega.
Documentar y llevar a código: Figma, Storybook y React
Un componente que no está documentado ni implementado en código es un dibujo. El sistema solo cobra vida cuando diseño y desarrollo hablan del mismo componente con el mismo nombre.
La documentación mínima de cada componente debería responder a cuatro preguntas: cuándo usarlo, cuándo no usarlo, qué variantes tiene y qué reglas de accesibilidad cumple. No hace falta una enciclopedia; unas pocas líneas claras y ejemplos visuales bastan.
En el lado del código, el flujo habitual hoy es construir los componentes en React con HTML y CSS bien escrito, consumir los tokens como variables CSS y publicar todo en Storybook. Storybook es un catálogo vivo donde cada componente aparece aislado, con todos sus estados y controles para jugar con sus propiedades. Es la fuente de verdad que ve todo el equipo, y es también donde QA y diseño comprueban que lo implementado coincide con lo dibujado.
Si vienes de diseño y piensas que esto no va contigo, te equivocas. Un diseñador UX/UI que entiende cómo se monta un componente en React, qué es una prop y por qué el CSS cascada como cascada, hace mejores handoffs. Hablas el idioma del desarrollador, anticipas límites técnicos y discutes menos. Y si vienes de programación, entender por qué un diseñador pide ese espaciado concreto te ahorra devoluciones.
No hace falta ser full stack para esto. Pero saber JavaScript lo bastante para leer un componente y proponer cambios te sitúa en otra liga profesional. De hecho, los perfiles que mezclan diseño de producto y front-end son de los más buscados, y pocas escuelas los forman de verdad.
Gobierno: quién manda en el sistema
El error más caro de un design system no es técnico, es organizativo. Si nadie es responsable de él, se pudre en seis meses.
Hay tres modelos típicos:
- Centralizado: un equipo dedicado crea y mantiene todo. Es coherente, pero se convierte en cuello de botella.
- Federado: varios equipos contribuyen con un núcleo pequeño que revisa. Más ágil, pero necesita disciplina.
- Solitario: una persona hace lo que puede. Es lo que ocurre en la mayoría de startups y no es tan malo como suena, siempre que esa persona tenga apoyo.
Sea cual sea tu modelo, necesitas un proceso claro para tres cosas: proponer un componente nuevo, modificar uno existente y retirar uno obsoleto. Y necesitas versionado. Si cambias el botón y rompes veinte pantallas sin avisar, el equipo dejará de fiarse del sistema y volverá a copiar y pegar.
Una idea que funciona: un canal de conversación dedicado y una reunión corta cada quince días para revisar propuestas. Sin burocracia pesada. El objetivo es que usar el sistema sea más fácil que saltárselo.
Y mide algo, aunque sea poco: cuántos componentes del producto salen ya del sistema, cuánto tarda el equipo en montar una pantalla nueva, cuántas incoherencias detecta QA. Sin números, tu sistema es una opinión; con ellos, es una inversión que puedes defender ante dirección.
Cómo se aprende esto en TRAZOS
Puedes leer cien artículos sobre design systems, pero solo lo entiendes del todo cuando construyes uno, te lo critican y lo rompes. Esa es la parte que no se aprende con vídeos sueltos.
En el área de Diseño UX/UI de TRAZOS, en nuestro campus de Chamberí, trabajas con las herramientas reales del sector: Figma para diseño y librerías, HTML y CSS y JavaScript para entender cómo se construye lo que dibujas, y React y Node.js si quieres llegar hasta el front-end o el full stack. Las disciplinas del área (UX/UI, diseño web y programación) están pensadas para que no te quedes en un solo lado de la mesa.
Los mentores vienen de la industria: hay profesionales que han trabajado en Ogilvy, La Factoría de Ideas, Danone o Electronic Arts. Eso se nota cuando te corrigen, porque no te cuentan cómo debería ser un proceso en teoría, sino cómo se hace con plazos, con presión y con un cliente que cambia de opinión el jueves.
Las salidas son concretas: diseñador UX/UI, diseñador de producto digital, diseñador web, desarrollador front-end, desarrollador full stack o maquetador web. Y si quieres ver hacia dónde apunta el listón creativo del sector, mira los trabajos que premian Awwwards o los CSS Design Awards. Detrás de casi todos hay un sistema sólido que no se ve.
Si estás pensando en reciclarte o en dar el salto desde otro perfil, un design system es un proyecto de portfolio de los buenos. Demuestra criterio, orden y capacidad de trabajar con desarrollo. Justo lo que busca quien contrata.



