The Quiet Complexity of Healthcare UX

Most products are used by people who opted in. Healthcare software is often used by people who didn't choose it at all — a nurse handed a new charting system mid-shift, a patient forced into a portal just to see a lab result, a case manager juggling four disconnected tools because that's what the contract bundled together.

That changes what "good design" means. You're not competing for attention or trying to delight anyone. You're trying to disappear — to get out of the way of someone doing something that matters far more than the interface ever will.

Healthcare interfaces carry a particular kind of weight. Mistakes don't just cost conversions; they can cost time with patients, cause missed information, or contribute to errors in care. And yet the users are often rushed, interrupted, tired, and working across systems that were never designed to fit together. Here's what I keep relearning on healthcare projects.

Context switches are the real cost, not clicks#

The "fewer clicks" mantra misses the point in clinical settings. What actually drains people is losing their mental state — re-finding a patient, re-reading a chart, re-remembering what they were about to do before the system interrupted them. Design for continuity, not brevity.

Clinical work is full of interruptions: a call, a colleague's question, an urgent alert, a patient who needs attention right now. Interfaces need to support returning to a task as much as starting one.

Design patterns that help:

• Keep the patient context visible. Name, age, key identifiers, and allergies should stay on screen as people move between sections, so nobody has to wonder whose record they're looking at.
• Preserve unfinished work. Drafts should save automatically. Leaving a form shouldn't mean losing it.
• Show where people left off. Recently viewed patients, incomplete tasks, and unsigned notes should be easy to get back to.
• Avoid unnecessary modal interruptions. Every dialog that blocks the screen is another context switch.

A workflow that takes one more click but never loses someone's place is often far better than a shorter one that does.

Defaults are clinical decisions#

A pre-filled dosage field, a default sort order on a medication list, a "most recent first" assumption — these aren't neutral UI choices. Someone is going to trust the default because they're moving fast and the system looked confident. Treat every default like it has clinical weight, because eventually it will.

That means involving clinical experts in decisions that look purely visual or technical:

• What order should medications, results, or problems appear in?
• What units are shown, and are they always explicit?
• Which fields are pre-filled, and from what source?
• What happens when a value falls outside a normal range — is it highlighted, and how?

It also means making defaults visible. If a value was pre-filled, show where it came from. If a list is filtered, make the filter obvious. Hidden assumptions are where errors hide too.

Design for recognition, not memory#

People in clinical settings carry enormous cognitive load. Interfaces shouldn't add to it by requiring people to remember codes, navigation paths, or information from a previous screen.

• Show relevant information where the decision is made, rather than forcing people to look it up elsewhere.
• Use clear labels instead of abbreviations that vary between departments.
• Make status visible — pending, reviewed, signed, cancelled — rather than implied.
• Make comparisons easy, such as showing the previous result next to the new one.

Every fact the interface remembers is one the user doesn't have to.

Alerts need restraint#

Alerts exist to prevent harm, but too many of them cause a different problem: people learn to dismiss them without reading. When everything is urgent, nothing is.

Good alert design in healthcare means:

• Reserving interruptive alerts for genuinely critical situations.
• Using non-interruptive indicators for lower-priority information.
• Making alerts specific: what's wrong, for which patient, and what to do.
• Reviewing which alerts are routinely overridden, because those are signals of noise.

The goal is an alert system people trust enough to pay attention to.

Accessibility isn't a checklist here — it's the actual user#

Patients using portals skew older, more stressed, and more likely to be using a screen for the first time in a hard moment. If your contrast ratios and tap targets are "technically compliant," you've met the floor, not the need.

Designing for patients means going beyond minimum standards:

• Larger default text and generous spacing.
• Plain language instead of clinical terminology, with explanations where medical terms are necessary.
• Clear, calm explanations of results, including what someone should do next and when to contact their care team.
• Simple navigation focused on the few tasks people actually come to do: see results, book appointments, message a provider, manage prescriptions.
• Support for screen readers, magnification, and other assistive technology, tested in practice rather than assumed.

Patients often open these tools when they're worried. Clarity is a form of care.

Respect the real workflow#

Healthcare software is rarely used in isolation. It sits alongside paper forms, phone calls, other systems, and workarounds people have built over years. Research in these environments often reveals that the official process and the real one are quite different.

That's why observation matters so much. Watching how people actually work — what they write on paper, which spreadsheets they keep, what they copy from one system to another — shows where the software fails them. Those workarounds aren't user error. They're design requirements in disguise.

When possible, research in context: in the clinic, at the front desk, in the back office. Interviews alone rarely capture the interruptions, time pressure, and physical environment that shape how software is used.

Design for safety and recovery#

In high-stakes environments, it's not enough to prevent errors. The interface also needs to help people notice and recover from them.

• Make irreversible actions clear, and confirm them proportionally to their consequences.
• Allow corrections with a clear audit trail rather than silent changes.
• Show summaries before important submissions, such as orders or prescriptions.
• Make it obvious when something failed to save or send.

Safety comes from systems that make mistakes visible and correctable, not from expecting people never to make them.

Invisible when it works#

Healthcare UX rarely produces the flashiest case study. But it's some of the most consequential design work I've done, precisely because so much of it is invisible when it works.

When the patient context stays visible, defaults are deliberate, alerts are meaningful, information is easy to recognize, and patients can understand what they're reading, the software fades into the background. And that's exactly where it belongs — behind the people doing the work that actually matters.