Control de versiones de diseño sin ser desarrollador
Los desarrolladores tienen Git. Los diseñadores tienen «Homepage_FINAL_v4_revised_APPROVED.png». Así pones orden en tus versiones sin línea de comandos.

El cementerio de nombres de archivo
El disco duro de cualquier diseñador cuenta la misma historia:
Homepage_v1.png
Homepage_v2.png
Homepage_v2_revised.png
Homepage_FINAL.png
Homepage_FINAL_v2.png
Homepage_FINAL_FINAL_USE_THIS_ONE.png
Tiene gracia hasta que un cliente aprueba la versión equivocada y tú ya mandaste los archivos a imprenta.
Por qué es difícil versionar diseños
Los desarrolladores resolvieron esto hace décadas con Git. Cada cambio queda registrado y puedes volver atrás en cualquier momento, así que todos trabajan sobre la misma fuente de verdad. Pero la mayoría de las herramientas de control de versiones para diseño exigen conocimientos técnicos o te atan a una aplicación de diseño concreta.
La realidad para la mayoría de los freelancers y las agencias pequeñas:
- Los archivos viven en carpetas con convenciones de nombres muy creativas.
- Los clientes ven lo que les envías. No hay garantía de que estén mirando la última versión.
- El feedback se queda huérfano. Los comentarios que un cliente dejó en la v2 no se trasladan cuando envías la v3.
- No hay historial de cambios. Si alguien pregunta «¿qué cambió entre la ronda 2 y la ronda 3?», reconstruyes la historia de memoria.
Este artículo explica por qué pasa eso y lo que te cuesta cuando sale mal. Después verás cómo crear un hábito de versiones que no te obliga a aprender a usar la línea de comandos.
Tomar prestados conceptos de desarrollo, sin la línea de comandos
No necesitas Git para aprovechar las ideas que hay detrás. Tres conceptos se trasladan sin problema, y ninguno requiere escribir un solo comando.
Una versión es una instantánea, no un reemplazo. En Git, un commit no borra el código anterior. Añade un nuevo punto en el historial al que siempre puedes volver. El equivalente en diseño es sencillo: cada ronda de trabajo que envías a un cliente debe ser su propia instantánea, guardada junto a las anteriores, no encima de ellas. Si sobrescribes Homepage_FINAL.png con tus últimos cambios, pierdes la posibilidad de responder «¿cómo era realmente la ronda 2?».
Un diff muestra qué cambió. Los desarrolladores revisan los pull requests mirando un diff: las líneas concretas que cambiaron entre un commit y el siguiente. Los diseñadores rara vez lo tienen de serie, así que hay que fabricarlo. Puede ser tan simple como ver dos versiones lado a lado, o una nota breve bajo cada subida que explique qué se movió. La idea es la misma: no hagas que el cliente busque qué es diferente. Muéstraselo.
Una rama es una ronda de exploración que aún no se ha aceptado. Cuando un desarrollador abre una rama, está diciendo: «esto es una propuesta, todavía no está integrada en la línea principal». Una ronda de diseño en curso es exactamente lo mismo. No debería presentarse al cliente como la nueva versión por defecto hasta que la haya revisado y aceptado. Mezclar «esta es una idea que estoy probando» con «este es el diseño aprobado actual» es una de las formas más comunes en que los equipos pierden la pista de qué es lo que vale.
Nada de esto requiere un cliente de Git, una terminal ni formación en informática. Requiere tratar las versiones como un historial que se va ampliando y no como un único archivo que se modifica una y otra vez, y requiere una forma de mostrar qué cambió entre ellas.
Qué pasa cuando falla el control de versiones
No son hipótesis. Es un martes cualquiera.
El cliente aprueba la versión equivocada. Envías un enlace de revisión el lunes. Para el miércoles ya subiste una corrección, pero el cliente abre el enlace antiguo que tenía en favoritos, el que todavía apunta a la v1. Responde «¡Aprobado!» y tú lo publicas. Dos semanas después, en la reunión de lanzamiento, alguien pregunta por qué la sección principal sigue con el titular antiguo. Ahora estás haciendo correcciones de emergencia en un proyecto «terminado», y el cliente jura que nunca aprobó esa versión.
El diseñador sobrescribe el archivo aprobado. Estás ordenando la carpeta del proyecto y guardas la última ronda de ajustes justo encima del archivo aprobado anteriormente. El problema es que la versión aprobada era la que el cliente había dado por buena, y ya no la tienes. Cuando el cliente cuestiona un cambio más adelante («yo nunca aprobé ese color»), no tienes pruebas. La aprobación desapareció porque el archivo al que estaba ligada ya no existe en su forma original.
El feedback se pierde entre versiones. Un cliente deja comentarios detallados en la v2: «sube el CTA», «cambia la foto de fondo», «acorta el subtítulo». Tomas esas notas, haces la v3 y la envías como un adjunto nuevo en un hilo de correo nuevo. El cliente abre la v3 pero no recuerda qué pidió originalmente. Vuelve a pedir cambios que ya hiciste, o da por hecho que ignoraste sus notas. Mientras tanto, el feedback original está enterrado diecisiete mensajes más abajo en un hilo que nadie quiere recorrer.
Dos personas editan a la vez y nadie se da cuenta. En un equipo pequeño es habitual que un diseñador y un colaborador junior, o un diseñador y alguien de marketing retocando textos, abran el mismo archivo fuente con menos de una hora de diferencia. Quien guarda último gana, en silencio, y los cambios de la otra persona desaparecen sin ningún aviso de que hubo un conflicto. A los desarrolladores se les avisa explícitamente de los conflictos de fusión. Los diseñadores, normalmente, simplemente pierden su trabajo.
Todos estos problemas tienen la misma causa: las versiones existen, pero nada las conecta. Los archivos flotan en un lugar y el feedback y las decisiones en otro. Eso es lo que resuelve un control de versiones de verdad. No solo registra archivos: mantiene toda la conversación anclada a la instantánea correcta.
Por qué el historial de versiones de tu herramienta de diseño no basta
Si trabajas en Figma, Adobe XD o simplemente en Google Drive, probablemente ya tengas algún tipo de historial de versiones. Es tentador suponer que con eso basta. Normalmente no, y la diferencia importa precisamente en el trabajo con clientes.
Está pensado para quien edita, no para el cliente. El historial de versiones de Figma es una lista de puntos de restauración que se recorre con scroll, pensada para ti, la persona que edita el archivo. Da por hecho que quien lo mira ya sabe moverse por la herramienta. Pedirle a un cliente que abre un archivo de Figma por primera vez que encuentre «la versión del martes pasado» no es realista, sobre todo si nunca ha usado Figma ni lo usará.
No registra ninguna decisión. El historial nativo registra que un archivo cambió. No registra que un cliente lo miró y dijo sí o no. Restaurar una versión antigua te dice qué contenía el archivo. No te dice nada sobre si alguien lo aprobó, cuándo ni en qué términos.
No abarca distintos tipos de archivo. Un mismo proyecto suele mezclar una maqueta de la página de inicio, una propuesta en PDF, un video corto de recorrido y una URL de staging por la que el cliente puede navegar. El historial de Figma cubre el archivo de Figma. El de Drive cubre lo que hay en Drive. Ninguno te da un único lugar donde el cliente pueda revisar los cuatro con un registro coherente de qué se aprobó y cuándo.
Desaparece cuando el cliente no es colaborador. La mayoría de las herramientas de diseño solo muestran el historial completo a quienes tienen permiso de edición. Los clientes suelen ser solo lectores, si es que tienen acceso, así que el historial al que recurrirías en una disputa a menudo es algo que ellos no pueden ver ni exportar.
El historial nativo sigue siendo una buena red de seguridad para tu propio proceso de edición. Simplemente resuelve un problema distinto al de este artículo: asegurarte de que el cliente y el diseñador miren siempre la misma instantánea.
Control de versiones práctico, sin complicaciones
1. Sube, no reemplaces
En lugar de sobrescribir un archivo, sube la nueva versión junto a la anterior. Así conservas el historial y cualquiera puede comparar iteraciones.
2. Mantén el feedback ligado a las versiones
El mayor dolor del versionado no son los archivos. Es el feedback. Cuando los comentarios viven en el correo o en Slack, se desconectan de la versión concreta a la que se refieren.
Aligno lo resuelve vinculando los comentarios a versiones específicas. Cuando subes una versión nueva, los comentarios anteriores siguen ligados a la versión en la que se dejaron. El cliente siempre ve la última, pero el historial completo está a un clic.
3. Que «actual» no admita dudas
Uses la herramienta que uses, debe haber una versión claramente marcada como «actual». Sin adivinar, sin preguntar «¿esta es la última?».
4. Que el cliente llegue siempre a la última versión
Los enlaces para compartir deberían abrir siempre la versión más reciente por defecto. Si el cliente guardó el enlace de revisión en favoritos hace tres semanas, debería seguir mostrándole lo que es actual ahora, no lo que era actual cuando lo compartiste por primera vez.
5. Cierra cada versión con una decisión
El control de versiones va más allá de registrar archivos. También registra decisiones. Cada versión que envías a un cliente debería terminar con una acción explícita: aprobada o con cambios solicitados. Sin eso, te quedas adivinando. ¿El silencio significaba que le gustó? ¿Llegó siquiera a abrir el enlace?
Cuando cada versión se cierra con una decisión registrada, obtienes un registro de auditoría que protege a ambas partes. El cliente no puede decir que nunca aprobó algo. Tú no puedes seguir iterando por error sobre una versión que ya se aceptó. Y si un proyecto pasa a otro diseñador a mitad de camino, la persona nueva puede ver exactamente en qué punto está todo sin preguntarle a nadie.
Busca una herramienta que integre la aprobación del cliente en el flujo de revisión. El cliente debería aprobar con un botón sobre el propio diseño, en lugar de con un correo de seguimiento que luego nadie encuentra. Así la aprobación queda justo al lado de la versión a la que se refiere.
Cada tipo de archivo necesita sus propios hábitos de versionado
Del «control de versiones para diseño» se suele hablar como si todo proyecto fuera una única imagen estática. En la práctica, un proyecto de diseño o de agencia suele abarcar varios tipos de archivo, y cada uno tiene sus particularidades a la hora de versionar.
Imágenes estáticas y maquetas
Es el caso más sencillo y del que sale la mayor parte del caos de nombres de archivo. El hábito que hay que crear es pequeño: cada exportación se sube como una nueva versión del mismo archivo, no como un archivo nuevo en una carpeta nueva. Los comentarios fijados en un punto concreto de la versión 2 (por ejemplo, una nota sobre la posición del logo) deberían quedarse en la versión 2 aunque ya exista la versión 3, para que cualquiera que mire atrás vea exactamente a qué se refería la nota.
PDF de varias páginas
Los PDF añaden un matiz: el feedback suele referirse a una página concreta. Un comentario sobre la tabla de precios de la página 4 tiene que seguir ligado a la página 4 de esa versión en particular, no al documento en su conjunto. Si tu herramienta de revisión trata una propuesta de 12 páginas como un solo archivo plano, acabarás con comentarios que solo tienen sentido si recuerdas qué página tenía abierta el revisor cuando los escribió.
Ediciones de video
El video añade una dimensión temporal al versionado. «Arregla la transición» no significa nada si no sabes a qué segundo de qué montaje se refiere. Los comentarios en video tienen que fijarse a una marca de tiempo, y esa marca de tiempo tiene que viajar con la versión correcta, porque un nuevo montaje puede desplazar fácilmente el punto donde cae un momento determinado. Una herramienta que admite comentarios fijados a una marca de tiempo en video resuelve un problema real, distinto del de fijar un comentario en una imagen estática.
Páginas web en vivo
Revisar una página web en un entorno de staging es otra historia, porque el «archivo» es una URL en vivo que puede cambiar bajo los pies del revisor en cualquier momento. Un cliente que abre un enlace de staging el lunes y vuelve el jueves puede encontrarse una página totalmente distinta si has seguido subiendo cambios a la misma URL, sin forma de saber sobre qué comentó originalmente. La solución sigue el mismo principio que en todo lo demás: cada ronda de cambios en esa URL debería capturarse como una versión revisable propia, para que un comentario sobre el diseño del lunes siga teniendo sentido el jueves, aunque la página en vivo ya haya avanzado.
Un ejemplo práctico: tres rondas para rediseñar una página de inicio
Los conceptos se aplican mejor con un caso concreto. Supongamos que eres freelance y rediseñas la página de inicio de un cliente en tres rondas.
Ronda 1. Subes el concepto inicial como versión 1 y compartes el enlace de revisión. El cliente fija tres comentarios: la imagen principal se siente genérica, el botón de llamada a la acción es demasiado pequeño y el pie de página necesita los enlaces correctos a redes sociales. No aprueba. No pasa nada, para eso está la ronda 1.
Ronda 2. Atiendes las tres notas y subes la versión 2. Como los comentarios de la versión 1 siguen ligados a la versión 1, puedes volver atrás (y el cliente también) y marcar cada uno frente a lo que cambió, en lugar de fiarte de la memoria. El cliente revisa la versión 2, le gusta la dirección, pero pide un último ajuste: la nueva imagen principal está bien, pero el encuadre no funciona en móvil. Todavía no hay aprobación, lo cual es esperable y normal.
Ronda 3. Corriges el encuadre y subes la versión 3. Esta vez el cliente hace clic en aprobar. Esa decisión queda registrada específicamente sobre la versión 3, con su marca de tiempo. Dos meses después, si alguien del lado del cliente pregunta quién aprobó la sección principal, hay una respuesta directa: esta versión, esta fecha, esta decisión, sin depender de la memoria de nadie.
Fíjate en qué lo hizo posible: no se sobrescribió nada, cada ronda de feedback siguió ligada a la versión a la que se refería y la aprobación final apuntaba a una instantánea exacta y todavía existente, no a «lo que esté publicado ahora».
No necesitas Git
Necesitas un sistema que registre las versiones y mantenga el feedback ligado a ellas, para que todos sepan cuál es la versión que cuenta. Mantenlo simple y visual, y tu yo del futuro te lo agradecerá.
Si tu herramienta de revisión actual se te está quedando corta, mira cómo se compara Aligno con GoVisually para una revisión de diseño que tiene en cuenta las versiones, o echa un vistazo a la lista completa de funciones para ver cómo encajan versiones, comentarios y aprobación en un solo lugar.