What the largest text size does to your layout.
Every screen in your app was designed at one text size: the default. Plenty of people don’t run the default. They’ve nudged the slider up a notch or two, or turned on the accessibility sizes because small type is genuinely hard for them to read. At the far end of that slider, body text isn’t ten percent bigger. On iOS it’s about three times bigger, and a layout that was never tested there tends to fail in the same handful of places.
How far the sizes actually go
iOS calls this Dynamic Type. There are seven standard sizes, from xSmall to xxxLarge, with Large as the default. The Body style is 17pt at Large and 23pt at xxxLarge, which most layouts survive. Behind a separate switch, under Settings › Accessibility › Display & Text Size › Larger Text, are five more accessibility sizes. Body goes 28, 33, 40, 47 and finally 53pt at the largest, AX5. That’s the size where a row that comfortably held thirty characters now holds about ten.
Android has a font size slider in Display settings, and since Android 14 it reaches 200%. Text sized in sp follows the slider and text sized in dp doesn’t, which is why a label someone hard-coded in dp sits unchanged while everything around it grows. Older Android versions topped out lower, and some manufacturers ship their own larger steps, so treat 200% as the setting to test, not a hard ceiling.
Small text grows the most
Neither platform scales everything by the same factor. On iOS, Body roughly triples between the default and AX5, while the big title styles grow by a much smaller proportion, because they were already large. Android 14 made its scaling nonlinear for the same reason: text that’s already big is scaled at a lower rate than small text, so a 200% setting doesn’t turn a 30sp headline into a 60sp one.
That’s the right call for readability, and it has a design consequence people miss: your type hierarchy compresses. At default, a 34pt title over 17pt body is a clear two-to-one step. At the largest sizes the body has caught up most of the way, and if size was the only thing separating a heading from the text below it, the separation is gone. Hierarchy that also rides on weight, colour and spacing survives; hierarchy built on size alone doesn’t. It’s the same reason we lean on spacing to show what belongs together: it keeps working when the sizes stop cooperating.
Where layouts break first
Go through any app at AX5 and the failures cluster. In rough order of how often they show up:
- Horizontal rows. A settings row with a label on the left, a value on the right and a chevron is fine at 17pt. At 53pt the label and the value fight for the same width and one of them truncates to a couple of letters. The fix is to switch the row to a vertical stack at accessibility sizes: label on top, value underneath. SwiftUI exposes this as dynamicTypeSize.isAccessibilitySize, UIKit as preferredContentSizeCategory.isAccessibilityCategory. Apple’s own Settings app does exactly this.
- Fixed heights. A button with a hard 44pt height and a label inside it will clip the label once the text is taller than the box. Use a minimum height plus padding, so the button grows with its content and never shrinks below a usable tap target.
- One-line limits. A title set to a single line with an ellipsis is a reasonable choice at default and a destructive one at AX5, where “Monthly summary” becomes “Mon…”. Let text wrap, and reserve truncation for content that genuinely can’t, like file names.
- Overlapping layers. Text positioned over an image, a badge pinned to the corner of a card, a floating button above a list. These were placed with absolute offsets that assumed a text height. When the text grows, it slides under the thing on top of it.
- Screens that don’t scroll. A sign-up or onboarding screen built to fit exactly one phone height will push its primary button off the bottom. If the container doesn’t scroll, that button is unreachable, which is the one failure here that completely blocks a user.
- Text inside images. Words baked into a PNG don’t scale at all. At AX5 they sit at their original size among text that tripled, which looks like a bug even when it’s technically legible.
Bars are the exception you’re allowed. iOS doesn’t expect tab bars and toolbars to grow until they eat the screen. Instead, the system’s Large Content Viewer shows an enlarged copy of a bar item when the user long-presses it. Standard bar components get this for free; a custom tab bar has to opt in.
Capping the scale is a trap
The quickest way to make a broken screen look right is to stop the text from growing: clamp the scale factor in Flutter, pass a fixed size in UIKit, size the Android text in dp. The screen now matches the design file, and it’s now unreadable for exactly the people who changed the setting. They didn’t turn it up for fun.
There’s a second, quieter version of the trap in Flutter. Code that wraps a fixed number in TextScaler.linear to impose a cap also replaces Android 14’s nonlinear curve with a flat multiplier, so headings grow more than the platform intended while body text is held back. If you need a limit at all, apply it to the one element that can’t grow, such as a tab label, not to the whole app from MaterialApp.
A twenty-minute test
You don’t need a device lab. On iOS, run the app in the simulator and open Environment Overrides from Xcode’s debug bar, which lets you drag the Dynamic Type slider while the app is running and watch every screen reflow live. On Android, the emulator’s Settings app has the same slider, or set it from a terminal with adb shell settings put system font_scale 2.0.
Then walk the main flow three times: at the default, at the largest standard size, and at the largest accessibility size. On each screen look for four things: text that’s clipped, text that’s truncated into nonsense, elements drawn on top of each other, and any button you can’t reach. Write each one down with its screen; most fixes are the same three or four layout changes applied in different places. For a typical indie app with a dozen screens, the whole pass takes about twenty minutes, and the first one usually turns up something on the paywall or the sign-up screen, the two places you least want a user stuck.
If you’re planning to declare Larger Text support in your App Store accessibility labels, this is the test that backs the claim. Do it before you tick the box, not after a user tells you the box was wrong.