Plan de rollback antes de desplegar: versión, migraciones y verificación
En la práctica/ 10 min de lectura
Escribe la vuelta atrás antes del deploy: qué versión, una base que el código anterior aguante (expandir y contraer) y un script que decide. Probado en PGlite.
- Bases de datos
- Migración
- QA
En este artículo (8)
- Por qué el plan de rollback se decide antes de desplegar
- Regla 1: una versión identificable y un camino de vuelta
- Regla 2: migraciones que el código anterior aguante (expandir y contraer)
- Regla 3: verificar después de desplegar
- Primero regresa, luego investiga
- Errores comunes
- Preguntas frecuentes
- Checklist
Un plan de rollback es una nota corta que escribes antes de desplegar: a qué versión vuelves, cómo vuelves, si la base de datos sigue funcionando con el código anterior y qué comprobaciones lo deciden. Unas pocas líneas escritas cuando nada está roto convierten un mal despliegue en un paso rutinario y no en una discusión.
Los ejemplos usan una app web en Node en una plataforma que conserva el build anterior, y una tabla pequeña de Postgres. El SQL corrió en PGlite (PostgreSQL 18.6 en WebAssembly) y el script contra un servidor local desechable; los pasos de la plataforma salen de su documentación y no los ejecutamos en un despliegue real. Es la misma nota que vas a necesitar para cada arreglo urgente durante un code freeze antes de Black Friday.
Por qué el plan de rollback se decide antes de desplegar
A las once de la noche, con el checkout devolviendo errores, nadie piensa bien. Hay que responder cuatro cosas a la vez: cuál fue la última versión buena, cómo volver a ella, si la base de datos funciona con ella y quién decide. Si las respuestas viven en la cabeza de alguien, los primeros diez minutos se van en encontrarlas. El plan las mueve a un momento tranquilo y se apoya en tres reglas: conocer la versión y el camino de vuelta, hacer migraciones compatibles con el código anterior y verificar con un script en lugar de una impresión.
Antes, conviene saber qué es un rollback. La guía de Railway para revertir un deploy malo y su página de acciones de deployment son un ejemplo público claro; otras plataformas difieren, así que lee la tuya con esta tabla al lado.
| Qué | ¿Lo devuelve el rollback? | Nota |
|---|---|---|
| La imagen de la app | Sí | Reactiva la imagen Docker de un deployment anterior como deployment nuevo, sin reconstruir |
| Las variables personalizadas | Sí | Vuelven como estaban, así que un cambio de variable malo también se revierte |
| Esquema y datos de la base | La guía no lo describe | No menciona bases de datos ni migraciones: es cosa tuya (regla 2) |
| Deployments más viejos que la retención | No | La opción Rollback no aparece; Redeploy reconstruye desde el código original |
Regla 1: una versión identificable y un camino de vuelta
Haz que cada deploy se pueda identificar: que /healthz devuelva un identificador de versión (el hash corto del commit sirve). Y nombra el destino con ese identificador, «la última versión que funcionó», no «el deploy anterior»: si salieron dos malos seguidos, el anterior también está roto.
Desliza la figura para verla completa
Escribe el camino. En Railway, según su guía, se abre la pestaña Deployments del servicio, se busca el último deployment bueno y en el menú de tres puntos se elige Rollback. Restaura la imagen Docker y las variables personalizadas como un deployment nuevo y activo, sin reconstruir, así que tarda segundos, siempre que la plataforma aún guarde la imagen: 24 horas en Free/Trial, 72 en Hobby, 120 en Pro y 360 en Enterprise. Pasado ese plazo queda Redeploy, que reconstruye desde el código y las variables originales: es más lento y depende de que el build vuelva a salir bien.
No confundas el healthcheck con la verificación. Con una ruta de healthcheck, la plataforma cambia el tráfico solo tras un 200 y, si falla, el deployment anterior sigue sirviendo; pero la guía aclara que corre solo al desplegar. Un cambio que arranca bien y rompe la página de producto lo pasa sin problema.
La plantilla cabe en siete líneas:
- Versión a la que vuelves: el identificador.
- Cómo vuelves: los pasos exactos y quién tiene acceso.
- Ventana: cuánto conserva la plataforma la imagen anterior.
- Base de datos: la última migración y si ya se contrajo (regla 2).
- Criterio: qué resultado dispara el rollback, por ejemplo «el script de verificación sale con código distinto de 0».
- Quién decide: un nombre, con teléfono.
- A quién se avisa: ventas, soporte, la agencia.
Regla 2: migraciones que el código anterior aguante (expandir y contraer)
El rollback devuelve código, no esquema. En PGlite, con una tabla customers(id, email, name), ALTER TABLE customers RENAME COLUMN name TO full_name hizo que el código nuevo funcionara y que el viejo fallara con column "name" does not exist, al leer y al insertar. Un solo paso, y se acabó la vuelta atrás.
La salida es el patrón que Martin Fowler publica como parallel change, o expandir y contraer (texto de Danilo Sato, mayo de 2014): expandir añade lo nuevo junto a lo viejo, migrar mueve a los clientes y contraer quita lo viejo cuando nadie lo usa. El paso de expandir, antes del deploy:
ALTER TABLE customers ADD COLUMN full_name text;
CREATE FUNCTION customers_sync_name() RETURNS trigger AS $$
BEGIN
IF TG_OP = 'INSERT' THEN
NEW.full_name := COALESCE(NEW.full_name, NEW.name);
NEW.name := COALESCE(NEW.name, NEW.full_name);
ELSIF NEW.full_name IS DISTINCT FROM OLD.full_name THEN
NEW.name := NEW.full_name;
ELSIF NEW.name IS DISTINCT FROM OLD.name THEN
NEW.full_name := NEW.name;
END IF;
RETURN NEW;
END $$ LANGUAGE plpgsql;
CREATE TRIGGER customers_sync_name
BEFORE INSERT OR UPDATE ON customers
FOR EACH ROW EXECUTE FUNCTION customers_sync_name();
UPDATE customers SET full_name = name WHERE full_name IS NULL;
ADD COLUMN full_name textañade la columna sin valor por defecto; según la documentación de PostgreSQL, eso no reescribe la tabla.customers_sync_namemantiene las dos columnas iguales: en unINSERTrellena la que el código dejó vacía y en unUPDATEcopia a la otra la que cambió.CREATE TRIGGERla ejecuta antes de cadaINSERToUPDATE, fila por fila.- El
UPDATEfinal copia las filas existentes. En una tabla grande, hazlo por lotes.
Desliza la figura para verla completa
Luego desplegamos la versión nueva, que solo usa full_name. En cualquier orden, cada versión leyó bien las filas que escribió la otra, incluso al volver a la vieja con filas escritas por la nueva; las cuatro filas terminaron con name igual a full_name. Ahí el rollback es seguro. Sin el trigger no lo era: en un control, el insert de la versión nueva falló con null value in column "name" … violates not-null constraint y el update de la vieja dejó full_name desactualizada. El trigger es una versión mínima: pruébalo con tus propios escritores.
Contraer va al final, y solo cuando ya no vas a volver:
ALTER TABLE customers ALTER COLUMN full_name SET NOT NULL;
DROP TRIGGER customers_sync_name ON customers;
DROP FUNCTION customers_sync_name();
ALTER TABLE customers DROP COLUMN name;
SET NOT NULLdejafull_namecomo la columna obligatoria.DROP TRIGGERyDROP FUNCTIONquitan la sincronización, que ya sobra.DROP COLUMN nameelimina la vieja; la documentación aclara que queda invisible, pero el espacio no se libera de inmediato.
Después la versión vieja falla con column "name" does not exist: ya no hay vuelta a ella. Por eso contraer espera a que pase la ventana del rollback, y por eso el plan anota si ya se hizo.
Regla 3: verificar después de desplegar
Un deploy «terminado» solo significa que el proceso arrancó. Este script comprueba cuatro rutas, incluida la versión, y sale con código distinto de cero si algo falla, para que una persona o un pipeline actúen sin interpretar nada:
// Uso: node verify.mjs <url-base> <release-esperada>
const [base, release] = process.argv.slice(2);
const checks = [
{ path: "/healthz", status: 200, ok: (b) => JSON.parse(b).release === release },
{ path: "/", status: 200, ok: (b) => b.includes("<h1") },
{ path: "/products/blue-shirt", status: 200, ok: (b) => b.includes("Add to cart") },
{ path: "/this-page-does-not-exist", status: 404 },
];
let failed = 0;
for (const c of checks) {
try {
const res = await fetch(base + c.path, { signal: AbortSignal.timeout(5000) });
const body = await res.text();
const pass = res.status === c.status && (!c.ok || c.ok(body));
if (!pass) failed++;
console.log((pass ? "ok " : "FAIL ") + c.path + " " + res.status);
} catch (err) {
failed++;
console.log("FAIL " + c.path + " " + err.name + ": " + err.message);
}
}
console.log(failed ? failed + " check(s) failed: roll back" : "all checks passed");
process.exit(failed ? 1 : 0);
- Recibe la URL base y la versión que esperas; cambia las rutas por las de tu proyecto.
- Cada comprobación tiene una ruta, un estado esperado y, si hace falta, una prueba sobre el cuerpo.
/healthzdebe devolver la versión recién desplegada (así detecta que sigue sirviendo la vieja), la página de producto debe contener el botón «Add to cart» (no basta un 200) y una ruta inexistente debe dar 404 (así detecta un servidor que responde 200 a todo). - El
fetchexpira a los cinco segundos; una petición que falla cuenta como fallo. - Sale con
1si algo falló y con0si todo pasó.
Lo corrimos en local contra un servidor de prueba en 127.0.0.1: versión nueva sana, código 0; página de producto con 500, código 1; versión vieja todavía sirviendo, código 1; nada escuchando, código 1. El servidor es una simulación, así que el script vale lo que valgan sus rutas. Para el flujo de compra completo, suma el smoke test del checkout.
Desliza la figura para verla completa
Primero regresa, luego investiga
Si la verificación falla, vuelve primero y entiende después. La versión rota deja de servir y tú reproduces el fallo en una copia, con los registros delante, sin clientes pagando tu tiempo. Un arreglo improvisado sobre producción es otro deploy sin plan.
La excepción es la que justifica la regla 2: con una migración ya contraída no hay a dónde volver, solo un arreglo hacia adelante. Cuando hayas vuelto, anota qué pasó y qué cambias en el plan; el arreglo se despliega como cualquier otro, con su versión, su camino de vuelta y su verificación.
Errores comunes
- Renombrar o borrar una columna en el mismo deploy que usa el nombre nuevo. Deja el rollback sin base compatible. Expande, migra y contrae por separado.
- Dar por hecho que el rollback devuelve la base. La guía de la plataforma habla de imagen y variables, no de datos.
- No saber cuánto dura la ventana. Con 24 horas de retención, un fallo del viernes descubierto el lunes ya no se revierte con un clic.
- Verificar solo la portada. Un 200 en la portada no dice nada de la página de producto ni del carrito.
- Tomar el healthcheck por verificación posterior. Corre al desplegar y no vuelve a mirar.
Preguntas frecuentes
¿Puedo hacer rollback si ya corrí una migración?
Sí, si es compatible con el código anterior. Una migración que solo expande (una columna nullable, una tabla, un índice) no impide volver; una que borra o renombra, sí.
¿Cuánto tiempo tengo para hacer rollback?
Depende de la plataforma. En Railway, según su guía, la imagen se conserva 24 horas en Free/Trial, 72 en Hobby, 120 en Pro y 360 en Enterprise. Después queda Redeploy.
¿Cuál es la diferencia entre rollback y redeploy?
El rollback reactiva una imagen ya construida, con las variables que tenía, sin build. El redeploy construye otra vez desde el código original: tarda más y puede fallar si el build ya no funciona.
¿Es lo mismo que hacer git revert?
No. Un git revert crea un commit nuevo que debe pasar otra vez por el build y el deploy. Primero vuelves con el rollback y después revierte el commit, para que la rama no vuelva a desplegar el cambio malo.
Checklist
- Cada deploy se identifica:
/healthzdevuelve la versión. - El plan nombra la versión a la que vuelves y los pasos están escritos.
- Sabes cuánto tiempo guarda tu plataforma la imagen anterior.
- Las migraciones de este deploy solo expanden; contraer va en uno posterior.
- El script de verificación cubre las rutas que dan dinero y comprueba la versión.
- El criterio del rollback y quién decide están escritos.
Si Black Friday está cerca, cada arreglo urgente del code freeze debería llevar su plan. Y si el cambio es una imagen nueva, anota la anterior antes de tocar nada, como en actualizar Node en Docker.
¿Viste esto en Instagram? Comenta ROLLBACK en el Reel y te mando la guía.
Escrito por

Publicado el 12 de noviembre de 2026 · actualizado el 18 de noviembre de 2026