# There is no such thing as simplicity. Written by Bart Van Hecke · Imported 2026-10-20 **Type:** article “Just make it simpler” is one of the most common requests in product design, and one of the most misunderstood. Simplicity is not the absence of complexity. It is the deliberate organization of it. Every valuable SaaS product handles data, users, integrations, permissions and edge cases, and that complexity grows with the product. You can’t remove it. You can only hide it, channel it and shape it so users never feel its weight. This article covers four principles I apply in every project: define a clear purpose, start small and find your fit, hide complexity behind a well-structured interface, and test your assumptions with real users. When working on digital experiences, I’ve lost count of how many times I’ve heard the request: *“Just make it simpler.”* But simplicity doesn’t exist in nature. Even the smallest life forms are built on astonishingly complex systems. So maybe it’s time we stop *demanding* simplicity as if it’s something we can simply summon. Does that mean we shouldn’t *strive* for it? Of course not, we should. But we need to understand what we’re really asking for. Let’s get one misunderstanding out of the way: **Simplicity is not the absence of complexity — it’s the thoughtful organization of it.** Every meaningful digital product is, by nature, complex. The more valuable a system becomes, the more variables it must handle — data, users, integrations, permissions, edge cases, etc. The myth is that we can *remove* complexity. In reality, we can only *hide* it, *channel* it, or *shape* it so the user doesn’t feel its weight. Imagine you run a small bar with three employees working shifts. You want a simple scheduler: pick a shift, assign it to someone, they accept, done. Easy! But what if that person’s only available for a few hours? What if they cancel? What if you need to rearrange shifts, track hours, or manage pay? And what happens when your little bar turns into a chain of Hard Rock Cafés overnight? The features need to be there to add value, but they can’t overwhelm the user so he abandons the process altogether. Take Google, for instance. I love Google for its ease of use. They invest heavily in user research, and it shows. But they’ve become so vast that even five hundred designers, researchers, and developers couldn’t make it truly *simple* anymore. There are just too many products, too many users, too many moving parts. Simplicity isn’t a starting point — it’s an ongoing pursuit against the natural tide of complexity. ## So how do we cope? If you could walk around inside my head, you’d probably be overwhelmed by the chaos. But somewhere in that chaos, there’s structure — a strange, living kind of order. The same goes for ideas we generate in teams: they start raw and alive, full of potential, but somewhere between concept and delivery, they risk getting buried under “nice-to-haves” and distorted by overthinking. So the real question is: how do good ideas survive the process, and stay simple enough to create real value? A few commendments: ![](../../assets/images/articles/adefd77a47e257d7.webp) ### Thou shalt have a purpose. Unless you’re an anarchist, you’d agree that everything needs a purpose. You can’t design for simplicity if the product’s goal isn’t clear. Every feature should answer one question: “Does this directly serve the core user goal?” If it doesn’t, it’s just clutter. ![](../../assets/images/articles/27200d3814a67710.webp) ### Thou shalt find your fit. The key is not to start too big. Avoid building complex frameworks just because they *look* like progress. Start small. Find a pace and structure that works for you. It won’t be perfect at first, but consistency matters more than perfection. Keep iterating week after week, refining as you go, trimming the process until it fits — until you start seeing real progress. ![](../../assets/images/articles/fc3befe6387f1ff8.webp) ### Thou shalt hide complexity. Behind every seamless experience — think Google Search or the iPhone camera — lies immense complexity, meticulously hidden from view. Every feature is arranged within a carefully designed information architecture that mirrors how users think and behave. The essentials sit right up front, effortlessly accessible, while the secondary features are tucked neatly in the background — never out of reach, just out of the way. The goal isn’t to make the product simple, but to make the *interaction* feel simple. ![](../../assets/images/articles/2ca9783b8307697d.webp) ### Thou shalt test, God damn it! It sounds like telling your eye-rolling twelve-year old to clean up his room day after day, only to find he never does. But testing is so damn crucial to your process, and still, in all my career, I know very little companies that actually do it. Testing is hard, it involves speaking to users, which we don’t like, and most of the time we think we don’t need it, because things are clear as they are. I can deviser many more reasons, but the simple fact is: nobody ever tests! If you’re building something for a customer, how do you actually know that what you’re building is exactly what that customer wants, or needs? Do you ever go past the ‘my user was able to book a room’, toward ‘my user is really happy with the booking experience’? In the projects I consult on, I always push for *lean user testing*. If you think a feature might add value, that’s not a fact — it’s an *assumption*. And assumptions can’t live in your head, or your team’s head for that matter. They need to be tested. At one project I worked on — a platform for coworking spaces — we built a tight feedback loop with our members. Whenever someone requested a new feature, we didn’t just take their word for it. We observed, tested, and watched how people actually behaved. Because here’s the truth: just because a user *asks* for something doesn’t mean it’s a good idea. It’s always better to observe what people *do* than what they *say*. ## God’s final words. Simplicity in digital applications is not about removing complexity, it’s about managing it intelligently. Every feature, every interaction, and every piece of information should serve a clear user goal. Start small, iterate consistently, and validate your assumptions with real users. Organize complexity behind a seamless interface, where the most important actions are obvious and secondary options remain accessible without overwhelming the user. True simplicity emerges when thoughtful design, disciplined prioritization, and continuous feedback work together to make the experience effortless, even if the underlying system is complex. In the end, simplicity isn’t a design *goal* — it’s a design *discipline.* It’s about doing the hard, invisible work so users don’t have to. ## Want this applied to your product? Book a call. [Book a call](https://superflow.design/contact)