How to strip inherited assumptions from your strategy

The Real Problem Behind Your Issues

Your biggest strategic problems aren't what you think they are. They're inherited assumptions disguised as facts. Every time you say "we've always done it this way" or "our industry requires X," you're probably running headfirst into an invisible constraint that's throttling your entire operation.

Most founders mistake symptoms for root causes. You see slow growth and assume you need more marketing. You see low conversion and assume you need better copy. You see team inefficiency and assume you need better project management. But these are all downstream effects of inherited assumptions you've never questioned.

The real problem is deeper. You're optimizing around constraints that don't exist while ignoring the one bottleneck that actually determines your throughput. This is why throwing more resources at growth rarely works. You're adding complexity to a system that's fundamentally broken at the constraint level.

The constraint is never where you think it is. It's hidden behind layers of inherited wisdom that everyone accepts but no one has tested.

Why Most Approaches Fail

Traditional strategic planning fails because it starts with the wrong question. Instead of asking "what should we do differently," most frameworks ask "how can we do more of what we're already doing." This keeps you trapped in the same inherited assumptions that created your current limitations.

The consulting playbook makes this worse. Best practices are just inherited assumptions wrapped in data from companies that might have completely different constraints than yours. When you implement someone else's solution without understanding their specific bottleneck, you're importing their constraints along with their tactics.

Even worse, most approaches add complexity instead of removing it. They give you more metrics to track, more processes to follow, more initiatives to manage. But if your real constraint is something fundamental — like the wrong business model or misaligned incentives — all that additional complexity just makes the core problem harder to see.

This is the Complexity Trap in action. You think more sophisticated systems will solve your problems, but they actually obscure the simple truth: one constraint is determining everything, and until you find and fix it, nothing else matters.

The First Principles Approach

First principles thinking means stripping away everything you assume to be true and starting with fundamental laws. For strategy, this means identifying the actual constraint that governs your throughput, not the one you inherited from industry wisdom or past experience.

Start by mapping your value creation process as a series of steps. Where does value enter your system? Where does it get stuck? Where does it leave? Most importantly, which single step determines the speed of everything else? This is your constraint, and it's probably not where conventional wisdom says it should be.

For example, you might assume your constraint is lead generation because that's where most SaaS companies focus. But when you trace the actual flow, you discover your constraint is onboarding velocity. New customers take 90 days to see value, so even perfect lead generation won't help. Your inherited assumption — that more leads equals more growth — was masking the real bottleneck.

Once you identify the true constraint, build your entire system around optimizing it. This means subordinating everything else to constraint optimization. If onboarding velocity is your constraint, your product roadmap, sales process, and customer success function should all prioritize faster time to value over everything else.

The System That Actually Works

The constraint-based system works because it aligns all your resources around the one thing that actually limits throughput. Instead of spreading effort across multiple "important" initiatives, you concentrate force on the single point that determines system capacity.

First, measure constraint utilization. If your constraint is operating at less than 100% capacity, the problem isn't the constraint itself — it's everything feeding into it. Fix the upstream dependencies before trying to expand constraint capacity. This prevents the classic mistake of optimizing the wrong part of the system.

Second, ensure the constraint never starves. Everything upstream should be designed to keep your constraint fully utilized. This might mean carrying extra inventory, maintaining buffer capacity, or designing redundant processes. It feels inefficient until you realize that efficiency anywhere except the constraint is an illusion.

Third, don't let anything downstream become a new constraint. When you successfully optimize your bottleneck, the constraint will move somewhere else in the system. You need mechanisms to detect this shift quickly and redirect optimization efforts to the new constraint location.

A system is only as fast as its slowest step. Everything else is just expensive theater.

Common Mistakes to Avoid

The biggest mistake is optimizing multiple constraints simultaneously. This seems logical but it's actually impossible. By definition, only one step can be the constraint at any given time. When you try to improve everything, you improve nothing because you're not concentrating enough force on the actual bottleneck.

Another common error is mistaking local optima for global optima. Making one department 20% more efficient might actually hurt overall throughput if it creates a new constraint downstream. This is why most productivity initiatives fail — they optimize pieces instead of the whole system.

Don't fall into the metrics trap either. You'll be tempted to track everything, but only constraint metrics matter. If you're measuring twenty KPIs, you're not measuring anything useful. The constraint metric is the signal. Everything else is noise that obscures what actually drives performance.

Finally, avoid the assumption that your constraint is permanent. Inherited assumptions tell you "this is just how our business works," but constraints can often be eliminated entirely through first principles redesign. Sometimes the best solution isn't optimizing the constraint — it's designing a completely different system that doesn't have that constraint at all.