When I started as a designer, I thought perfectionism was a prerequisite for being good at the job. Here’s what I’ve learned over the years about when it helps and when it hurts — and how to make it work in reality.
Keep your battery charged
Weirdly, perfectionism thrives when you’re drained — low energy means endless tweaking. Why? To your monkey brain, it’s safer to keep nudging familiar pixels than to wrap up and move on to the next task. Familiar feels safe; the next thing doesn’t. So the first move is to get your energy back.
And for a designer, energy isn’t just sleep, exercise, and good food — it’s the “outside” stuff too. The breakfast that hit, a new coffee shop, a different desk; the things your commute throws at you — a glass reflection, a station poster, someone’s jacket colorway; a quick scroll through something beautiful on Instagram; how stylish last night’s movie was; the last time you went all-out at work.
COVID pressure-tested this — when the commute and in-between moments vanished, so did the most of the design fuel. Books, videos, Pinterest helped — but they were band-aids.
This isn’t about working only when you feel like it — or lowering quality. It’s about charging up so you can push through. With a full battery, you’ve got the power to do what needs doing until it feels right, and to see what’s essential and what can be cut — because fear of the next step isn’t fogging your judgment anymore.
Perfectionism is a fear response — full battery and fresh input turn the overwhelming unknown into a manageable next step.
Precise polish beats maximal polish
Pareto runs startups and most companies — the first 20% of effort is the standard now; you’re allowed to iterate only if a metric moves. Tough pill to swallow for a design purist like me — but there’s a reason Apple was called “crazy” — it takes major dedication, restraint, sacrifice, a few white lies, plus factors beyond design to “make it” while shipping only the perfect stuff.
Yes, Apple raised expectations for designers. What didn’t rise with them were most teams’ budgets, risk tolerance, or runway. So most products cut corners or follow the market — safe decisions beat whimsical flourishes, and that’s fine.
How did Airbnb, Stripe, Notion, Figma become who they are? They still play 80/20 — but with high core standards, hardcore restraint, and only applying the craft surgically, where it moves the needle. ChatGPT proves it too — tasteful, dead-simple, fast UI that gets out of the way while the model itself does the heavy lifting.
There are two gears: baseline (fast, clear, safe) and art (slow, costly, unforgettable). Default to and master the baseline, deploy art like a scalpel. Ship the minimal lovable product now and do the rest later when you actually know what works and can blend your original intent with fresh learnings.
Sometimes you break the rule — you go full art and chase the version you’d be proud of in 50 years. It rarely lands, but when it does, it’s magical. Do it eyes open — budgeted, deliberate, and rare.
Lovable as a baseline
There’s a pandemic of teams with low-to-moderate core standards abusing “MVP” to ship junk and promise v2 that never comes — extracting the first 20% from their designers again and again.
“We’ll fix it after launch” promises, backlogs that are really graveyards. Metrics and “target audience” waved around to justify shipping broken stuff. Design debt piles up, trust erodes, and you start to feel ashamed of your work without noticing. Everyone gets faster at making worse things. Sounds familiar?
The antidote is minimal lovable product. Not in the traditional sense of being fancy, or an exception for vanity projects — but as the higher core standard we discussed above. Build the smallest meaningful slice that works consistently, doesn’t break in obvious ways, doesn’t annoy you, and doesn’t make you cringe when you share it. Not revolutionary. Not Red Dot Award bait. Just not broken — and satisfying to the people who made it.
Aim for minimal viable product and you tend to undershoot into “barely functional.” Aim for minimal lovable product and you usually land on “actually pretty good.”
How to ship without lowering the bar
Cut scope, not standards. Boil the idea to its simplest form — clean flows that match user mental models, consistent with your design system, native controls and animations, including accessibility basics and all core states. Everything else moves to v2.
Define your own minimal-lovable baseline. Fast, stable, consistent, design-system tokens only; real content and edge cases covered, something you can share without excuses — whatever feels right to you and can be “fast.”
Learn to hit that new baseline fast. Obsessively build tokens, grids, typography rules, and state components — then learn when to ignore them. If the system blocks clarity or speed for v1, craft the one-off by hand and backfill the system later. The goal is muscle memory so obvious, lightweight, systemic design is your default.
Apply 80/20 with taste. Ship the safe baseline now; spend craft precisely where it moves trust, conversion, or retention. If your personal energy tank is empty, refill and ship a smaller slice rather than compromising the baseline.
Dogfood before you ship. When the internal build is ready, can you actually use it and go “oh yeap, nice” before going public?