The Iceberg Illusion
Every time I hear someone say "just make it simple," I smile. Not because simplicity isn't the goal -it absolutely is -but because that statement reveals a fundamental misunderstanding of what simplicity actually requires.
Simple UX is an iceberg. Users see the 10% above the surface: clean interfaces, obvious buttons, intuitive flows. What they don't see is the 90% of complexity beneath -the hundreds of decisions, edge cases, and trade-offs that make that simplicity possible.
After years of designing enterprise software, I've come to appreciate this paradox deeply. The simpler something appears, the more work went into making it that way.
Why Enterprise Products Feel Complicated
Before we can discuss simplification, we need to understand why complexity exists in the first place. Enterprise products aren't complicated because designers don't care about UX. They're complicated because:
Real Business Processes Are Complex
When you're designing a consumer app, you might have a handful of user flows. When you're designing enterprise software, you're often modeling decades of accumulated business logic. Approvals, exceptions, compliance requirements, audit trails -these aren't arbitrary complexity. They exist because businesses need them.
Different Users Need Different Things
Enterprise products serve everyone from first-day employees to 20-year veterans. Power users demand efficiency and shortcuts. New users need guidance and guardrails. These needs often conflict, and the interface has to accommodate both.
Edge Cases Are the Norm
In consumer products, edge cases are rare. In enterprise software, what seems like an "edge case" often represents 30% of your user base. You can't just design for the happy path.
The Cost of Oversimplification
I've seen products fail because they pursued simplicity too aggressively. The symptoms are predictable:
- Missing features that users actually need - In the pursuit of minimalism, critical functionality gets cut
- Hidden complexity that erupts later - Simplifying the UI by pushing complexity elsewhere (like support tickets or workarounds)
- One-size-fits-all that fits no one - Removing customization options that different users genuinely require
The goal isn't to eliminate complexity. It's to manage it thoughtfully.
The Iceberg Model of Design Decisions
When I approach a complex feature, I use what I call the iceberg model. For every visible element, I document the hidden decisions that support it.
Visible Layer: What Users See
- The interface elements
- The copy and labels
- The interactions and animations
- The information hierarchy
Hidden Layer: Supporting Decisions
- Business rules: What logic governs this feature?
- Error states: What happens when things go wrong?
- Permissions: Who can see and do what?
- Performance: How does this scale with data?
- Accessibility: How do different users interact with this?
- Edge cases: What unusual scenarios must we handle?
For every simple button on screen, there might be ten hidden decisions. "Submit" seems straightforward until you consider: What validates? What happens if validation fails? What if the user's session expires? What about concurrent edits? What feedback do we show during processing?
Case Study: Simplifying a Complex Workflow
Let me share a real example. I was tasked with redesigning an approval workflow that had become a nightmare. The existing system had 47 different states an approval could be in. Users were constantly confused about what to do next.
The Wrong Approach
My first instinct was to simplify the states. Combine similar ones. Reduce the 47 down to maybe 10. This is what most designers would do.
But when I mapped out why those states existed, I discovered something crucial: almost every state served a legitimate business purpose. Regulatory compliance, audit requirements, escalation procedures -these weren't arbitrary. They were necessary.
The Right Approach
Instead of reducing complexity, I hid it appropriately. The redesign:
-
Showed users only what they needed to act on - Of the 47 states, most users only ever encountered 5-7. We surfaced those prominently and tucked the rest away.
-
Used progressive disclosure - Details available on demand, not forced on every view.
-
Created smart defaults - The system now predicted the most likely next action, reducing cognitive load.
-
Built contextual help - Instead of explaining everything upfront, we offered guidance exactly when users needed it.
The underlying complexity remained. But users experienced simplicity because we managed their exposure to that complexity.
Principles for Managing Complexity
After years of this work, I've developed several principles:
1. Audit Before You Cut
Before removing anything, understand why it exists. Talk to users who rely on it. Review support tickets. Check usage analytics. The feature you want to remove might be someone's most important workflow.
2. Layers Over Removal
Instead of removing complexity, consider layering it. Put common actions front and center. Make advanced options available but not intrusive. Let users grow into complexity as they need it.
3. Defaults Are Decisions
Every default value represents a decision about what most users need most of the time. Invest heavily in getting defaults right. A good default can eliminate entire steps from a workflow.
4. Consistency Reduces Cognitive Load
When patterns are consistent, users don't have to think about them. They can focus on their actual task. Invest in design systems and enforce them rigorously.
5. Context Reduces Confusion
Don't make users remember things. Show them what they need when they need it. Use contextual help, smart suggestions, and inline validation to guide without overwhelming.
The Designer's Burden
Here's the uncomfortable truth: simple UX requires more work, not less. It requires:
- More research to understand what users actually need
- More ideation to explore solution spaces thoroughly
- More testing to validate that simplification doesn't break workflows
- More documentation to explain the decisions you made
- More collaboration to align stakeholders on trade-offs
When someone asks for "simple," they're really asking you to do the hard work of managing complexity for them. That's the job. And it's a worthy one.
Finding the Balance
The best products I've worked on don't eliminate complexity -they embrace it while shielding users from unnecessary exposure. They acknowledge that the world is complicated while taking responsibility for making it feel manageable.
Simple UX isn't about having fewer features. It's about having the right features, presented at the right time, in the right way. That takes profound understanding of both the problem space and the users navigating it.
The next time someone asks you to "just make it simple," I hope you smile too. Then roll up your sleeves. There's a lot of invisible complexity to wrangle.
What's the most complex feature you've had to simplify? I'd love to hear about your approach.