Guías Técnicas

SEO Técnico para Webs Industriales: Lo que vemos, lo que creemos, lo que funciona

Nuestra posición técnica sobre arquitectura, rendimiento y datos estructurados en catálogos B2B. Con código real y métricas verificables.

Publicado
Lectura 6 min

Introducción

En Portocarrero trabajamos principalmente con webs industriales B2B. Catálogos técnicos, fichas de producto con especificaciones, sectores con normativas específicas. Y hay algo que vemos una y otra vez: el SEO técnico se trata como un checklist de plugins en lugar de como una decisión arquitectónica.

Nuestra posición es clara: sin arquitectura limpia, no hay SEO que valga. Puedes instalar Yoast, RankMath o lo que quieras. Si tu web hace 45 consultas SQL por página, si tus URLs son un caos de parámetros, si no tienes schema.org estándar... ningún plugin te va a salvar.

Este artículo expone lo que creemos sobre SEO técnico industrial, lo que vemos en las webs que analizamos, y lo que funciona cuando lo implementamos. Con código PHP real y métricas de proyectos como ProSilicones64.

El problema

Cuando analizamos una web industrial por primera vez, el patrón se repite. Da igual si es WordPress, PrestaShop o un desarrollo a medida antiguo. Los problemas son casi siempre los mismos:

  • URLs que mezclan IDs numéricos, slugs y parámetros GET sin criterio
  • Canonicals mal implementados o directamente ausentes
  • TTFB por encima de 800ms porque cada página ejecuta decenas de queries
  • Cero schema.org, o peor: schema.org mal implementado que confunde a Google
  • Sitemaps monolíticos con miles de URLs sin segmentar
  • Core Web Vitals en rojo porque nadie midió antes de lanzar

Lo que vemos es que estos problemas no vienen de falta de conocimiento SEO. Vienen de falta de arquitectura. De webs que crecieron sin plan, añadiendo plugins y parches hasta que nadie sabe qué hace qué.

Arquitectura de URLs: si no es predecible, no escala

Creemos que la estructura de URLs es la decisión SEO más importante que puedes tomar. No porque Google lo diga (que también), sino porque una URL predecible significa que tu sistema tiene lógica interna. Y esa lógica es lo que permite crecer sin caos.

Lo que vemos en webs industriales es esto:

/producto.php?id=847&cat=3&lang=es
/catalog/view/847
/es/productos/847-perfil-silicona
/product-847/
Lo que implementamos text
/productos/
/productos/{categoria}/
/productos/{categoria}/{producto}/

# Ejemplos reales:
/productos/extrusion/
/productos/extrusion/perfiles-silicona-ferroviario/

Cuatro URLs para el mismo producto. Cuatro formas de llegar al mismo contenido. Para Google, cuatro páginas distintas compitiendo entre sí.

Nuestra posición: una estructura jerárquica estricta, sin excepciones.

Resultado: URLs predecibles, canonicals automáticos, cero duplicados.
ProSilicones64

Pasamos de 127 "Duplicate without user-selected canonical" a 12 en 4 semanas. El 91% de duplicados eliminados solo con arquitectura limpia.

TTFB y Core Web Vitals: el problema no es el HTML, es la base de datos

Vemos webs industriales con TTFB de 2 segundos. Dos segundos para que el servidor empiece a responder. Y cuando analizamos por qué, casi nunca es el HTML. Es la base de datos.

Un catálogo industrial típico tiene productos relacionados con series, sectores, certificaciones, materiales. Cada ficha de producto puede necesitar datos de 5-6 tablas. Si no hay caché, cada visita dispara las mismas consultas una y otra vez.

Nuestra posición: el caché no es optimización, es arquitectura básica. Si tu sistema no tiene caché desde el día uno, está mal diseñado.

Caché a nivel de repositorio php
<?php
class ProductRepository
{
    public function __construct(
        private PDO $db,
        private CacheInterface $cache
    ) {}

    public function findBySlug(string $slug): ?array
    {
        $key = "product_{$slug}";

        // Si está en caché, devolver directamente
        if ($cached = $this->cache->get($key)) {
            return $cached;
        }

        // Si no, consultar y cachear
        $product = $this->queryProduct($slug);
        
        if ($product) {
            $this->cache->set($key, $product, 3600);
        }

        return $product;
    }

    private function queryProduct(string $slug): ?array
    {
        // Una sola query con JOINs, no 15 queries separadas
        $sql = '
            SELECT p.*, s.nombre as serie_nombre, sec.nombre as sector_nombre
            FROM productos p
            LEFT JOIN series s ON p.serie_id = s.id
            LEFT JOIN sectores sec ON p.sector_id = sec.id
            WHERE p.slug = ?
        ';
        
        $stmt = $this->db->prepare($sql);
        $stmt->execute([$slug]);
        return $stmt->fetch(PDO::FETCH_ASSOC) ?: null;
    }
}
Métrica Objetivo Lo que vemos habitualmente
LCP < 2.5s 4-6s
TTFB < 200ms 800-1500ms
CLS < 0.1 0.2-0.4
Queries/página < 10 30-50
Resultado: Primera visita: consulta real. Siguientes visitas: caché. TTFB estable.
ProSilicones64

De 45 queries por página a 8. TTFB de 890ms a 180ms. El LCP bajó de 6.2s a 1.1s.

Schema.org: o lo haces bien o mejor no lo hagas

Vemos dos extremos. Webs sin ningún schema.org, y webs con schema.org generado por plugins que meten datos incorrectos o incompletos. Ambos son malos, pero el segundo es peor porque confunde a Google.

Nuestra posición: schema.org tiene que reflejar datos reales de tu base de datos. No plantillas genéricas. Si tu producto tiene un SKU, una temperatura máxima de operación y una certificación EN 45545-2, eso tiene que estar en el schema.

Schema.org Product con datos reales php
<?php
class ProductSchemaGenerator
{
    public function generate(array $product): array
    {
        $schema = [
            '@context' => 'https://schema.org',
            '@type' => 'Product',
            'name' => $product['nombre'],
            'description' => $product['descripcion_corta'],
            'sku' => $product['sku'],
            'manufacturer' => [
                '@type' => 'Organization',
                'name' => $product['fabricante']
            ],
            'material' => $product['material'],
            'additionalProperty' => []
        ];

        // Propiedades técnicas reales, no genéricas
        if (!empty($product['temp_max'])) {
            $schema['additionalProperty'][] = [
                '@type' => 'PropertyValue',
                'name' => 'Temperatura máxima',
                'value' => $product['temp_max'],
                'unitCode' => 'CEL'
            ];
        }

        if (!empty($product['dureza_shore'])) {
            $schema['additionalProperty'][] = [
                '@type' => 'PropertyValue',
                'name' => 'Dureza Shore A',
                'value' => $product['dureza_shore']
            ];
        }

        if (!empty($product['certificaciones'])) {
            $schema['additionalProperty'][] = [
                '@type' => 'PropertyValue',
                'name' => 'Certificaciones',
                'value' => implode(', ', $product['certificaciones'])
            ];
        }

        return $schema;
    }

    public function render(array $product): void
    {
        $schema = $this->generate($product);
        echo '<script type="application/ld+json">';
        echo json_encode($schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
        echo '</script>';
    }
}
Resultado: Google entiende qué vendes, con qué propiedades, para qué sirve.
ProSilicones64

De 0 rich results a 47 en 3 semanas. CTR en consultas long-tail subió un 24%.

Sitemaps: divide y controlarás

Vemos sitemaps de 15.000 URLs en un solo archivo. Sin prioridades, sin fechas de modificación reales, sin segmentación. Google los procesa, sí. Pero no tienes control sobre qué indexa primero ni puedes diagnosticar problemas por tipo de contenido.

Creemos que un catálogo industrial necesita sitemaps segmentados: productos, sectores, procesos, páginas estáticas. Cada uno con su propio archivo, su propia frecuencia de actualización, su propia monitorización en Search Console.

Generador de sitemaps segmentados php
<?php
class SitemapGenerator
{
    public function __construct(
        private string $baseUrl,
        private ProductRepository $products,
        private SectorRepository $sectors
    ) {}

    public function generateIndex(): string
    {
        $xml = '<?xml version="1.0" encoding="UTF-8"?>';
        $xml .= '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
        
        $sitemaps = ['products', 'sectors', 'processes', 'pages'];
        
        foreach ($sitemaps as $type) {
            $xml .= '<sitemap>';
            $xml .= '<loc>' . $this->baseUrl . '/sitemaps/' . $type . '.xml</loc>';
            $xml .= '<lastmod>' . date('Y-m-d') . '</lastmod>';
            $xml .= '</sitemap>';
        }
        
        $xml .= '</sitemapindex>';
        return $xml;
    }

    public function generateProducts(): string
    {
        $products = $this->products->findAllActive();
        
        $xml = '<?xml version="1.0" encoding="UTF-8"?>';
        $xml .= '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
        
        foreach ($products as $product) {
            $xml .= '<url>';
            $xml .= '<loc>' . $this->baseUrl . '/productos/' . $product['categoria_slug'] . '/' . $product['slug'] . '/</loc>';
            $xml .= '<lastmod>' . $product['updated_at'] . '</lastmod>';
            $xml .= '<changefreq>monthly</changefreq>';
            $xml .= '</url>';
        }
        
        $xml .= '</urlset>';
        return $xml;
    }
}
Resultado: Control granular de indexación. Diagnóstico por tipo de contenido.
ProSilicones64

Tiempo de indexación de productos nuevos: de 2-3 semanas a 3-5 días.

Hreflang: si tienes varios idiomas, hazlo bien o no lo hagas

Vemos webs multiidioma con hreflang implementado a medias. Solo en algunas páginas. O con códigos de idioma incorrectos. O sin el x-default. Google ignora hreflang mal implementado, así que o lo haces completo o estás perdiendo el tiempo.

Nuestra posición: hreflang en todas las páginas, generado automáticamente desde el sistema de rutas, con validación.

Hreflang automático y completo php
<?php
class HreflangGenerator
{
    private array $languages = ['es', 'en', 'fr'];
    private string $defaultLang = 'es';

    public function __construct(
        private Router $router,
        private string $baseUrl
    ) {}

    public function render(): void
    {
        $currentPath = $this->router->getPathWithoutLang();
        
        foreach ($this->languages as $lang) {
            $url = $this->buildUrl($lang, $currentPath);
            $hreflang = $lang === $this->defaultLang ? 'x-default' : $lang;
            
            echo '<link rel="alternate" hreflang="' . $lang . '" href="' . $url . '">';
            
            if ($lang === $this->defaultLang) {
                echo '<link rel="alternate" hreflang="x-default" href="' . $url . '">';
            }
        }
    }

    private function buildUrl(string $lang, string $path): string
    {
        if ($lang === $this->defaultLang) {
            return $this->baseUrl . '/' . ltrim($path, '/');
        }
        return $this->baseUrl . '/' . $lang . '/' . ltrim($path, '/');
    }
}
Resultado: Google entiende qué versión mostrar a cada usuario. Sin competencia entre idiomas.
ProSilicones64

Impresiones en Francia +340% en 2 meses tras implementar hreflang correctamente.

Métricas de referencia: ProSilicones64

Estos son datos reales de un proyecto donde implementamos todo lo anterior. No son promesas, son resultados medidos.

Métrica Antes Después Cambio
TTFB 890ms 180ms -80%
LCP 6.2s 1.1s -82%
Queries SQL/página 45 8 -82%
Duplicados en Search Console 127 12 -91%
Rich results activos 0 47 +47
CTR en long-tail 2.1% 2.6% +24%
Solicitudes de presupuesto/mes 8 31 +287%

Conclusión

Lo que creemos en Portocarrero es simple: el SEO técnico no es una capa que añades al final. Es una consecuencia de tener arquitectura limpia. URLs predecibles, caché desde el día uno, schema.org con datos reales, sitemaps segmentados, hreflang completo.

Vemos webs industriales que gastan miles de euros en contenido y linkbuilding mientras su TTFB está en 2 segundos y tienen 200 duplicados en Search Console. Es tirar el dinero.

La buena noticia es que arreglar la base técnica no es magia. Es código, es arquitectura, es decisiones correctas. Y una vez que está bien, el resto del SEO funciona.

Si quieres saber cómo está tu web industrial a nivel técnico, podemos hacer una auditoría real: medir TTFB, contar queries, revisar schema.org, analizar duplicados, verificar hreflang. Sin humo, sin promesas vacías. Datos verificables sobre los que tomar decisiones.

Solicitar auditoría técnica

Adrián Morín

Desarrollador y arquitectura visual

Responsable del desarrollo técnico, diseño de interfaces y arquitectura web sin dependencias.