“I’ve built systems that worked flawlessly—and systems that flopped. Sometimes in the same year. I’ve learned that being an expert doesn’t protect you from ignorance. It just changes where your blind spots hide.”
I’ve been working with Dynamics CRM and Power Platform for over 15 years.
I’ve led successful implementations. I’ve rescued failing projects. I’ve built solutions that transformed how organizations operate.
All of that is true.
It’s also true that I’ve misunderstood clients. Overcomplicated solutions. Forgotten the human side of technology.
🧭 The Duality We Live In
Here’s the paradox nobody tells you early in your career:
The more skilled you become, the easier it is to accidentally build the wrong thing.
Because you see:
- Elegant architectures.
- The “right” way to structure solutions.
- Patterns and best practices you know save time and technical debt.
So you start solving before you’ve finished listening.
⚙️ The Time I “Knew Better”
What feels like a few years ago, I built a complex, layered model-driven app:
- Managed solutions.
- Custom PCF controls.
- Automated ALM pipelines.
- Environment variables leveraged to the maximum.
Technically? Solid.
But the client’s team—who were used to running SSRS reports and using Advanced Find—looked at it like I’d built a spaceship.
They didn’t understand how to maintain it. They were intimidated.
I’d forgotten the most basic rule:
A perfect solution that the client can’t use is a failure.
🔥 Why This Happens
Because as technologists:
- We want to solve the problem properly.
- We want to protect clients from future technical debt.
- We want to build things we’re proud of.
But we also:
- Miss subtle cues from business users.
- Underestimate how much change exhausts people.
- Forget that the best solution might be the simple one.
❌ When Expertise Becomes a Liability
I’ve built solutions with:
- Robust ALM.
- Beautifully layered solutions.
- Advanced security models.
Sometimes those were the right call.
Other times, all the client needed was:
- A canvas app with a single gallery.
- An Excel export.
- A simple Power Automate flow.
I learned the hard way that:
Complexity creates risk. And risk isn’t always worth it.
🛠️ What I’ve Learned
I’m not going to pretend I’m perfectly wise now. But a few things keep me grounded:
1. Listen Like You Know Nothing
Even if you’ve built this exact solution a dozen times before—listen again.
Business needs are never identical. Neither are cultures, people, or politics.
2. Remember Who Has to Maintain It
The best architecture is the one the client’s team can support without calling me for every change.
3. Simplicity Isn’t Laziness
Sometimes the right answer is:
- One screen.
- One table.
- No pipelines.
Not because it’s all I can do—but because it’s all that’s needed.
4. Good Technology Serves People
We’re not building apps for the sake of apps. We’re trying to:
- Save time.
- Reduce errors.
- Help people do their jobs better.
If a solution doesn’t help people feel more capable, it’s a waste.
💡 The Cost of Not Learning This
When we ignore this duality:
- We build solutions that sit unused.
- We frustrate clients who feel shut out of their own systems.
- We create technical debt hidden behind clever architectures.
And the worst part?
We rob ourselves of the satisfaction of building something that actually makes life better for real people.
🧭 I’m Still Learning
I’m proud of my career.
I’m proud of what I know.
I’m equally proud of the moments I’ve said:
“Let’s back this off. Let’s simplify. Let’s listen again.”
Because the truth is:
Being an expert doesn’t mean knowing all the answers. It means knowing how to keep asking the right questions.
👋 Your Turn
When have you built something brilliant—but ultimately wrong for the client?
What did you learn that changed how you work?
Let’s talk. Not about perfection—but about building things that fit.