Your team has a requirement it cannot drop. The app has to work at the largest accessibility text sizes, or in three languages, or on the smallest phone your customers carry. Every screen now has variants, and every design review becomes a review of each one. Polishing all of them pushes the release out. So someone quietly caps the text size, or ships the default and promises to fix the rest later, and the users who needed the requirement most are the ones who lose.
I ran into this in October in an iPhone app, where a fair share of the expected users are the kind of people who turn the system text size up.
Three options, one sentence
The options were plain. Keep full support for every text size iOS offers, up to the largest accessibility sizes. Cap text at the largest standard size, which locks out the people who need more. Or drop scaling, which would undo the work merged the day before. I kept full support and wrote one sentence that made it affordable:
Review design from the default screenshots. Treat the largest-text screenshots as a breakage check only: every control reachable, no clipped copy, no mid-word breaks.
That sentence splits one acceptance bar into two. At the default size the question is whether the screen is good: spacing, hierarchy, whether the headline reads like a headline. At the largest size the only question is whether it is broken, and three yes-or-no checks answer it. A layout that looks heavy at the largest size passes. A button pushed off the screen fails.
What made the second bar cheap
Two things had to be true for the breakage bar to cost almost nothing per build.
The first was in the code. Every font call in the app goes through one modifier that scales with the system text size. Headlines scale against a larger base style than body text, so they grow least. Text fields grow instead of clipping. The change touched 15 files. One approach was rejected on the way, because it computed the scaled size once and did not redraw when someone changed their text size with the app open. A setting that only takes effect after a restart is a bug no screenshot review catches.
The second was the check. The app already had a UI test that walks its main path through the real interface, typing into the same fields and tapping the same buttons a person would. It attaches a screenshot of every screen, because some of what it looks for is something a person has to see. I ran that walk twice on an erased simulator, once at the default size and once at the largest accessibility size. It passed at both, in 58 and 61 seconds. The screenshots land in two folders, and design review only ever opens one of them.
The bar catching something
A week later the largest-text walk found a real defect. A confirmation banner sat in a stack under the back button, and at the accessibility sizes the stack squeezed its text to one truncated line. The fix was one layout line that lets the banner keep its own height:
CreatedBanner(state: state)
.fixedSize(horizontal: false, vertical: true)
There was nothing to debate about whether it looked good, because at that size that was never the question. The copy was clipped, so it failed, so it got fixed. Without the split, one of two things happens instead. A reviewer spends a design round making every large-size screen beautiful, or nobody looks at the large sizes at all and a user with large text meets a cut-off sentence on their first day.
Write down when you would stop
The decision carries its own exit. If usage data shows that almost no user raises the text size, and the large-size layouts keep costing design time, the cap comes back on the table. Keeping a requirement you cannot measure yet is a reasonable bet. Keeping it with no condition for revisiting it is how a requirement becomes a cost nobody remembers agreeing to.
Where else this applies
The split works for any requirement that multiplies your screens. If your interface ships in Russian, Kazakh and English, judge the design in the language most of your users read, and hold the others to a breakage check: nothing truncated, no word broken mid-line, no untranslated string. If you support small phones, judge the design on the common size and hold the small one to reachability. The breakage check has to be mechanical enough to run on every build. A check that needs a meeting stops running.
The rule I apply now: when a requirement cannot be dropped and cannot be polished everywhere, split the bar. Judge quality at the default. Hold the extremes to a pass-or-fail check that a test run produces on every build, and write down the condition under which you would revisit the requirement. In my case the split cost two folders and a second run of a test that already existed, and it caught a clipped banner before anyone with large text ever saw it.