Migración de WordPress a Strapi 5 y Astro: cómo un servicio para médicos redujo su base 20 veces y subió Lighthouse de 44 a 100A fondo · digest del 20 de noviembre
Bodegón cinematográfico de un espacio de trabajo de ingeniería con una pantalla que muestra la puntuación máxima de Lighthouse 100 y un cuaderno de bocetos con el esquema de arquitectura de la migración a Strapi 5 y Astro.
A fondo8 secciones≈ 39 min

Migración de WordPress a Strapi 5 y Astro: cómo un servicio para médicos redujo su base 20 veces y subió Lighthouse de 44 a 100

La puntuación de Lighthouse móvil subió de 44 a 100, la base de datos bajó de 1 GB a 50 MB y los ingresos por suscripciones crecieron un 225% en un año, junto con la conversión (+90%) y la profundidad de visita (+75%). El equipo de evilUnion no obtuvo estos resultados en una demo sintética, sino en un servicio real de pago para médicos tras migrar por completo de WordPress a Strapi 5 y Astro. Además, el cambio solo era viable bajo una condición estricta: trasladar absolutamente todo (artículos, guías clínicas, manuales PDF de pago, cursos multisección, suscripciones activas, códigos promocionales y contraseñas antiguas) sin que ningún médico perdiera el acceso tras el lanzamiento.

El desarrollador fullstack Artem, de evilUnion, detalló la historia completa de esta migración en un artículo en Habr publicado en el blog de Alexander Bakharev. Es un caso poco común porque no muestra una vitrina con tres colecciones, sino toda la arquitectura en producción: frontend con caché, edición sin depender de programadores, búsqueda híbrida, colas en segundo plano, CRM propio, analítica y excavación en la antigua base de WordPress.

Por qué el antiguo WordPress tocó techo

El servicio para médicos nació originalmente sobre WordPress: entradas estándar, un montón de plugins para suscripciones, cobros automáticos, códigos promocionales, referidos y un CRM integrado. Mientras la audiencia y el catálogo de contenidos eran pequeños, la estructura aguantaba a duras penas. Cuando el proyecto creció, el monolito empezó a fallar por cuatro frentes a la vez.

En primer lugar, el sitio se volvió muy lento en móviles: sacar 44 puntos en Lighthouse Performance para un proyecto de contenidos que vive en gran parte del tráfico orgánico significa perder lectores de forma directa. En segundo lugar, el propio panel de administración se arrastraba, al punto de que abrir y guardar un artículo era una prueba de paciencia. En tercer lugar, el sitio anterior ya había sufrido intrusiones, algo clásico cuando un mismo motor carga con decenas de plugins de terceros. Y en cuarto lugar, lo más grave para el negocio: nadie se fiaba ya de los datos del CRM integrado. Las cifras entre secciones vecinas no cuadraban por filtros internos cuya lógica era casi imposible de rastrear.

Tras migrar al nuevo stack, las caídas de rendimiento desaparecieron, como reflejan las mediciones de carga y navegación antes y después del cambio.

Tiempo de carga (Lighthouse móvil) y navegación (Yandex Metrica): WordPress vs Strapi 5 + Astro

En la práctica, este salto se nota al instante: la página deja de quedarse pensando antes de mostrar el primer texto y los clics dentro del catálogo responden casi de inmediato. No se trata de optimizar imágenes por encima, sino de cambiar toda la arquitectura: en lugar de un monolito pesado, el proyecto pasó a tener un backend independiente en Node.js y un frontend ligero que no envía JavaScript innecesario al navegador.

Strapi 5 como backend único: esquema de datos y flujo de la petición

Cuando escuchas «headless CMS» (un sistema de gestión de contenidos sin plantillas HTML integradas que guarda datos, ofrece un panel y expone todo por API), suele parecer que solo sirve para textos y que para suscripciones, pagos y CRM hará falta otro servidor. El equipo de evilUnion tomó otro camino y convirtió a Strapi 5 en el único backend del proyecto.

Por debajo, Strapi corre sobre Node.js estándar con el framework Koa y soporta PostgreSQL, MySQL, MariaDB y SQLite. En este proyecto eligieron PostgreSQL en Docker detrás de nginx, totalmente self-hosted, para mantener el código y los datos personales en servidores propios. La curva de entrada es baja: defines una entidad desde el editor visual Content-Type Builder o a mano en el archivo schema.json, que son dos formas de ver la misma configuración.

{
  "kind": "collectionType",
  "info": {
    "singularName": "article",
    "pluralName": "articles"
  },
  "options": {
    "draftAndPublish": true
  },
  "attributes": {
    "title": { "type": "string", "required": true },
    "content": { "type": "richtext" },
    "category": {
      "type": "relation",
      "relation": "manyToOne",
      "target": "api::category.category"
    }
  }
}

Al guardar este esquema, Strapi crea automáticamente la tabla en la base de datos, genera el formulario en el panel y levanta los endpoints REST (GET, POST, PUT, DELETE para /api/articles). Todo viene cerrado por defecto: hasta que no habilitas explícitamente los métodos find y findOne para el rol Public, nadie externo puede leer nada. Para integraciones externas se emiten tokens de API con permisos limitados, y ni las contraseñas ni los campos internos se filtran en las respuestas.

Interfaz de Content-Type Builder en Strapi 5 para configurar colecciones, campos y relaciones (Fuente: docs.strapi.io)

Cualquier petición HTTP atraviesa en Strapi 5 una cadena clara: petición → ruta → middleware y policies → controlador → servicio → Document Service API → base de datos. Veamos qué hace cada pieza sin rodeos. middleware y policies interceptan la petición antes de la lógica principal (por ejemplo, para verificar permisos o añadir cabeceras). El controlador analiza los parámetros y devuelve la respuesta HTTP. El servicio encapsula la lógica de negocio reutilizable, que puedes invocar tanto desde el controlador como desde tareas cron o colas en segundo plano. Por último, Document Service API (strapi.documents(...)) habla con la base de datos usando el identificador estable documentId, que en la versión 5 sustituyó a los ID numéricos de la versión 4.

Para evitar que la base se convirtiera en un cajón de sastre, el equipo organizó las entidades en tres niveles desde el principio. Todo lo independiente que es referenciado por otros registros (artículos, categorías, profesores) fue a colecciones. Lo que solo vive dentro de una página concreta (un acordeón dentro de un artículo, un bloque de preguntas y respuestas o la ficha de un docente) se modeló como componentes. Y las páginas de los cursos se armaron con zonas dinámicas, un campo constructor donde el editor añade los componentes permitidos en el orden que necesite.

Otra decisión acertada fue el perfil de usuario. Strapi trae el plugin users-permissions, y resulta tentador colgar todos los campos del suscriptor directamente de ese modelo estándar. El equipo evitó hacerlo y extrajo el perfil a una colección propia api::profile.profile, enlazada con suscripciones, planes, pagos, guías compradas, códigos promocionales, sesiones y favoritos. Así, desde cualquier registro se ve al instante toda la cadena: quién compró, con qué plan, mediante qué pago y con qué código promocional.

Frontend con Astro: páginas estáticas, SSR con caché e islas de React

Para el sitio público, en lugar de los habituales Next.js o Nuxt, eligieron Astro. La gran ventaja de Astro es que, por defecto, envía al navegador HTML puro sin nada de JavaScript del lado del cliente. Los widgets interactivos se montan de forma puntual como «islas» (Astro Islands) en React, Vue o Svelte, de modo que el navegador no tiene que descargar ni procesar el bundle de toda la aplicación para mostrar un simple artículo de texto.

Arquitectura de islas Astro Islands: HTML puro por defecto e interactividad puntual (Fuente: docs.astro.build)

El modo de renderizado se configura página por página mediante on-demand rendering. Las secciones que cambian poco se compilan como archivos estáticos una sola vez durante el build: basta con añadir una línea al principio del archivo. En cambio, los artículos y catálogos se actualizan de forma continua, así que se renderizan en el servidor (SSR) y se cachean en nginx.

---
// Una página que cambia poco se genera en estático durante el build
export const prerender = true;
---

Ese archivo se convierte en HTML listo durante la compilación y se sirve directamente desde disco sin pasar por Node.js. Para los artículos y catálogos vivos se usa renderizado en servidor con una isla puntual de interactividad:

---
// El artículo obtiene los datos desde Strapi en el servidor (SSR)
const { data } = await fetchApi({
  endpoint: 'articles',
  query: { filters: { slug } },
});
---
<ArticleHeader title={data.title} />
<ArticleBody content={data.content} />
<!-- La isla de React solo cargará JS cuando el botón aparezca en pantalla -->
<FavouriteButton client:visible articleId={data.documentId} />

Aquí hay un truco arquitectónico muy elegante sin el cual la caché compartida en nginx no funcionaría. En el servidor, Astro renderiza únicamente la parte pública de la página, idéntica para todos los visitantes y buscadores. Ese HTML se puede cachear entero en nginx y servir a miles de personas sin tocar Strapi. Todo lo personal (materiales cerrados por suscripción, área privada, estado de favoritos o notificaciones) se carga después en el cliente. Además, la directiva client:visible en <FavouriteButton /> retrasa la descarga de su código React hasta que el usuario hace scroll hasta el botón.

Encima añadieron el prefetch integrado de Astro: por defecto empieza a precargar en silencio la siguiente página en cuanto el cursor pasa por encima de un enlace, y se frena solo si detecta conexión lenta o modo de ahorro de datos. Combinado con la caché de nginx, esto dio esa sensación de navegación instantánea. Y si un editor corrige una errata y no quiere esperar a que caduque la caché, solo tiene que pulsar un botón de purga dentro del propio panel de Strapi.

Flujo editorial: CKEditor 5, vista previa en vivo y la trampa de los permisos

La prueba de fuego de cualquier CMS es si los editores dejan de molestar a los desarrolladores por cada detalle. En el Content Manager de Strapi 5 lo básico ya viene resuelto: tablas de registros con filtros, ordenación y búsqueda, además de una Media Library con carpetas, recorte, textos alt y generación automática de distintos tamaños de imagen para que los móviles no descarguen archivos originales pesados.

Las páginas de cursos se construyen con zonas dinámicas: el editor pulsa «Añadir componente» y combina por su cuenta el temario, los docentes, los planes, las reseñas y las preguntas frecuentes, reordenándolos con arrastrar y soltar. Los docentes se vinculan mediante relaciones: si actualizas la foto de un profesor en su ficha, cambia automáticamente en todos los cursos.

Con los editores de texto nativos de Strapi (Markdown y Blocks) ocurrió el clásico choque entre expectativa y realidad: para artículos médicos con tablas complejas se quedaban cortos. En su lugar integraron CKEditor 5 mediante el plugin strapi-plugin-ckeditor y desarrollaron encima cuatro plugins propios para el equipo editorial:

  • inserción de etiquetas médicas de nivel de evidencia y grado de recomendación (UDD y UUR, por sus siglas en ruso, usadas en documentos clínicos);
  • ocultación de fragmentos de texto e imágenes;
  • botones de acceso rápido con descripciones emergentes;
  • manejo correcto de la tecla Tab dentro de listas anidadas.

Al mismo tiempo, quitaron a propósito a los editores la posibilidad de elegir fuente, tamaño y color de texto. Suena estricto, pero en la práctica es una salvación: sin esa restricción, en seis meses los artículos acaban pareciendo un periódico multicolor con tres tipografías distintas.

Pantalla de edición de un registro en Strapi 5 Content Manager con selector Draft/Published y barra lateral (Fuente: docs.strapi.io)

El mecanismo de Draft & Publish (el borrador y la versión publicada viven separados) sirvió incluso para redirecciones SEO. Cuando cambia la URL de un contenido, no borran el registro antiguo, sino que lo pasan a borrador y rellenan el campo redirect_url. El frontend lo detecta y ejecuta la redirección por su cuenta, sin pedir ayuda a un programador.

Para que el editor vea cómo quedará realmente el artículo maquetado, activaron el Preview oficial de Strapi 5. Abre la página real del sitio dentro de un iframe en el panel de administración, con selector entre borrador y publicado.

// config/admin.js — configuración de la vista previa integrada en Strapi 5
preview: {
  enabled: true,
  config: {
    // Permitimos la comunicación con el iframe solo a nuestro dominio
    allowedOrigins: [env('PREVIEW_URL')],
    async handler(uid, { documentId, status }) {
      const pathname = getPreviewPathname(uid, documentId);
      // Devolver null oculta el botón Preview en tablas internas
      if (!pathname) return null;
      const base = `${env('PREVIEW_URL')}${pathname}`;
      return `${base}?token=${env('PREVIEW_SECRET')}&status=${status}`;
    },
  },
},

El frontend en Astro valida PREVIEW_SECRET y renderiza la entrada exactamente con los mismos componentes que en producción, pero saltándose la caché de nginx. Justo al lado, en el panel derecho de la ficha, el equipo añadió dos botones propios: «Abrir página» y «Actualizar caché».

Para evitar que los formularios de guías de pago se volvieran interminables, usaron campos condicionales (conditions.visible en schema.json). El campo de precio price y el archivo de muestra solo aparecen en la interfaz cuando la guía tiene activada la bandera isPremium.

"price": {
  "type": "decimal",
  "conditions": {
    "visible": {
      "==": [{ "var": "isPremium" }, true]
    }
  }
}

Y aquí se esconde un tropiezo muy silencioso de Strapi en producción. Cuando añades un campo nuevo en schema.json, al superadministrador le aparece al instante, pero los roles personalizados de editor no tienen permisos sobre él por defecto. El editor abre la ficha y, en lugar del precio, ve el aviso No permissions to see this field. Hay que asignar los permisos de cada campo nuevo a mano, y olvidarlo es facilísimo. Prueba el interruptor y cambia de rol en el simulador de abajo para ver cómo funcionan los campos condicionales y esta trampa del panel.

Simulador interactivo: campos condicionales y la trampa de permisos en Strapi 5

Este ejemplo sencillo deja claro por qué, tras cada migración de esquema, conviene entrar en la configuración de roles y comprobar la visibilidad de los campos nuevos con ojos de editor, no solo con la cuenta de administrador.

Backend personalizado: Koa, búsqueda híbrida con Meilisearch, colas BullMQ y panel propio

Cuando el CRUD básico se queda corto, Strapi 5 no te impide escribir código de servidor convencional. En el artículo original, Artem advierte en un aviso previo que todos los fragmentos siguientes están simplificados para mostrar la mecánica de las herramientas de Strapi y no deben copiarse a producción sin validación, control de permisos y protección frente a condiciones de carrera (por ejemplo, en producción conviene actualizar un contador de vistas con un incremento atómico en SQL en lugar de leer y escribir por separado).

Así es como, junto a las rutas estándar de un artículo, se añade un endpoint propio para contar lecturas mediante createCoreController, createCoreService y strapi.documents:

Esquema isométrico de la arquitectura modular del backend en Strapi 5 con controladores, búsqueda híbrida en Meilisearch y colas en segundo plano con BullMQ.

// src/api/article/routes/custom.js
module.exports = {
  routes: [
    {
      method: 'POST',
      path: '/articles/:documentId/view',
      handler: 'article.view',
    },
  ],
};

// src/api/article/controllers/article.js
module.exports = createCoreController(
  'api::article.article',
  ({ strapi }) => ({
    async view(ctx) {
      const svc = strapi.service('api::article.article');
      await svc.incrementViews(ctx.params.documentId);
      ctx.status = 204;
    },
  })
);

// src/api/article/services/article.js
module.exports = createCoreService(
  'api::article.article',
  ({ strapi }) => ({
    async incrementViews(documentId) {
      const docs = strapi.documents('api::article.article');
      const article = await docs.findOne({ documentId });
      await docs.update({
        documentId,
        data: { views: (article.views ?? 0) + 1 },
      });
    },
  })
);

Sobre esta capa se acoplan fácilmente otros tres mecanismos nativos: middleware de Koa, hooks de ciclo de vida (lifecycles) y el planificador cron integrado en Server Configuration. El middleware se conecta con una línea en config/middlewares.js y puede modificar la respuesta después de await next(), por ejemplo para añadir Cache-Control a las peticiones GET públicas de artículos. Los lifecycles se disparan de forma automática al crear o editar un registro (muy útil para calcular el tiempo de lectura a 200 palabras por minuto), y el cron marca cada semana los diez contenidos más populares.

// src/middlewares/cache-headers.js — cabeceras de caché tras la respuesta
module.exports = (config, { strapi }) => {
  return async (ctx, next) => {
    await next();
    const isArticles = ctx.url.startsWith('/api/articles');
    if (ctx.method === 'GET' && isArticles && ctx.status === 200) {
      ctx.set('Cache-Control', 'public, max-age=60');
    }
  };
};

// src/api/article/content-types/article/lifecycles.js
const getReadingTime = (html = '') => {
  const words = html.replace(/<[^>]+>/g, ' ').split(/\s+/).length;
  return Math.ceil(words / 200);
};

module.exports = {
  beforeCreate(event) {
    const { data } = event.params;
    data.readingTime = getReadingTime(data.content);
  },
  beforeUpdate(event) {
    const { data } = event.params;
    if (data.content) {
      data.readingTime = getReadingTime(data.content);
    }
  },
};

// config/server.js — cron integrado sin servicio aparte
cron: {
  enabled: true,
  tasks: {
    '0 3 * * 1': async ({ strapi }) => {
      const svc = strapi.service('api::article.article');
      await svc.markPopular({ limit: 10 });
    },
  },
},

La búsqueda fue otro reto aparte. Los médicos rara vez escriben el título exacto de un artículo: usan otra forma gramatical, cometen errores de tipeo o describen síntomas con sus propias palabras. Para resolverlo integraron Meilisearch mediante el plugin oficial strapi-plugin-meilisearch, que actualiza el índice automáticamente ante cualquier edición.

La configuración quedó ingeniosa y limpia: el índice incluye acordeones anidados mediante entriesQuery.populate, limpia el HTML con stripHtml, reduce los títulos a su raíz léxica (stemText) y añade encima el modelo multilingüe de embeddings sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2. Con source: 'huggingFace', Meilisearch descarga y ejecuta el modelo en local sin depender de API externas de pago.

// config/plugins.js — indexación de artículos y embedder local
meilisearch: {
  config: {
    host: env('MEILISEARCH_HOST'),
    apiKey: env('MEILISEARCH_API_KEY'),
    article: {
      entriesQuery: {
        populate: { content: { populate: { accordion: true } } },
      },
      transformEntry({ entry }) {
        return {
          ...entry,
          contentPlain: stripHtml(entry.content),
          stemmedTitle: stemText(entry.title),
        };
      },
      settings: {
        embedders: {
          default: {
            source: 'huggingFace',
            model:
              'sentence-transformers/' +
              'paraphrase-multilingual-MiniLM-L12-v2',
          },
        },
      },
    },
  },
},

Como resultado, el buscador opera en modo híbrido 50/50 (semanticRatio: 0.5): la mitad del peso va a coincidencias léxicas y tolerancia a erratas, y la otra mitad a cercanía semántica. La barra de búsqueda global consulta varios índices en una sola petición, mientras que buscar dentro de una sección concreta (por ejemplo, solo en guías) apunta únicamente a su índice.

La siguiente pieza clave son las colas en segundo plano con BullMQ sobre Redis. El frontend envía un flujo constante de eventos: lecturas, apertura de acordeones, descargas de guías y clics en banners. Si todo eso se escribiera de forma síncrona en la base analítica durante la petición HTTP, el backend se saturaría rápido bajo carga. Con BullMQ, el endpoint encola el trabajo al instante y libera al usuario, mientras un worker lo procesa en segundo plano con tres reintentos y pausa exponencial.

// El endpoint encola la tarea y responde de inmediato
const queue = strapi.plugin('bullmq').service('queue').get('analytics');
await queue.add('track', event, {
  attempts: 3,
  backoff: { type: 'exponential', delay: 2000 },
});

// El worker escribe los eventos en ClickHouse en segundo plano
const workers = strapi.plugin('bullmq').service('worker');
workers.create(queue, async (job) => {
  await writeToClickHouse(job.data);
});

Por las mismas colas pasan las exportaciones pesadas, el recálculo de segmentos y la cancelación de pagos atascados. Para no ir a ciegas en la consola viendo qué está pendiente o qué falló, montaron la interfaz web Bull Board en una página dedicada del servidor Strapi. De paso resolvieron la documentación de la API: el plugin oficial de OpenAPI/Swagger generó los esquemas de las rutas estándar, y el equipo completó los de los endpoints personalizados con ayuda de agentes de IA.

Por último, adaptaron el propio panel de administración. La interfaz de Strapi está hecha en React y expone la Admin Panel API en src/admin/app.js. Como estas extensiones usan el sistema de diseño nativo de Strapi, no se sienten como parches ajenos. Con addEditViewSidePanel añadieron el panel derecho con los botones «Abrir página» y «Actualizar caché». Y con injectComponent (que en Strapi 5 pasó dentro del plugin content-manager) colocaron el botón «Cambiar orden» para reordenar categorías arrastrando, ya que tuvieron que descartar un plugin del catálogo que exigía configuración individual por cada administrador.

// src/admin/app.js — extensión de la interfaz de edición y listado
export default {
  bootstrap(app) {
    const cm = app.getPlugin('content-manager');
    cm.apis.addEditViewSidePanel([ActionsPanel]);
    cm.injectComponent('listView', 'actions', {
      name: 'category-order-sort',
      Component: CategoryOrderSort,
    });
  },
};

Así, alrededor de un único núcleo de Strapi y sin montar un zoológico de microservicios, reunieron la API del sitio, la búsqueda híbrida, las tareas en segundo plano y un panel cómodo para el equipo editorial.

CRM propio, constructor de segmentos y analítica sobre la misma API

¿Recuerdas aquel problema del antiguo CRM en WordPress donde las cifras no cuadraban entre pestañas? En la nueva arquitectura lo resolvieron de raíz: construyeron un CRM aparte en React y TypeScript que ni siquiera tiene base de datos propia. Consulta exactamente la misma API REST de Strapi que el sitio principal. Una sola fuente de verdad, cero discrepancias.

Todo lo que suele costar muchísimo programar en tablas administrativas (paginación en servidor, filtrado, ordenación, carga de relaciones con populate) ya venía resuelto de fábrica en Strapi. Los gestores personalizan las columnas que necesitan y exportan cualquier selección a Excel. La autenticación del personal funciona con Users & Permissions, y los roles personalizados con matriz de acceso por secciones viven en una colección normal de Strapi, así que se puede crear un rol nuevo desde la interfaz sin tocar código.

Un detalle curioso del desarrollo: el frontend del CRM lo construyeron con ayuda de Claude Code. Definieron de antemano en Markdown los tipos de datos, las pantallas y el formato de peticiones a Strapi, dividieron el trabajo en fases y el agente fue implementándolas paso a paso manteniendo un registro de cambios. Funcionó tan bien gracias a la uniformidad de la API de Strapi: bastó especificar una vez el formato de filtros y paginación para que el agente lo aplicara a todas las tablas.

La parte más potente del CRM es el constructor de segmentos. El equipo de marketing arma audiencias como «médicos con suscripción activa que vence en una semana» o «usuarios a los que les falló el cobro automático». Incluye más de 20 tipos de reglas (estado de suscripción, especialidad, páginas visitadas, eventos analíticos) y cualquier combinación AND y OR, tanto para médicos registrados como para visitantes anónimos.

Estas reglas se guardan como un árbol JSON en la colección de segmentos. No hizo falta inventar un lenguaje de consultas propio: una función recursiva corta recorre el árbol y traduce casi todas las condiciones a los filtros estándar $and y $or de Strapi.

// Traducción recursiva del árbol JSON de reglas a filtros de Strapi
async function evaluateNode(node) {
  if (node.logic) {
    const filters = await Promise.all(
      node.conditions.map(evaluateNode)
    );
    return node.logic === 'AND'
      ? { $and: filters }
      : { $or: filters };
  }
  return evaluators[node.type](node);
}

const filters = await evaluateNode(segment.conditions);
const users = await strapi
  .documents('api::profile.profile')
  .findMany({ filters });

Prueba a marcar reglas y alternar entre AND y OR en el miniconstructor de abajo: muestra cómo el árbol de la interfaz se convierte en el objeto filters para Strapi y filtra al momento las fichas del conjunto de prueba.

Simulador interactivo: constructor de segmentos del CRM y filtros de Strapi

En el servicio real, los segmentos se recalculan en segundo plano cada 30 minutos mediante una cola BullMQ. Cuando toca guardar de golpe los resultados en la base de datos, Strapi no obliga a lanzar miles de consultas individuales por el ORM: por debajo ofrece acceso directo a Knex.js (strapi.db.connection) para inserciones por lotes rápidas. Los segmentos listos se sincronizan automáticamente con las listas de correo en Unisender y alimentan al mismo tiempo el módulo publicitario.

Ese módulo publicitario también vive como una colección normal de Strapi. Soporta tres formatos: banner en la cabecera, ventana emergente y banner en el área privada. La creatividad se puede subir como imagen, paquete HTML5 o armarse en el editor integrado (por ejemplo, una promoción con descuento y botón para copiar el código), revisarse al instante en una vista previa adaptable a distintas pantallas y segmentarse por audiencia, páginas y límite de impresiones por sesión. En el sitio opera un único endpoint de Strapi: calcula los segmentos del visitante, devuelve los banners adecuados y envía impresiones y clics a la cola de analítica. Así, marketing lanza campañas en minutos sin intervención de desarrollo.

Toda la analítica recopilada en ClickHouse se visualiza en tableros de Yandex DataLens incrustados dentro de las pantallas del CRM. Para no exponer claves privadas en el navegador, el backend de Strapi genera el token JWT firmado para inserción privada (según la documentación de DataLens, firma PS256 y vigencia máxima de 10 horas).

Investigación en la base de WordPress: pivote de wp_usermeta y 5 sorpresas en los datos

Si piensas que lo más difícil de una migración así es levantar el nuevo frontend, las colas y el CRM, la realidad te devuelve pronto a la tierra. Lo que más tiempo consumió al equipo no fue el código del sitio nuevo, sino averiguar qué había guardado y dónde dentro de la antigua base de WordPress.

WordPress sigue un modelo EAV (Entity-Attribute-Value): casi todo el contenido acaba en wp_posts separado por post_type, mientras que los campos personalizados de decenas de plugins se reparten por wp_postmeta y wp_usermeta en pares clave-valor. Para reconstruir un solo usuario había que pivotar decenas de filas en SQL:

-- Pivotamos las filas EAV de wp_usermeta en un único registro de usuario
SELECT
  u.ID,
  u.user_email,
  MAX(CASE WHEN um.meta_key = 'first_name'
    THEN um.meta_value END) AS first_name,
  MAX(CASE WHEN um.meta_key = 'telefon_lk'
    THEN um.meta_value END) AS phone,
  MAX(CASE WHEN um.meta_key = 'user_registration_select_1667036325'
    THEN um.meta_value END) AS status,
  MAX(CASE WHEN um.meta_key = 'user_registration_select_1667037133924'
    THEN um.meta_value END) AS specialty
FROM wp_users u
LEFT JOIN wp_usermeta um ON um.user_id = u.ID
GROUP BY u.ID;

Fíjate en esas claves de la consulta: descubrir que user_registration_select_1667036325 representaba el estado del usuario solo fue posible a base de pruebas, comparando los valores de la base con el sitio en vivo. Con los años se habían instalado y borrado plugins que dejaban tablas huérfanas sin documentación. Cuando limpiaron toda esa basura y pasaron los datos útiles a tablas relacionales limpias en Strapi, la base se redujo 20 veces, pasando de 1 GB a 50 MB.

Bodegón de ingeniería sobre la normalización de la base de datos: tarjetas EAV caóticas de WordPress transformándose en un modelo relacional compacto de Strapi con compresión de 1 GB a 50 MB.

Antes de lograr una migración limpia tuvieron que resolver cinco anomalías muy reales, escribiendo un tratamiento específico para cada una. Primero, un mismo campo JSON podía aparecer en distintas filas como un objeto JSON válido, como una cadena con JSON anidado o como texto con comillas duplicadas. Segundo, en lugar de fechas vacías (NULL) aparecía 0000-00-00. Tercero, algunas entidades carecían por completo de relaciones por ID, así que tocó emparejar guías compradas y planes por su nombre en texto. Cuarto, encontraron usuarios duplicados con el mismo correo electrónico. Y quinto, las contraseñas estaban guardadas en varios formatos de hash distintos.

Dividieron la migración en una cadena de scripts: primero usuarios, luego planes, después suscripciones y pagos, y al final guías, códigos promocionales y enlaces de referidos. En cada paso el script guardaba un diccionario de correspondencias entre ID antiguos y nuevos, y además conservaron el antiguo ID de WordPress en el perfil de Strapi porque resultó útil para integraciones externas.

No validaron el resultado con reportes SQL oscuros: los agentes de soporte simplemente abrían los perfiles migrados en el nuevo panel de Strapi. Por primera vez en mucho tiempo veían todo junto en una sola ficha: suscripciones, pagos, guías, favoritos, códigos promocionales y sesiones. Si un médico escribía diciendo que le faltaba algo, soporte abría el perfil y lo resolvía sin abrir un ticket para los desarrolladores.

Lista de verificación antes de migrar una base de datos desde WordPress

  • Mapear todos los meta_key en wp_usermeta y wp_postmeta y contrastar las claves crípticas de plugins con las pantallas reales del sitio.
  • Revisar la base en busca de fechas nulas 0000-00-00, correos duplicados y JSON rotos con doble escape antes de lanzar la importación.
  • Localizar entidades sin relaciones por ID que deban emparejarse por nombre textual y preparar reglas de limpieza.
  • Guardar el diccionario old_id -> new_id en cada paso del script y conservar el antiguo ID de WordPress en el perfil para integraciones externas.
  • Hacer una revisión por muestreo de las fichas migradas junto al equipo de soporte directamente en el nuevo panel.

Una vez que las tablas estuvieron en su sitio y soporte confirmó que las suscripciones seguían intactas, quedaba el último punto delicado: dar acceso a miles de médicos al nuevo servicio sin un restablecimiento masivo de contraseñas.

Autenticación propia, servidor MCP integrado y los límites de este stack

Para los usuarios finales del sitio, el equipo también descartó la autenticación estándar de users-permissions y montó la suya propia con rutas, controladores y servicios normales de Strapi sobre la colección de perfiles. Hubo cuatro razones: tener un perfil con decenas de campos y relaciones en una sola tabla resulta más cómodo; necesitaban limitar los dispositivos por cuenta para que no compartieran una suscripción de pago entre diez personas; requerían inicio de sesión con VK y Yandex vinculado a la cuenta ya existente; y lo principal, debían validar los hashes antiguos de WordPress para que miles de médicos entraran al nuevo servicio sin cambiar su contraseña a la fuerza.

Entre las novedades de la plataforma, el caso destaca el servidor MCP integrado (Model Context Protocol, el protocolo abierto con el que agentes de IA como Claude o Cursor se conectan a sistemas externos). Llegó a Strapi 5 en la versión v5.47.0 y se activa con tres líneas en config/server.js:

// config/server.js — activación del servidor MCP integrado en Strapi 5
module.exports = ({ env }) => ({
  mcp: {
    enabled: true,
  },
});

Tras reiniciar y recompilar, se levanta el endpoint /mcp (Streamable HTTP). Un matiz importante de la documentación de Strapi 5: para conectar un agente hace falta un Admin API Token (el servidor rechaza los tokens habituales de Content API). El agente recibe exactamente los permisos asignados a ese token, lo que permite delegarle tareas rutinarias como clasificar cien artículos por categorías sin darle acceso a pagos ni a usuarios.

Además de todo lo que usaron en este proyecto, Strapi 5 incluye de serie i18n para multilenguaje, webhooks ante cambios en registros, el plugin oficial de GraphQL, Strapi CLI para mover datos y archivos directamente entre producción y staging, y proveedores para llevar la biblioteca multimedia a S3.

Por supuesto, esta arquitectura tiene un coste. En lugar de un único hosting tradicional de WordPress, el equipo debe mantener y actualizar todo un ecosistema: Node.js para Strapi, Astro en servidor detrás de nginx, PostgreSQL, Redis con BullMQ, Meilisearch, ClickHouse y la integración con DataLens. Para un blog pequeño, una web corporativa sencilla o un equipo sin experiencia en infraestructura backend, semejante despliegue sería excesivo. Pero cuando un servicio de suscripción choca contra un panel lento, brechas de seguridad y cifras en las que el propio negocio ya no confía, un backend unificado en Strapi 5 con un frontend rápido en Astro compensa de sobra la complejidad inicial.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 20