What does it mean to design expressively?
If you hate reading and just want the visuals, I keep the “pretty” work (process, screens, flows, brand, and UI states) in a separate case study linked below.
This piece is different. This is me trying to figure out what “expressive design” actually means in practice. What it does to cognition. What it does to hesitation. And whether it has anything to do with equity.
Where This Started
I started with a problem that isn’t new: insurance and financial literacy have an equity gap. In high-stakes systems, that gap shows up as hesitation, avoidance, and expensive surprises.
When I looked for objective signals of that gap, the pattern was boring and brutal:
- In one survey of 1,008 adults, 51% couldn’t correctly identify at least one basic insurance term.
- By mid‑2022, 43% of working‑age adults (19–64) were “inadequately insured”
- About 36% of adults report skipping or postponing needed care due to cost in the past 12 months; even among insured adults, 37% still report not getting needed care due to cost.
- 23% of adults had major, unexpected medical expenses in the prior year (median $1,000–$1,999), and 17% report medical debt.
The infrastructure is digitized. The apps technically work. But comprehension has not scaled with complexity
At some point I reframed it for myself. Insurance isn’t hard because users are careless. It’s hard because systems push interpretation onto people. If you already understand the system, you move confidently. If you don’t, you hesitate
So I imagined a product called Charter. Not another insurance app. More of an intelligence layer. Something that turns fine print into visible signals. What’s covered. What you’ll likely pay. What matters next. What deadlines you’re about to miss.
But while designing it, a bigger question started bothering me.
If the real issue is comprehension and anxiety, why are we still designing these systems as flat and emotionally neutral?
What I Mean by “Expressive”
When I say “expressive design,” I’m not talking about decoration. I’m talking about hierarchy amplified on purpose.
Material 3 Expressive by Google is grounded in large-scale UX research (46 studies, 18,000+ participants) examining how people visually scan interfaces. In controlled testing, participants located key UI elements up to 4× faster when expressive hierarchy was applied correctly. Older users also showed reduced fixation disadvantages.
That stuck with me.
Material 3 Expressive increases:
- Contrast between primary and secondary actions
- Component containment (clear visual grouping)
- Emphasis through scale, color, variable fonts and shape
- Intentional focal points that guide first fixation
That gave me permission to design differently. Rather than aiming for minimal and “quiet,” I designed Charter around:
- Where does the eye land first?
- Is related information processed as a unit?
- How quickly can someone move from confusion to action?
It sounds nice in a research summary. But I wanted to know if it holds up somewhere messy. So I tested it in a category that almost resists expression.
Insurance.
The illusion of simplicity
For a long time, I equated minimalism with good design. Fewer colors. More whitespace. Subtle hierarchy. Clean. But I realized something uncomfortable. In complex systems, minimalism can hide the structure people actually need.
But when an interface is visually calm but conceptually dense, users are forced to:
- scan longer
- summarize internally
- interpret dense language
- decide without guidance
Working memory is limited. If someone is spending their mental energy decoding structure, they have less capacity left to actually decide. In practice, that means the “simple” screen can still be exhausting if it requires constant translation in your head.
In insurance and finance, neutrality creates a very specific emotion. Uncertainty. And uncertainty quietly turns into avoidance.
Minimal UI reduces noise. But expressive UI when done well reduces hesitation.
Bigger Buttons? Easy. Right?
When I started designing expressively, I thought it would be simple: increase scale, add color, boost contrast.
It wasn’t.
Get Mohnish Gopi’s stories in your inbox
Join Medium for free to get updates from this writer.
Expressive design is harder than minimal design because it forces you to commit. You can’t hide behind neutrality. Every decision becomes visible. Every signal needs a reason.
I learned quickly that:
- Over-emphasis creates noise.
- Too much containment creates clutter.
- Bold without hierarchy feels loud.
And context still matters. Expressiveness is not universal. Push it too far and usability drops. I went through drafts that technically followed the system but felt stressful. I had to rebalance everything. Strip back. Re-weight hierarchy. Earn every visual decision.
Eventually I stopped thinking to myself “Is this expressive enough?” and just treated it as “Does this reduce hesitation?” That became the real test.
Cognitive load is the real UX bug
In my interviews (and honestly, in my own experience), people don’t say: “I want a prettier interface.” They say:
- “It feels like reading a contract.”
- “I don’t know where to look.”
- “I skim and hope I’m not missing something expensive.”
This is where expressive design became reducing the mental steps required to convert information into action.
I tested that with one core feature: structured outputs instead of paragraphs.
When a user asks, “Am I covered?”, the worst answer is a wall of text. The best answer mirrors how decisions are actually made:
- Coverage status (covered / unclear / not covered)
- Estimated out-of-pocket
- Deductible or limits (so the “why” is visible)
- Next actions (1–3 clear steps)
- Source anchors (so trust is supported)
Beyond the Chat Bubble
I do think conversation is becoming a primary interface. People are increasingly telling systems what they want instead of how to do it. “Am I covered?” “What will I pay?” “Book the cheapest option.”
But I don’t think “chat-only” scales, especially for high-stakes decisions. Research suggests chatbot interfaces can increase cognitive load and sometimes reduce satisfaction compared to structured interfaces. NN/g’s ongoing usability research on AI tools consistently shows that chat introduces new friction: ambiguity, hidden system state, long responses that require interpretation. In other words, users now have to learn how to manage the AI.
So instead of designing chat as a messaging experience, I treated it as a reasoning engine.
Ask in natural language → interpret intent → retrieve context → return structured UI.
That’s where portability and MCP thinking come in. If intelligence is going to surface through multiple AI tools like ChatGPT, Gemini, whatever comes next. The value isn’t the chat bubble anymore, it’s the portable context layer underneath it. Things like policies, deadlines, deductibles, constraints, risk signals. Packaged once. Accessible and queried anywhere.
Conversation becomes the input surface. Structure becomes the output surface. Portability becomes the infrastructure. And that’s very different from simply adding a chat feature to your apps
AI That Draws the UI
There’s a reason entire books exist on visual communication strategy. Brain science consistently shows that we process visuals dramatically faster than text. Some estimates suggest visuals are processed tens of thousands of times faster than words. Roughly 30% of the cerebral cortex is involved in visual processing. We are wired to scan before we read.
One stat that stuck with me: a minute of video is often equated to over a million words in communicative value.
Infographic theory emphasizes three things:
- Reduce interpretation steps
- Surface hierarchy immediately
- Convert abstract data into spatial relationships
Insurance is abstract: deductibles, limits, renewal cycles. In paragraphs, they require translation. In progress bars, alerts, and grouped modules, they require recognition.
So instead of returning paragraphs like: “You have used 44% of your deductible…”
The system renders:
- A deductible progress bar
- A coverage status card
- A renewal alert
- A spending distribution chart
Instead of static dashboards, the AI produces contextual infographics based on live data: coverage usage, deductible progress, alerts, renewals, spending distribution.
This is why I started thinking of it not as “AI answers,” but as generative infographics. The model doesn’t just produce text. It produces render-ready UI modules via JSON which optimized for scanning and action.
No one likes to fill Forms
Then there’s onboarding. Traditional financial apps begin with long forms. Name. Address. Employment. Income. Policy details. It’s friction disguised as compliance.
But people speak 3–4× faster than they type. That alone made me pause.
Why are we still forcing high-friction typing in high-anxiety contexts? So I experimented with voice-based onboarding as a different input model.
Instead of “Fill out these fields,” it becomes, “Tell me about yourself.” The system extracts entities in real time and maps them to structured fields for confirmation.
This reduces effort, preserves thought flow, and turns onboarding into conversation. Voice won’t replace every form. Context still matters. But for long, repetitive, cognitively draining inputs, especially in financial systems — voice as a primary layer feels inevitable.
So Where This Lands
Across everything I read and designed, one thing kept coming back to me. Uncertainty makes people hesitate. And in insurance and finance, hesitation is expensive. It is not always about intelligence or effort. Sometimes it is just about not knowing what something will cost or what a sentence really means.
At some point this stopped being an insurance app experiment and became a personal test. I wanted to see if expressive hierarchy, clearer structure, and generated UI could actually reduce that hesitation. Not in theory. Not in a slide deck. In a real product. So I pushed the research into something tangible and built it.
What changed for me is how I see product design now. Interfaces are not just layouts anymore. They are reasoning surfaces. They shape how intelligence shows up, how trust is built, and how quickly someone can move from confusion to action. That feels like a bigger responsibility than just making something look clean.
Exploring expressive design like this genuinely stretched my brain. It forced me to justify every emphasis and every grouping. There were moments where I thought I had gone too far, and moments where I had not gone far enough. It was frustrating in a good way. The kind that makes you rethink your defaults.
So that is it. This case study is the product of that exploration. I am glad I took the time to go deep on it. And if you are a designer, I hope you try designing expressively at least once, not as decoration but as a way to reduce hesitation where it matters.
Clean is nice. Clarity is better.
