The "Just Make It Simple" Myth
"Just make it simpler." It's the most common piece of design advice, repeated so often it's become gospel. Simple interfaces are good. Complex interfaces are bad. End of discussion.
Except this oversimplification is killing professional software. When you visit a doctor, would you want them using a “simple” medical record system that hides critical patient data behind minimal UI? When trading stocks, should the platform hide advanced order types because they're “too complex”?
The real world is complex. Professional tools that handle complex problems should reflect that complexity — not hide from it.
The question isn't whether your interface is simple. It's whether your complexity is managed or chaotic. There's a massive difference between thoughtful complexity and accidental complication.
The difference:
Thoughtful Complexity
Reflects the inherent difficulty of the problem being solved. Provides power and flexibility to expert users while remaining learnable.
Accidental Complication
Adds difficulty without providing value. Results from poor design decisions, not problem complexity. Makes simple tasks harder than they need to be.
When Complexity Is Necessary
Some domains are inherently complex. Trying to oversimplify these systems doesn't help users — it handicaps them.
🏥 Clinical Software
A doctor reviewing a patient needs to see vitals, medications, allergies, lab results, imaging, and clinical notes — all at once. Hiding this information behind “clean” interfaces means more clicks, more time, and potentially missed critical details.
Epic's EMR system looks overwhelming to outsiders, but it's designed for professionals who need instant access to comprehensive patient data. The complexity matches the complexity of medical decision-making.
📈 Trading Platforms
Professional traders need real-time market data, advanced order types, options chains, technical indicators, and risk management tools. A “simple” trading app that hides these features isn't user-friendly — it's useless.
Bloomberg Terminal looks like the Matrix, but it packs decades of financial information design into highly efficient displays. Traders pay $24,000/year because the complexity enables split-second decisions worth millions.
🔧 Design Software
Photoshop has hundreds of tools, adjustment layers, blend modes, and filters. It's complex because photo editing is complex. A “simple” photo editor that hides advanced features isn't easier to use — it's less capable.
Adobe has spent decades organizing this complexity into learnable patterns. Panels, tool palettes, and contextual menus make complexity accessible without dumbing it down.
📊 Data Platforms
Analysts need to query databases, join tables, create visualizations, set up filters, and build dashboards. The interface needs to expose SQL capabilities, not hide them behind oversimplified drag-and-drop builders.
Tools like Tableau provide both simple interfaces for basic tasks and complex capabilities for advanced analysis. The key is layered complexity, not forced simplicity.
Notice the pattern: these interfaces are complex because the problems they solve are complex. The users are professionals who need powerful tools, not dumbed-down approximations of what they actually do.
Managed vs Unmanaged Complexity
The key isn't avoiding complexity — it's managing it. Well-designed complex interfaces feel systematic and learnable. Poorly designed ones feel chaotic and overwhelming.
✅ Managed Complexity
- •Consistent patterns that users can learn once and apply everywhere
- •Clear information hierarchy — what's primary vs secondary
- •Logical grouping of related functionality
- •Progressive disclosure — basic first, advanced when needed
- •Smart defaults that work for 80% of use cases
- •Contextual help and guidance when appropriate
❌ Unmanaged Complexity
- •Inconsistent UI patterns that feel random
- •Everything appears equally important (or unimportant)
- •Features scattered without logical organization
- •All complexity visible at once, overwhelming new users
- •Poor defaults that require constant configuration
- •No guidance, users left to figure everything out alone
Managed complexity feels learnable. Users can start with basic tasks and gradually discover more advanced features. The interface teaches them how it works through consistent patterns and logical organization.
Unmanaged complexity feels hostile. Users can't build mental models of how the system works because everything seems arbitrary. They get overwhelmed and give up, or they develop elaborate workarounds to avoid features they can't understand.
The Progressive Disclosure Framework
Progressive disclosure is how you make complex interfaces approachable without dumbing them down. It's about revealing complexity at the right time, in the right context, as users need it.
The Three Layers
1. Essential (Always Visible)
The core functionality users need for 80% of their tasks. This should be immediately accessible and well-organized. Think of this as your interface's “executive summary.”
2. Contextual (Revealed When Relevant)
Additional options that appear based on user actions or context. For example, formatting tools that appear when text is selected, or advanced filters that show after a basic search.
3. Advanced (Available on Demand)
Power-user features accessible through clear pathways but not cluttering the main interface. Keyboard shortcuts, bulk operations, advanced settings, and specialized tools.
Applied Examples:
Gmail Compose
- Essential: To, Subject, Message body, Send button
- Contextual: Formatting toolbar appears when text is selected
- Advanced: BCC, scheduling, confidential mode hidden in expand button
Figma Properties Panel
- Essential: X/Y position, width/height, fill color
- Contextual: Text properties appear when text is selected
- Advanced: Auto-layout constraints, advanced blend modes in collapsed sections
Excel Ribbon
- Essential: Basic formatting, common functions visible on Home tab
- Contextual: Chart tools appear when chart is selected
- Advanced: Data analysis tools on separate tabs for power users
The key is never surprising users with complexity, but also never hiding it completely. Advanced users should be able to find power features quickly, while new users aren't overwhelmed by options they don't understand yet.
Signs Your Complexity Is Working vs Broken
How do you know if your complex interface is helping users or hurting them? These behavioral signals tell the story:
🟢 Working Well (Managed Complexity)
User Behavior
- • Users learn progressively — they start simple, add complexity over time
- • Feature adoption grows steadily as users get comfortable
- • Power users actively use advanced features
- • Users can explain the interface to others
Support Patterns
- • Questions about how to do advanced things, not basic navigation
- • Feature requests for even more functionality
- • Users share workflows and tips with each other
- • Long-term retention is high
🔴 Broken (Unmanaged Complexity)
User Behavior
- • Users avoid features they can't understand
- • They create elaborate workarounds instead of using built-in features
- • High abandonment during onboarding
- • Users stick to minimal feature sets even after months
Support Patterns
- • Same basic questions asked repeatedly
- • Requests to simplify or hide features
- • Users complain about feeling overwhelmed
- • High churn, especially in first 30 days
The Ultimate Test: Can Users Explain It?
Well-managed complexity is learnable and transferable. If users can explain your interface patterns to a colleague, you've probably got it right. If they can't articulate why things work the way they do, your complexity is likely chaotic.
Try this: Ask a power user to walk a new user through your interface. If they struggle to explain the logic, or if they say things like “it's just something you get used to,” that's a signal your complexity needs better organization.
How to Critique Complex Interfaces
Evaluating complex interfaces requires a different approach than critiquing simple consumer apps. Here's how to give meaningful feedback on professional software:
1. Understand the Problem Domain
Before calling something “too complex,” understand what problem it's trying to solve. A trading platform should look different from a consumer banking app because the users have different needs.
Ask: “What would happen if we removed this complexity? Would users be unable to accomplish something important?”
2. Look for Consistent Patterns
Complexity becomes learnable when it follows consistent rules. Look for whether similar functions behave similarly across the interface.
Ask: “If I learn how to do something in one area, can I apply that knowledge elsewhere?”
3. Evaluate Information Hierarchy
Good complex interfaces have clear visual hierarchy. Critical information should be more prominent than secondary details.
Ask: “Can I quickly identify what's most important on this screen?”
4. Test Progressive Disclosure
Check whether the interface reveals complexity appropriately. New users should be able to accomplish basic tasks without being overwhelmed.
Ask: “Could a new user accomplish the main workflow without getting lost in advanced options?”
5. Check for Unnecessary Complication
Even complex interfaces shouldn't have arbitrary difficulty. Look for places where the interface makes simple tasks harder than they need to be.
Ask: “Are there places where the interface adds steps or confusion without providing additional capability?”
The Right Critique Questions
Instead of asking “How can we make this simpler?” try:
- • “How can we make this complexity more learnable?”
- • “Are there patterns that could be more consistent?”
- • “What would better progressive disclosure look like?”
- • “Which complexity serves users vs which just creates confusion?”
- • “How might we better organize this information?”
The Bottom Line
Stop apologizing for complexity that serves your users.
Professional software should be professional-grade. The question isn't whether your interface is simple — it's whether your complexity is thoughtful, learnable, and systematic.
Use progressive disclosure to make complexity approachable. Follow consistent patterns to make it learnable. But don't hide power features just because someone might call them “complicated.”
Your users chose your tool because they need to do complex work. Give them an interface that matches the sophistication of their problems.
Everything You Need to Know
Quick answers to help you get started
Stay in the Loop Design Updates
Get practical design tips and new updates. No spam, unsubscribe anytime.