Something’s wrong with UX in SaaS.
Not because Product Design & UXR Teams are bad, but because they’re great.
We got really good at shipping consistency. Design systems snapped every corner to an 8-point grid; research tools produced beautiful, statistically valid answers to the wrong questions; best-case thinking filled screens with side panels, red error banners, and three-dot menus as far as the eye can scroll. Perfect symmetry. Little mercy.
Good design is almost invisible. It’s the “Paste 2-factor code” bubble that appears the second your SMS lands. It’s dragging a file from your desktop straight into a browser window, and it just uploads. No dialog, no drama. It’s rotating an object in Pages with a two-finger twist and feeling it snap into place with a tiny haptic nod, instead of an accurate UI element stating: “89.333°”.
Things that just work, do only what you need, and adapt to the situation you’re actually in.
This is a call to stop decorating workflows and start deleting them.
The trap we built (with love and tokens)
Design systems were meant to scale quality. Instead, they scaled sameness. We optimized for “does it look consistent?” not “does it remove a step?” Research became a factory of averaged truths; edge cases were smoothed into the mean. And because every team must “own” a screen, we kept adding screens. The result: interfaces that look professional and behave bureaucratic. Users click through immaculate friction.
What “near-invisible” looks like (real samples of working patterns)
One-tap intent completion
iOS/macOS read the incoming code and surface a single, focused action right above the keyboard. No copying, no app-switching, no anxiety. Pattern principle: intercept the intent at the moment of highest certainty and remove all choices except the right one.
Two-finger rotation with angle snapping
Direct manipulation plus forgiving constraints. It lets you be imprecise, then quietly makes you precise. Pattern principle: allow messy human input; converge to clean outcomes. Even and specifically on small mobile screens.
Continuity actions that jump the gap
“Text from Camera” on Mac inserts the live-captured text from your iPhone into the active field. No cables, no files. Pattern principle: cross-device is one environment; respect the unit of work, not the device boundary.
Smart defaults that feel psychic
Auto-select the likely meeting length, the usual room, the last-used passenger data. Pattern principle: probability before purity — start with the most likely state and let users deviate.
Drag-and-drop that respects gravity
Take a file from anywhere, drop it into almost any surface, watch upload + progress + conflict handling just… happen. The UI doesn’t explain “supported formats”. It proves support by accepting them. Pattern principle: treat the object, not the form field.
Command palettes that remove the UI
Hit a key, type intent (“share”, “/table”, “resize to 1440”), done. No hunting. Pattern principle: make verbs addressable; make the surface optional.
Undo as a first-class safety net
Confidence through reversible actions makes aggressive simplification possible. Pattern principle: design for recovery, then you can design for speed.
None of those patterns are flashy. All of them delete steps. A lot of “UX work” still tunes pixels on steps that shouldn’t exist. The next decade is about intent inference and situation handling, not prettier panels.
Interfaces must get better at knowing before they get better at showing.
From screens to situations: a practical frame
Three lenses to redesign any flow and the UI shrinks on its own
Intent.
What is the shortest credible guess at what the user wants right now? (History, context, object in focus, time, role.)
Context.
What’s true about the environment that we can use? (Device, network, location, calendar, clipboard, sensors.)
Consequence.
If we’re wrong, how safely can we recover? (Undo, draft, preview, sandbox.)
Three moves (in order) to avoid UI elements slowing the user down
Auto.
Do it outright if confidence is high and consequence is low.
Assist.
Prefill, preselect, or propose with one-tap acceptance.
Ask.
Only when confidence is low and consequence is high; then ask once, clearly.
Anti-patterns to retire (with prejudice)
- Side panels that narrate your database schema. If users must learn your table relationships, you designed for you.
- Mandatory wizards for routine tasks. If the defaults are always the same, the wizard is a tax.
- Error banners as a lifestyle. Pre-validate inputs; inline fixes beat red paragraphs.
- Three-dot menus with graveyard actions. If an action isn’t used, don’t hide it, delete it.
- Notification duct tape. If you need ten toasts to explain what just happened, the thing that happened is wrong.
Ok, here it comes: Christian’s 90-day “Butter by the fishes” workout plan
Weeks 1–3: Ruthless intent mapping.
List your top 10 user jobs. For each, write the intent sentence (“Create PO from last supplier at previous quantities”). Capture signals available at the moment of intent (role, prior actions, clipboard, time, object in focus).
Weeks 4–6: Delete a screen a week.
Take one critical flow and run the Auto → Assist → Ask play. Replace a screen with: auto-apply, command palette action, in-place affordance, or background worker. Ship behind a flag.
Weeks 7–9: Design for recovery.
Add undo, draft states, and safe previews so you can be bold elsewhere. Confidence compounds.
Weeks 10–12: Measure the right pain.
Stop celebrating clicks. Track:
- Time-to-done (TTD) per job.
- Detour rate (any nav away from the primary surface during a job).
- Assist uptake (how often your suggestion was accepted).
- Error-after-submit (should trend to zero; pre-validate).
- Invisible completion ratio (jobs finished without opening a dedicated screen).
If these move, users feel it by lunch.
“But our domain is complex.” Good. Then hide more of it.
Complexity belongs in the system, not on the surface. Compliance, tax, medicine … the stakes demand stronger recovery, not thicker UI. Put the hard logic into automation and validation, not into endless forms. Expose only the levers that change outcomes. Everything else should live in state, not in the interface.
Look at aviation: commercial pilots are paid to operate a plane. They train continuously, renew permits, and pass medical and psychological checks. That’s the discipline required to fly.
Your software is not a plane. It’s closer to an escalator, one of many in the building. Users don’t get paid to operate it; they get paid to get things done. And most of the time, they juggle a dozen such systems every day. Focus on supporting exactly that.
And stop calling AI a co-pilot. It’s not. It’s an assistant and a very powerful one.
What this demands from teams
Senior Management
Feature richness doesn’t make you rich. Value does. Measure outcomes, not output.
PMs / POs
Prioritize deletion as a feature. “Shipped −1 screen” belongs in release notes.
Ops / Legal
Partner early to define safe automation envelopes. Boldness with guardrails.
UXR & Product Design
Stop owning screens; start owning the job-to-be-done. And stop just listening to users; start understanding them. Your artifact is a reduced journey, not a prettier one.
Customer Success
Stop reporting tickets. Start reporting patterns. Your insights should shorten the journey, not just soothe the pain.
Support
Don’t compensate for broken UX. Escalate it. Every workaround you teach is a design debt carried by the user.
Engineers
Invest in primitives. Background workers, reliable undo, eventing, and a first-class command layer. This is the substrate of invisible UX. And yes, use AI for those. Not as an extra chatbot bolted on.
QA / Testers
Don’t just check acceptance criteria. Challenge them. Your job is not to confirm assumptions, but to expose blind spots.
If your next release notes list more components than outcomes, you’re decorating the problem. If your NPS comments say “fast” and “easy,” you’re on track. If they say “engaging” or “looks great,” be careful. The next step isn’t another design system token. It’s the courage to remove the step entirely.
In the more refined words of author and pilot Antoine de Saint-Exupéry (Terre des hommes, 1939):
‘Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.’