Recommended Free Tools
The most reliable responsive sites combine fluid Grid and Flexbox layouts with targeted media queries, container queries, bounded fluid values, and preference-aware styling. Choose each rule according to what should drive the change: the viewport, a component’s available space, a continuously scaling value, or a user setting.
Start with a fluid layout, not a device checklist
Responsive design is an approach rather than a single CSS feature. MDN describes its foundations as fluid grids, fluid images, and media queries; modern Grid and Flexbox are responsive layout methods by default. MDN’s responsive design overview is a useful reference for that foundation.
Build the baseline around the content: let Grid and Flexbox distribute available space, allow items to wrap or change tracks when needed, and constrain images so they do not overflow their containing block. Then add conditional rules only where the content or available space calls for a meaningful change. This avoids treating a list of device widths as the design itself.
Choose the condition that should drive the change
| Technique | Responds to | Best fit |
|---|---|---|
| Media query | Viewport or device features, media type, and user preferences | Page-level layout changes, orientation-specific behavior, and accessibility preferences |
| Container query | A query container’s size or another supported container feature | Reusable components that appear in different layout contexts |
Fluid function such as clamp() |
A continuously varying value, bounded by minimum and maximum values | Type or spacing that should scale smoothly rather than switch at a breakpoint |
These techniques are complementary. A site can use a fluid page layout, a media query for a major navigation change, a container query for a card, and clamp() for a title’s size.
#1 Best Overall
Use media queries for page and device conditions
Media queries can test viewport width, orientation, aspect ratio, media type, and user preferences. Use them when the page as a whole needs a discrete change—for example, changing a multi-column page layout when its available viewport no longer supports the current arrangement. Pick a threshold based on the content’s needs rather than assuming every device in a category has the same width.
The syntax below illustrates a page-level layout transition; the breakpoint is an example, not a universal value:
.page-layout {
display: grid;
grid-template-columns: minmax(0, 2fr) minmax(14rem, 1fr);
gap: 2rem;
}
@media (width < 48rem) {
.page-layout {
grid-template-columns: 1fr;
}
}For the underlying feature syntax and the range of conditions media queries can test, see MDN’s guide to using media queries.
Use container queries for components that move
A card can sit in a wide main column, a narrow sidebar, or a different grid. A viewport breakpoint cannot reliably describe all of those local contexts. A size container query lets descendants adapt to the size of a declared ancestor, so the component can change when its own available space changes.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Declare a container context on the ancestor whose inline size should control the descendant layout. Naming the container makes the intended target explicit, especially if nested containers could otherwise make it unclear which ancestor a query should match.
.article-list {
container-type: inline-size;
container-name: articles;
}
.article-card {
display: grid;
grid-template-columns: 1fr;
}
@container articles (width > 40rem) {
.article-card {
grid-template-columns: 1fr 2fr;
}
}The 40rem threshold here is illustrative: test a real card with its actual text, image ratio, and available width. For details on size container queries, naming, setup, and fallback considerations, see MDN’s container queries guide and the reference for container-type.
Scale local typography and spacing with container units
Container query units let values follow a query container instead of the viewport. cqi is one percent of the query container’s inline size; other units include cqb, cqmin, and cqmax. This can make a component’s typography or spacing respond to where it is placed.
Use bounds when unrestricted scaling could make text or spacing uncomfortable. For example, a component heading can scale with its container while staying within a legible range:
.article-card__title {
font-size: clamp(1.25rem, 1rem + 2cqi, 2rem);
}The container must establish the relevant query context. As with any responsive type, check wrapping and readability at narrow and wide sizes. See MDN’s container query length unit guidance.
Use clamp() for bounded fluid values
clamp(minimum, preferred, maximum) keeps a value within its lower and upper bounds while allowing the preferred expression to vary. It is useful for typography and spacing when the design should change continuously and does not need a discrete layout transition.
.page-title {
font-size: clamp(1.75rem, 1.1rem + 2.5vw, 3.5rem);
}Here, 1.75rem is the floor and 3.5rem the ceiling; the middle expression is the fluid preference. These example values are not a tested prescription. Tune them against the intended type scale, line wrapping, and zoom behavior. A fluid value can reduce the need for a breakpoint whose only purpose is to adjust that value, but it does not replace breakpoints when the layout itself needs to change. MDN explains the function and its use for fluid font sizing in its reference for clamp().
Honor motion preferences
Responsive behavior also includes user settings. The prefers-reduced-motion media feature lets a site adapt when a user has asked the operating system to reduce motion. Non-essential movement—including movement triggered by interaction—should be removed or reduced; do not remove motion that is essential to functionality or conveying information.
@media (prefers-reduced-motion: reduce) {
.animated-element {
animation: none;
scroll-behavior: auto;
}
}Audit transitions and scripted movement as well as animations when implementing this preference. MDN’s reduced-motion reference and media-query accessibility guidance explain the feature and its accessibility context.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Check support and provide a sensible fallback
Do not assume that support for one container-query feature implies support for every newer query form. The basic size-query pattern is distinct from style, scroll-state, and anchored query forms; support can differ among them. Check compatibility for the specific feature and browser versions that matter to your site before depending on a newer form.
For environments where your chosen container-query feature is unsupported, make the baseline Grid or Flexbox layout usable on its own, then consider a media-query fallback if a viewport-based approximation is acceptable. That fallback cannot perfectly reproduce a component’s local context in every placement, so treat it as a graceful alternative rather than an equivalent measurement. MDN’s guide to container size and style queries discusses query categories and compatibility considerations.
Debug responsive behavior systematically
- Test the content, not just the width. Long headings, translated text, unusual image ratios, and empty states can expose failures that a short placeholder does not.
- Test components in each real placement. A card in a sidebar may need a different layout from the same card in a wide list; that is precisely where container queries can help.
- Separate scaling problems from layout problems. Use
clamp()for a value that should grow smoothly; use a conditional layout rule when the arrangement itself should change. - Check user preferences. Verify reduced-motion behavior with the operating system or browser preference enabled, including interaction-triggered effects.
- Inspect the specific feature’s support. Confirm the query type and target browser versions rather than relying on a broad claim about container queries.
Or skip the browser setup
If you need screenshots to check how a page renders at different sizes, ScreenshotNeo is a website screenshot API and MCP server. A single request can return an image or PDF; here is a cURL example:
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Quick Recap
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for request options. Cookie banners are accepted and removed before capture, along with supported newsletter popups and chat widgets; each cleanup step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed. Its MCP server gives AI agents tools to take screenshots, get page information, and capture PDFs. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots.
Sign up for ScreenshotNeo’s free plan.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
