Guía Completa de Diseño Responsive para Móviles
Construye layouts que funcionan en cualquier pantalla: breakpoints mobile-first, Grid, Flexbox, container queries, tipografía fluida e imágenes responsive.
Introducción
Un layout que se ve perfecto en tu monitor de 1440px puede romperse apenas alguien lo abre en un teléfono de 375px: las columnas colapsan en tiras ilegibles, las tablas empujan toda la página hacia el costado y los tamaños de fuente pensados para desktop obligan a hacer zoom con los dedos. El diseño responsive es la disciplina de hacer que una sola base de código funcione en todo ese rango, y el CSS moderno por fin permite resolver casi todo sin una sola línea de JavaScript.
Esta guía trata sobre la estrategia: cómo elegir breakpoints, cuándo usar Grid vs. Flexbox vs. container queries, cómo escalar la tipografía de forma fluida y cómo manejar las piezas que suelen romperse primero — imágenes, tablas y la altura del viewport. Si buscas la mecánica profunda de Grid y Flexbox, la Guía Completa de CSS Grid y Flexbox los cubre propiedad por propiedad; aquí nos enfocamos en usarlos para construir layouts que sobrevivan a cualquier pantalla.
Estrategia Mobile-First
Mobile-first significa que tus estilos base apuntan a la pantalla más pequeña y mejoras hacia arriba con media queries min-width. La alternativa — estilizar para desktop y luego sobreescribir hacia abajo con max-width — produce más CSS, overrides más difíciles de razonar y layouts que se rompen en los breakpoints que olvidaste probar.
/* Estilos base — mobile first */
.card {
padding: 1rem;
font-size: 0.875rem;
}
/* Tablet y superior */
@media (min-width: 768px) {
.card {
padding: 1.5rem;
font-size: 1rem;
}
}
/* Desktop y superior */
@media (min-width: 1024px) {
.card {
padding: 2rem;
font-size: 1.125rem;
}
}
Fíjate que la versión móvil necesita menos código: contenido apilado, elementos a ancho completo y un tamaño base legible. Las pantallas más grandes solo agregan lo que necesitan. Ese es el argumento económico de mobile-first: la pantalla pequeña recibe el CSS más simple y la complejidad crece solo donde hay espacio para ella.
Cómo elegir breakpoints
No necesitas un breakpoint por cada dispositivo del mercado — agregalo cuando el layout realmente deja de funcionar: líneas demasiado largas para leer, un grid que aprieta sus celdas, espacio en blanco que se convierte en un cañón. Un conjunto pragmático que cubre la mayoría de los proyectos:
| Breakpoint | Dispositivo típico | Qué suele cambiar |
|---|---|---|
| base (0–639px) | Teléfonos | Una columna, nav apilada, tamaño base |
| 640px | Teléfonos grandes, tablets chicas | Grids de dos columnas, espaciado más denso |
| 768px | Tablets | Aparece el sidebar, la nav pasa a horizontal |
| 1024px | Laptops | Layout multi-columna completo, ancho máximo de contenido |
| 1280px+ | Desktops | Opcional: gutters más anchos, topes de tipografía mayores |
Estos números siguen la convención de Tailwind (sm 640, md 768, lg 1024, xl 1280), que vale la pena adoptar incluso sin Tailwind porque le da a todo el equipo un vocabulario compartido. Lo que importa es la consistencia: cinco breakpoints que de verdad mantienes valen más que doce que solo existen en una hoja de estilos que nadie abre.
Dos breakpoints que la gente olvida: los teléfonos en landscape (~568–812px de alto), donde un hero de 100vh se come toda la pantalla, y los monitores muy anchos (>1600px), donde un max-width sin tope convierte los párrafos en líneas de 200 caracteres.
Cómo Elegir la Herramienta de Layout Correcta
El error responsive más común es usar una media query cuando CSS puede resolver el problema de forma intrínseca. La decisión se reduce a qué debería reaccionar:
| Situación | Herramienta | Por qué |
|---|---|---|
| Header, sidebar, grid general de la página | Media queries | El layout de página depende del viewport, no de un contenedor |
| Card usada en el sidebar Y en la columna principal | Container queries | Mismo componente, distinto ancho disponible |
| Grid de cards o productos | repeat(auto-fit, minmax()) | No hace falta breakpoint: llena el espacio que exista |
| Tamaño de fuente, padding, espaciado de secciones | clamp() | Escalado suave, sin saltos de breakpoint |
| Mostrar u ocultar secciones enteras | Media queries | Cambio estructural ligado al tamaño de pantalla |
Si no estás seguro de si conviene Grid o Flexbox para un layout dado, la guía de CSS Modern Layout los compara patrón por patrón. Para el resto de esta guía, lo que importa es el ángulo responsive de cada uno.
CSS Grid para Layouts Responsive
Grid brilla para estructura de página en dos dimensiones. Para trabajo responsive en realidad necesitas dos patrones — el resto es mecánica que cubre la guía dedicada.
El grid auto-fit
Este es el patrón responsive que más uso. Crea tantas columnas como quepan y deja que las cards se estiren para llenar la fila — cero media queries:
.auto-grid {
display: grid;
gap: 1rem;
grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
}
Ajusta minmax() al ancho mínimo en que tu card sigue siendo legible. 280px funciona para cards de texto; las cards con mucha imagen suelen necesitar 320px. Si una card nunca debería quedar sola en una fila, cambia auto-fit por auto-fill: mantiene los tracks vacíos, así los items conservan su tamaño en vez de estirarse de forma incómoda.
El grid clásico con breakpoints
Cuando quieres control explícito — exactamente 2 columnas en tablets, 3 en desktop:
.grid {
display: grid;
gap: 1rem;
grid-template-columns: 1fr;
}
@media (min-width: 640px) {
.grid {
grid-template-columns: repeat(2, 1fr);
}
}
@media (min-width: 1024px) {
.grid {
grid-template-columns: repeat(3, 1fr);
}
}
Usa esto cuando la cantidad de columnas es una decisión de diseño, no una función del espacio disponible. Las páginas de marketing y los dashboards suelen querer conteos explícitos; las galerías de cards y los listados suelen querer auto-fit.
Reordenar regiones con grid areas
grid-template-areas permite reordenar regiones enteras de la página en un breakpoint sin tocar el HTML — pon main antes que nav en móvil para que el contenido vaya primero:
.layout {
display: grid;
grid-template-areas:
"header header header"
"nav main aside"
"footer footer footer";
grid-template-columns: 200px 1fr 250px;
min-height: 100vh;
}
@media (max-width: 768px) {
.layout {
grid-template-areas:
"header"
"main"
"nav"
"aside"
"footer";
grid-template-columns: 1fr;
}
}
Este ejemplo usa max-width a propósito: apilar todo por debajo de 768px es más simple como una única excepción que como tres bloques min-width. Mobile-first es una guía, no una religión — la regla es elegir la dirección que necesita menos declaraciones.
Patrones de Flexbox
Flexbox maneja layouts unidimensionales: filas y columnas de cosas. Tres patrones cubren la mayoría de las necesidades responsive.
Centrado y sticky footer
.center {
display: flex;
align-items: center;
justify-content: center;
min-height: 100vh;
}
body {
display: flex;
flex-direction: column;
min-height: 100vh;
}
main {
flex: 1;
}
El patrón sticky footer mantiene el footer abajo en páginas cortas sin empujarlo fuera de la pantalla en las largas: flex: 1 en main absorbe el espacio sobrante.
Navegación que colapsa
.nav {
display: flex;
align-items: center;
justify-content: space-between;
gap: 1rem;
padding: 0 1.5rem;
}
.nav-links {
display: flex;
gap: 1.5rem;
}
@media (max-width: 768px) {
.nav-links {
display: none;
}
}
Dos advertencias. Primero, display: none también saca los enlaces del alcance del teclado y de los lectores de pantalla: acompáñalo de un botón de menú visible que los revele, o acabas de hacer tu sitio innavegable en teléfonos. Segundo, prefiere el elemento <details> o un botón disclosure en lugar del hack del checkbox de CSS puro; el hack funciona, pero rompe la gestión del foco y no aporta semántica de accesibilidad.
La trampa del overflow: min-width: 0
Los hijos de un flex se niegan a encoger por debajo del tamaño de su contenido por defecto. Una card con una URL larga o un bloque <pre> va a romper el layout en pantallas angostas sin importar cuántos breakpoints escribas. La solución es una línea:
.card {
display: flex;
flex-direction: column;
gap: 0.75rem;
}
.card-content {
flex: 1;
min-width: 0; /* permite al hijo encoger por debajo de su contenido */
}
Si un layout responsive desborda “al azar” en teléfonos y no encuentras el culpable de ancho fijo, casi siempre es esto.
Container Queries
Las media queries responden “¿qué ancho tiene el viewport?” Las container queries responden “¿cuánto espacio tiene este componente?” Esa diferencia importa apenas un componente vive en más de un contexto: una card que es full-width en móvil, half-width en un sidebar y third-width en un grid.
/* Definir un contexto de contención */
.card-container {
container-type: inline-size;
container-name: card;
}
/* Consultar el tamaño del contenedor */
@container card (min-width: 400px) {
.card {
display: grid;
grid-template-columns: 120px 1fr;
gap: 1.5rem;
}
}
Dale al contenedor de la card 400px o más y pasa a layout horizontal, haga lo que haga el viewport. Pon la misma card en un sidebar angosto y vuelve a apilada por sí sola. Esto es lo que hace a las container queries la herramienta correcta para design systems: el componente lleva su propio comportamiento responsive en vez de depender de breakpoints de página que no saben dónde va a terminar ubicado.
Unidades de container query
Junto a @container tienes unidades relativas al contenedor, no al viewport: cqw (1% del ancho del contenedor) y cqi (1% del inline size). Permiten internos de componente realmente fluidos:
.sidebar {
/* escala con el ancho del propio sidebar, no de la pantalla */
font-size: clamp(0.875rem, 3cqw, 1.25rem);
padding: 2cqi;
}
Las container queries tienen soporte en todos los navegadores actuales (baseline desde 2023). Si todavía necesitas un fallback para navegadores viejos, entrega primero una versión razonable con media query min-width y deja que @container la mejore — la misma lógica de mejora progresiva que mobile-first. Consulta la referencia de container queries en MDN para la sintaxis completa, incluidas las style() queries.
Tipografía y Espaciado Fluidos
Los breakpoints generan saltos visibles: texto cómodo a 767px que de repente queda gigante a 768px. clamp() elimina el salto interpolando entre un mínimo y un máximo con un valor preferido relativo al viewport:
h1 {
/* nunca menos de 1.5rem, nunca más de 3.5rem, ~5vw en el medio */
font-size: clamp(1.5rem, 5vw, 3.5rem);
}
p {
font-size: clamp(1rem, 2.5vw, 1.125rem);
}
La fórmula detrás del valor preferido: elige el ancho de viewport donde quieres que el mínimo deje de aplicar y el ancho donde entra el máximo; el valor del medio es min + (max − min) × (100vw − minVw) / (maxVw − minVw). En la práctica, valores en vw entre 2.5vw y 6vw cubren la mayoría de los casos — solo verifica los extremos para que el valor preferido caiga realmente entre los topes en los anchos de tu diseño.
El mismo truco funciona para el espaciado, que es donde el diseño fluido más rinde. Padding de sección que respira en desktop pero no desperdicia la pantalla del teléfono:
.section {
padding: clamp(1rem, 5vw, 4rem);
margin-bottom: clamp(1.5rem, 4vw, 3rem);
}
Aplica clamp() al ritmo vertical (padding de secciones, márgenes de encabezados) antes de usarlo en el cuerpo de texto: el texto por debajo de ~1.25rem rara vez gana con el escalado, y un término vw demasiado entusiasta puede bajarlo de los 16px que los usuarios esperan. La página de clamp() en MDN tiene todos los detalles de los parámetros.
Imágenes Responsive
Las imágenes causan dos problemas responsive distintos — descargan demasiados datos para pantallas pequeñas y mueven el layout cuando no se conocen sus dimensiones — y cada uno pide un arreglo distinto.
srcset y sizes: cambio de resolución
<img
src="image-800.jpg"
srcset="image-400.jpg 400w, image-800.jpg 800w, image-1200.jpg 1200w, image-1600.jpg 1600w"
sizes="(max-width: 600px) 100vw, (max-width: 1200px) 50vw, 33vw"
alt="Descripción"
width="800"
height="600"
loading="lazy"
decoding="async"
/>
Con srcset listas qué archivos existen y sus anchos reales; con sizes declaras qué ancho va a ocupar la imagen en cada viewport — y esa es la parte que la gente suele hacer mal. Juntas las dos y el navegador descarga el archivo más chico que siga viéndose nítido. Deja sizes fuera o escríbelo mal y asume 100vw, así que una miniatura de 300px termina descargando el archivo de 1600px. Escribe sizes a partir de tu layout real, no de la imagen: un grid de tres columnas es aproximadamente 33vw en desktop, no 100vw.
picture: dirección de arte
srcset elige resoluciones de la misma imagen. Cuando lo que tiene que cambiar es el recorte — un paisaje ancho en desktop vs. un cuadrado en móvil — usa picture:
<picture>
<source media="(max-width: 600px)" srcset="mobile.avif" type="image/avif" />
<source media="(max-width: 1200px)" srcset="tablet.avif" type="image/avif" />
<img src="desktop.jpg" alt="Descripción" width="1600" height="900" />
</picture>
Pon primero los formatos modernos (avif, luego webp) y deja el <img> como fallback: los navegadores eligen el primer <source> que soportan, así que el orden importa. El <img> también es donde viven alt, las dimensiones y los atributos de carga; los <source> solo intercambian el archivo.
Evitar el layout shift
Declara siempre las dimensiones: atributos width/height en el <img> o aspect-ratio en CSS. El navegador reserva la caja antes de que llegue el archivo, lo que elimina el salto de CLS:
.image-container {
aspect-ratio: 16 / 9;
overflow: hidden;
}
.image-container img {
width: 100%;
height: 100%;
object-fit: cover;
}
Para la imagen LCP concreta (normalmente el hero), haz lo contrario de lazy: loading="eager" más fetchpriority="high". Hacer lazy-load del hero es una regresión de LCP auto-infligida clásica en móvil. Más detalles en la guía de imágenes responsive de MDN.
Tablas y Datos Responsive
Las tablas son la causa número uno de overflow horizontal en móvil. Dos estrategias cubren casi todos los casos.
El scroll horizontal es la más simple: envuelve la tabla y deja que haga scroll dentro del wrapper, así la página nunca desborda:
.table-wrapper {
overflow-x: auto;
-webkit-overflow-scrolling: touch;
}
Úsala para datos genuinamente tabulares — matrices de precios, tablas comparativas, logs — donde las columnas deben mantenerse alineadas. El min-width de la tabla controla cuándo aparece el scroll.
La transformación a cards convierte cada fila en una card apilada en pantallas pequeñas, repitiendo el encabezado como etiqueta vía data-label:
@media (max-width: 640px) {
table, thead, tbody, th, td, tr {
display: block;
}
thead {
display: none;
}
tr {
margin-bottom: 1rem;
border: 1px solid #e2e8f0;
border-radius: 0.5rem;
padding: 0.75rem;
}
td {
display: flex;
justify-content: space-between;
}
td::before {
content: attr(data-label);
font-weight: 600;
}
}
Esto necesita data-label en cada <td> del markup. Se lee mucho mejor en teléfonos para datos tipo entidad (listas de usuarios, facturas, configuraciones), pero es la elección equivocada para comparaciones densas donde escanear entre columnas es el punto: una tabla de precios de 20 columnas debería hacer scroll, no apilarse.
Unidades de Viewport y Áreas Seguras
100vh en móvil no es 100vh. El chrome del navegador — barra de direcciones, toolbars — aparece y desaparece al hacer scroll, y el vh clásico toma un valor que no coincide con ninguno de los dos estados. El resultado: heroes con contenido tapado por la barra de direcciones o un hueco abajo. Las unidades dinámicas de viewport lo arreglan:
dvhsigue la altura visible actual — se redimensiona cuando el chrome aparece o desaparece.svhes la altura de viewport más pequeña — garantizada completamente visible.lvhes la más grande — la altura con el chrome completamente oculto.
.hero {
/* siempre completamente visible, aun con la barra de direcciones */
min-height: 100svh;
}
.drawer {
/* sigue al viewport vivo para que el drawer nunca quede cortado */
max-height: 100dvh;
}
Usa svh para todo lo que nunca deba quedar cubierto (heroes, diálogos full-screen) y dvh para elementos que deban seguir al viewport en vivo (drawers pegajosos, hojas de chat). El vh plano sigue sirviendo como fallback: los navegadores que no conocen svh/dvh ignoran la declaración, así que declara vh primero.
Los dispositivos con notch agregan una arruga más. Los iPhones en landscape pueden superponer tus sidebars fijos sobre la zona de sensores. env(safe-area-inset-*) devuelve los márgenes inseguros:
.header {
padding-left: max(1rem, env(safe-area-inset-left));
padding-right: max(1rem, env(safe-area-inset-right));
}
Esto requiere viewport-fit=cover en el meta viewport para tener efecto — sin eso los insets siempre son 0.
Pruebas en Condiciones Reales
La emulación de dispositivos de DevTools es donde todos empiezan — Ctrl+Shift+M en Chrome/Firefox, el Responsive Design Mode de Safari — y sirve para bugs de layout. Lo que no te va a mostrar: rendimiento real de GPU, comportamiento táctil real, diferencias de renderizado de fuentes y el problema del chrome del navegador de la sección anterior.
La jerarquía de pruebas que detecta la mayoría de los bugs:
- Emulación en DevTools para layout, breakpoints e iteración rápida.
- Throttling de red (preset Slow 4G): los bugs responsive suelen ser en realidad bugs de rendimiento — una imagen hero de 2MB que nunca carga expone tu estado de layout-roto-sin-imagen.
- Un teléfono real en el mismo Wi-Fi: remote debugging de Chrome DevTools para Android, Web Inspector de Safari para iOS. Cinco minutos en un dispositivo real encuentran problemas que los emuladores nunca verán: tap targets demasiado chicos, menús que dependen del hover, scroll con tirones.
- Las pruebas de viewport automatizadas detectan regresiones casi gratis. Con Playwright, verificar que el layout no desborde en tus breakpoints son unas pocas líneas:
test('sin overflow horizontal en móvil', async ({ page }) => {
await page.setViewportSize({ width: 375, height: 667 });
await page.goto('/es/guides/');
const overflow = await page.evaluate(
() => document.documentElement.scrollWidth > document.documentElement.clientWidth
);
expect(overflow).toBe(false);
});
Para depuración visual del layout en sí, el clásico truco del outline sigue funcionando:
* {
outline: 1px solid red;
}
Feo, temporal, y muestra al instante qué elemento está causando el overflow. Sácalo antes de commitear.
Auditar un Layout Existente
Cuando heredas una base de código que “casi funciona en móvil”, no la reescribas — audítala en este orden:
- Revisa primero el meta viewport. ¿Falta
width=device-width, initial-scale=1o está mal? Sin esa línea, el resto da igual. - Caza anchos fijos. Busca en la hoja de estilos
width:ymin-width:enpx— cada uno es sospechoso. Reemplázalos por%,fr,max-widthoclamp()donde sea un contenedor. - Revisa los culpables habituales de overflow: tablas sin
.table-wrapper, bloques<pre>sinoverflow-x: auto, URLs largas, hijos flex sinmin-width: 0. - Audita las imágenes: ¿tienen todas las dimensiones declaradas? ¿
srcset/sizespor encima del fold yloading="lazy"solo por debajo? - Revisa las media queries
max-width. Si el código es desktop-first, no tienes que reescribirlo todo de una vez — pero cada feature nuevo debería ser mobile-first, y los bloquesmax-widthse van convirtiendo a medida que los tocas. - Prueba con el dedo la nav y los CTAs a 375px. Botones de menos de ~44×44px y enlaces a menos de ~8px entre sí fallan tanto para usuarios como para WCAG 2.5.5.
- Prueba con contenido real, no con lorem. Un layout que funciona con títulos de 12 caracteres se rompe con copy real. Ahí es donde los grids
auto-fitse ganan su lugar: degradan con gracia en vez de romperse en un breakpoint.
La mayoría de las “reescrituras responsive” terminan siendo 10–20 arreglos puntuales encontrados con exactamente esta lista. Corréla antes de asumir que necesitas un rediseño.
Buenas Prácticas
- Empezar mobile-first — los estilos base apuntan a la pantalla más pequeña y las media queries
min-widthmejoran hacia arriba. - Dejar que CSS haga el trabajo — los grids
auto-fit,clamp()y las container queries eliminan breakpoints en vez de agregarlos. - Escribir
sizesdesde el layout, no desde la imagen — es el ancho renderizado, no el del archivo. - Declarar las dimensiones de las imágenes — los atributos
width/heightoaspect-ratioprevienen el CLS. - Usar
svh/dvhen lugar devhpara todo lo que el chrome del navegador pueda tapar. - Poner
min-width: 0en los hijos flex — es el arreglo de la mayoría de los overflow misteriosos. - Preferir
gapsobre márgenes en flex y grid — espaciado que no colapsa ni se duplica en los bordes. - Probar en un teléfono real — los emuladores no capturan el tacto, la GPU ni el comportamiento del chrome del navegador.
- Limitar el largo de línea — las pantallas anchas convierten los párrafos en ríos;
max-width: ~70chen contenedores de texto los mantiene legibles. - Mantener pocos breakpoints y consistentes — adoptar una escala compartida (como 640/768/1024/1280) en vez de valores ad-hoc.
Errores Comunes
- Escribir todo con media queries
max-width— el CSS desktop-first crece y se vuelve más difícil de sobreescribir. - Anchos fijos en píxeles en contenedores — se rompe en cualquier pantalla más angosta que el valor.
- Ocultar la nav con
display: nonesin ofrecer alternativa — los usuarios de teclado también pierden el menú. - Falta de
sizesen imágenes consrcset— el navegador asume100vwy descarga 4 veces los píxeles necesarios. - Imágenes sin dimensiones — causan layout shift en cada carga.
- Heroes de
100vhen móvil — la barra de direcciones tapa tu CTA; usa100svh. - Lazy-loading en la imagen LCP — una regresión de LCP directa y auto-infligida.
- Tabla sin wrapper
overflow-x: auto— una tabla ancha empuja toda la página hacia el costado. - Hijos flex sin
min-width: 0— el contenido largo desborda en vez de encoger. - Media queries para responsive a nivel componente — la herramienta correcta son las container queries; los breakpoints de página no conocen el contexto del componente.
- Un breakpoint por dispositivo — terminas persiguiendo un mercado en movimiento; corta donde el layout se rompe.
Ver también
- Guía Completa de CSS Grid y Flexbox — la referencia propiedad por propiedad que esta guía cita
- CSS Modern Layout: Grid, Flexbox, Container Queries — comparación patrón por patrón de los sistemas de layout
- Modo oscuro con prefers-color-scheme — media queries más allá del tamaño de pantalla
- Guía de Web Components — donde las container queries se vuelven esenciales
Preguntas frecuentes
¿Debo usar container queries o media queries?
Usa media queries para layout a nivel página — header, sidebar, grid principal — porque esas decisiones realmente dependen del viewport. Usa container queries para responsive a nivel componente — cards, widgets, cualquier cosa reutilizada en contextos distintos — porque el componente debería reaccionar al espacio que recibe, no a la pantalla. Responden a preguntas distintas, así que la mayoría de los proyectos reales necesitan ambas.
¿Cuál es la diferencia entre auto-fit y auto-fill en CSS Grid?
Los dos llenan la fila con tantos tracks como quepan. La diferencia está en qué pasa con el espacio sobrante: auto-fit colapsa los tracks vacíos a cero para que los items existentes se estiren y llenen la fila, mientras auto-fill mantiene los tracks vacíos para que los items conserven su tamaño y dejen huecos. Elige auto-fit cuando los items deban crecer para llenar el espacio; auto-fill cuando un item solo no deba estirarse hasta convertirse en un banner gigante.
¿Cómo manejo el problema de la altura del viewport en móvil?
Los navegadores móviles muestran y ocultan la barra de direcciones al hacer scroll, lo que cambia lo que significa vh. Usa 100dvh para elementos que siguen al viewport en vivo o 100svh para cualquier cosa que deba estar siempre completamente visible. Deja primero una declaración con vh como fallback para navegadores viejos — la cascada se encarga del resto.
¿Cuántos breakpoints debería tener un sitio web?
Menos de los que crees. Un conjunto de trabajo común es 4–5 (como 640/768/1024/1280 más un tope ancho opcional), pero el número correcto es "cuántos lugares donde tu layout realmente se rompe". Cada breakpoint es código que mantener y un estado que probar — si auto-fit, clamp() o las container queries pueden absorber la variación, úsalos en su lugar.
¿Todavía hacen falta media queries con las container queries?
Sí. Las container queries conocen el ancho del componente, no el del viewport — no pueden responder preguntas de página como "¿hay lugar para un sidebar?" o "¿esto es un teléfono?". Tampoco pueden hacer prefers-color-scheme, prefers-reduced-motion ni estilos de impresión. Las media queries manejan el contexto de página; las container queries, el del componente.
¿Siguen siendo necesarias las media queries para prefers-reduced-motion y el modo oscuro?
Sí — y también cuentan como preocupaciones responsive. @media (prefers-color-scheme: dark) reacciona al tema del usuario, @media (prefers-reduced-motion: reduce) a sus necesidades de movimiento, y ninguna depende del tamaño de pantalla. La receta de modo oscuro cubre una implementación completa.
Recursos Relacionados
Web Components — Custom Elements, Shadow DOM y Templates
Guía práctica de Web Components: crear elementos personalizables reutilizables, encapsular estilos con Shadow DOM y componer con templates HTML.
GuideGuía completa de optimización de rendimiento en React
Optimiza aplicaciones React: memoización, virtualización, división de código, análisis del bundle, React Profiler, características concurrentes y Core Web Vitals.
GuideWCAG 2.2 Accesibilidad: Guía para Desarrolladores
Una guía práctica de cumplimiento WCAG 2.2: los cuatro principios POUR, ARIA, navegación por teclado, formularios y modales accesibles, con ejemplos de código reales.