A team ships `<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">`. What do those last two values do, and why will an accessibility reviewer flag them?
answer
- it is about pinch-zoom, not layout
- magnification is how low-vision users read
- WCAG resize and reflow criteria
- iOS Safari ignores it since iOS 10
- real fix is 16px input font-size
basics
~20 smaximum-scale=1 and user-scalable=no stop the user from pinch-zooming the page. That removes the main way low-vision users enlarge content, so it fails accessibility review; Safari on iOS has ignored these values since iOS 10, but Android browsers still honour them.
solid answer
~50 s`user-scalable=no` disables pinch-zoom outright, and `maximum-scale=1` caps zoom at 100%, which amounts to the same restriction. Teams usually add them to make an app "feel native" or to stop iOS from zooming in when a small-font input is focused. Both are accessibility defects: magnification is how many low-vision users read anything, and WCAG's resize requirement expects content to survive being enlarged, so blocking zoom is a common audit finding. Since iOS 10, Safari deliberately ignores `user-scalable=no` and clamps overly small maximum scales precisely because sites abused it; Chrome on Android still honours it unless the user turns on the force-enable-zoom accessibility setting. So the tag both harms users and does not reliably do what its author wanted. The correct viewport content is `width=device-width, initial-scale=1`, and the focus-zoom annoyance is fixed in CSS by not shipping tiny input fonts.
code
html · 5 lines<!-- Blocks pinch-zoom: flagged by every accessibility audit -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
<!-- Correct: zoom stays available to the user -->
<meta name="viewport" content="width=device-width, initial-scale=1">go deeper
Recall that user-scalable=no and maximum-scale=1 switch off pinch-zoom, and that the viewport tag you should write is just width=device-width, initial-scale=1.
Explain why blocking zoom fails accessibility review, name the WCAG resize and reflow expectations, and give the real cause of iOS input auto-zoom — an input font-size below 16 pixels — rather than the workaround.
Show you would trace where the tag came from: a component library, CMS theme or webview wrapper often injects it. Know the per-platform reality, that iOS ignores it and Android can be overridden, and that any UX depending on disabled zoom is already broken.
Own this as policy: put the viewport tag in the shared document shell, forbid scale-locking values in review, and make zoomed reflow part of the definition of done so layouts are fixed rather than pinned.
## What the two values mean The `content` attribute of the viewport meta tag carries scale controls alongside the width: - `initial-scale` — the zoom the page opens at. - `minimum-scale` / `maximum-scale` — the bounds the user may zoom between. - `user-scalable=yes|no` — whether user zooming is permitted at all. `user-scalable=no` and `maximum-scale=1` are two ways of saying the same thing: the user may not enlarge the page. `minimum-scale=1` is the mirror image and blocks zooming out. ```html <!-- accessibility defect --> <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no"> <!-- what you should ship --> <meta name="viewport" content="width=device-width, initial-scale=1"> ``` ## Why teams add them Three motives recur, and it is worth being able to name them in an interview because the fix differs for each. 1. **"It should feel like an app."** Native apps do not pinch-zoom, so a web app that does feels less polished to the person who commissioned it. This is an aesthetic preference being paid for with someone else's access to the content. 2. **iOS zooms in when an input is focused.** Safari on iOS auto-zooms the page when the user taps a form field whose font-size is under 16 pixels, and it does not zoom back out. Blocking zoom suppresses the symptom. The actual fix lives in the stylesheet: give inputs a font-size of at least 16 pixels and the auto-zoom never triggers. 3. **Accidental zoom during drag interactions.** A map, canvas or carousel that handles its own gestures can be disturbed by page zoom. The right answer is to scope gesture handling to that component rather than to disable zoom for the whole document. ## Why it is an accessibility failure Magnification is not a convenience feature. For users with low vision it is the primary reading mechanism, and pinch-zoom is the one magnification control that is always to hand on a phone, needs no settings screen, and works on any page. Taking it away means content that is merely small becomes content that is unreadable. This maps directly onto audit criteria. WCAG's resize-text requirement expects text to be enlargeable to 200% without loss of content or functionality, and the reflow requirement expects content to survive being viewed at that magnification. A viewport tag that pins the scale is one of the most mechanically detectable violations there is, which is why automated accessibility scanners — and every manual audit — flag it immediately. It is close to free to fix, so it reads as carelessness rather than as a tradeoff. ## The values are not even reliable Browsers pushed back on this abuse. Since iOS 10, Safari ignores `user-scalable=no` and does not let a page clamp zoom below the accessibility floor; the user can pinch regardless of what the markup says. Chrome on Android still honours `user-scalable=no` by default, but exposes a *Force enable zoom* accessibility setting that overrides any page. So the practical situation is: the values harm users where they are honoured, do nothing where they are not, and the behaviour differs per platform — the worst of every world. Any interaction design that *depends* on zoom being disabled is already broken on iOS. ## The correct posture Ship `width=device-width, initial-scale=1` and stop there. If you genuinely need a component that consumes pinch gestures, handle those gestures inside that component instead of legislating for the whole document. If focus auto-zoom is the complaint, raise the input font-size. If a layout "falls apart when zoomed", that is a layout bug being hidden rather than fixed — zoom is exactly how a reviewer will discover it. One more habit worth having: check the tag in the rendered HTML rather than in the template. Component libraries, CMS themes and mobile-app webview wrappers all like to inject their own viewport tag, and a `user-scalable=no` you never wrote can arrive with a dependency.
- A designer insists the app must not zoom because pinch gestures fight with an interactive map. What do you propose?Scope the gesture handling to the map component rather than disabling zoom for the document. The map can consume pinch events within its own bounds, leaving the surrounding page zoomable. That also survives iOS, which ignores `user-scalable=no` outright — so a design that depends on page zoom being off is already broken there.
- Why does iOS zoom the page when a user taps an input, and what is the correct fix?Safari on iOS auto-zooms when a focused form control has a font-size under 16 pixels, and it does not zoom back out afterwards. The fix is in CSS: give inputs a font-size of at least 16 pixels. Suppressing it with `user-scalable=no` treats the symptom, removes zoom for everyone, and no longer works on modern iOS anyway.
saying these in an interview costs you the question
- Says blocking zoom is fine because the design is already mobile-friendly
- Treats pinch-zoom as a convenience rather than an assistive mechanism
- Uses user-scalable=no to stop iOS input auto-zoom
- Assumes user-scalable=no works consistently across platforms
- Claims minimum-scale=1 is harmless because it only blocks zooming out