Build a SaaS sales motion

The Real Problem Behind Sales Issues

You're building a SaaS company. Revenue is growing, but sales feels like pushing water uphill. Your team adds more features to the demo, creates new collateral, hires more reps. Nothing changes the fundamental dynamic.

Here's what's actually happening: you're optimizing the wrong constraint. Most founders think sales problems are sales problems. They're not. They're systems problems disguised as people problems.

The real issue isn't that your reps need better training or your product needs more features. It's that you haven't identified the single bottleneck determining your sales throughput. Until you find that constraint and design your entire motion around it, you're just adding complexity to a broken system.

This is constraint theory applied to revenue generation. In manufacturing, Goldratt showed that every system has exactly one constraint that determines total output. The same principle applies to your sales motion. There's one step in your process that's limiting everything else.

Why Most Approaches Fail

The typical approach to sales problems is the Complexity Trap. Add more touchpoints. Create more nurture sequences. Build more sophisticated attribution models. Hire specialists for every micro-function.

Each addition feels logical in isolation. But complexity compounds. Now your reps are managing twelve different tools, following seventeen-step processes, and spending more time in Salesforce than talking to prospects.

"The moment you add a step to solve a symptoms problem, you've made the real problem harder to see."

The second failure mode is the Attention Trap. Teams obsess over vanity metrics that feel important but don't drive revenue. Pipeline value. Activity metrics. Lead scores. These are lagging indicators that make you feel busy while the real constraint operates unchecked.

The third trap is assuming the constraint is always lead generation. "We need more top-of-funnel." Maybe. But if your constraint is actually demo-to-close conversion, throwing more leads at a broken process just creates more noise.

The First Principles Approach

Start with the math. Your revenue is determined by a simple equation: prospects × conversion rate × average deal size × sales cycle length. One of these variables is constraining the others.

Map your actual process, not your theoretical one. Track prospects through each step. Where do you lose the most qualified opportunities? Where does velocity slow down? The constraint is hiding in those numbers.

Most B2B SaaS companies have one of three constraint patterns. First: demo booking. You have plenty of website traffic but prospects won't take meetings. Second: demo-to-trial conversion. Prospects will demo but won't commit to testing your product. Third: trial-to-close. Users adopt your product but won't sign contracts.

Each constraint requires a completely different system design. If demo booking is your constraint, obsessing over trial-to-close optimization is waste. You're polishing a step that most prospects never reach.

Here's the key insight: once you identify the true constraint, you design everything else to feed it. Marketing exists to maximize qualified prospects at the constraint step. Product development focuses on reducing friction at that exact point. Sales processes optimize for constraint throughput, not total activity.

The System That Actually Works

Build your sales motion like a manufacturing line. The constraint determines capacity. Everything upstream should produce exactly what the constraint can handle. Everything downstream should process whatever the constraint produces.

If demo-to-trial is your constraint, marketing shouldn't flood you with unqualified demos. Better to send fewer, higher-intent prospects who convert at higher rates. Your demo process should focus entirely on trial commitment, not feature education.

Design for signal amplification. The constraint step should give you the clearest signal about product-market fit. If prospects won't book demos, your positioning is off. If they demo but won't trial, you're solving the wrong problem. If they trial but won't buy, your pricing or implementation is broken.

Create feedback loops that make the system self-improving. Track constraint performance daily. When conversion drops, investigate immediately. When it improves, document what changed. This creates a compounding system where each iteration makes the constraint more effective.

Build specialist roles around the constraint, generalists everywhere else. If demo booking is your constraint, hire a specialist who only optimizes that conversion. Everyone else should be able to handle multiple functions. This prevents the Scaling Trap where you add overhead without adding constraint capacity.

Common Mistakes to Avoid

The biggest mistake is constraint shifting without recognition. You optimize demo booking, conversion improves, and suddenly trial-to-close becomes the constraint. Teams keep optimizing the old constraint while the new one throttles growth.

Monitor your system for constraint shifts. As you improve one bottleneck, capacity moves to the next weakest link. This isn't failure—it's progress. But you need to recognize it quickly and redesign accordingly.

Second mistake: assuming the constraint is always external. Sometimes the constraint is internal capacity. Your best rep is personally handling all demos. Your founder is closing every enterprise deal. These human constraints are harder to see but just as limiting.

Third mistake: trying to eliminate constraints entirely instead of managing them. Every system has a constraint. The goal isn't to remove all bottlenecks—it's to make sure your constraint is the right one and optimized properly.

The final mistake is optimizing for efficiency instead of effectiveness. A perfectly efficient system that optimizes the wrong constraint will fail. Better to have a simple, focused system that maximizes throughput at the true bottleneck.

Your sales motion isn't a collection of tactics. It's a system designed to move prospects through your constraint as efficiently as possible. Find that constraint. Build everything else to serve it. The results will follow.