Software Is Easy, It’s The People That Are Hard

"This shouldn't take more than a sprint, right?"

Great, famous last words.

A startup CEO once asked me to help launch a simple new feature: add Apple Pay support to their checkout flow. Clear business value, technically feasible, design was mostly in place. Should’ve been easy.

Fast-forward 3 months. Apple Pay still wasn’t live. Why? It wasn’t the API. It wasn’t latency. It wasn’t even QA. It was… the CFO wanted different reporting. The designer wanted to update more than just the payment screen. Legal raised concerns about data retention. The PM wanted to bundle it with another initiative. Everyone had a reason - but no one owned the outcome.

I’ve seen this pattern on teams from pre-seed startups to public companies: the tech is often straightforward, but aligning the people is the real work.

Here’s what’s really going on.

Misalignment, not incompetence, is killing your roadmap

Most teams don't lack talent. They lack alignment.

Everyone’s optimizing for different things - and usually with good intentions. Product wants velocity. Engineering wants technical cleanliness. Sales wants to close the next whale. Support wants fewer complaints. Finance wants predictability. Legal wants to manage risk.

The problem isn’t that any of these priorities are wrong. It’s that they’re rarely reconciled early and clearly.

That’s why I push for single-threaded leadership wherever possible. One person, one problem, one outcome. If five leaders are “co-owners,” nothing is really owned.

Want faster execution? Don’t just look at the sprint board. Look at the politics around it.

You’re not managing code. You’re managing context.

We’ve trained a whole generation of PMs to write beautiful tickets - but not to manage stakeholders. We have teams with standups, retros, and Jira epics - but no one knows what the VP of Sales really needs from Q2.

The best product work isn’t just technical. It’s emotional. It’s reading the room. It’s aligning incentives. It’s absorbing ambiguity and clarifying it into traction.

Every successful launch I’ve been part of had one person in the mix who could translate between exec, designer, engineer, and user. If you don’t have that translator? Expect delays, duplication, and drama.

Want to go fast? Reduce ambiguity, ruthlessly. Map out what each stakeholder really needs - not just what they say they want.

Conflict isn’t bad. But conflict avoidance is a killer.

You’d be amazed how many “tech delays” are really just evidence that two leaders are secretly in a power struggle. Or worse, avoiding one.

I once had a growth PM delay a simple A/B test for weeks because they “didn’t have the right copy.” In reality? The marketing lead hated that we were running the test at all but didn’t want to say so in front of the CTO.

Passive-aggressiveness will slow your roadmap faster than an outage.

If your team can’t have healthy conflict, you’re guaranteed to have unhealthy delays. That’s why I coach product leaders to normalize hard conversations. Surface tension early. Set expectations loudly. Coach your team to be direct - but not disrespectful.

You don’t need harmony. You need honesty.

Want to build that? Start with these:

• What are we really worried about here?
• Who truly owns this decision?
• What are we not saying that could bite us later?

If you don’t ask them, I promise your timeline will.

Culture eats your workflow for breakfast

Most product teams have their tools figured out. The people part? Not so much.

You’ll hear phrases like:

• “Let’s not step on toes”
• “We’ll just try to please everyone”
• “Well, the VP wants it so…”

Teams that can’t speak up early, set clear limits, or push back constructively are destined to ship slowly - or not at all. Speed comes from trust. Trust comes from clarity.

Here’s a truth I’ve shared with multiple PLG companies: you can’t confluence your way out of a soft culture. Jira won’t save you if no one’s willing to say “no.”

So instead of obsessing about tooling, start reinforcing healthy behavior:

• Recognize clear communication, not heroics
• Reward people who simplify - not overcomplicate
• Normalize prioritization over perfection

Tools are multipliers. But they can’t fix what’s broken in your culture.

Want to dig deeper into how cultural clarity impacts scale? This post on leadership and misaligned incentives is a must-read.

Every breakdown is people. Every breakthrough is people.

When you really zoom out over the last few features (or quarters), the truth becomes obvious. The biggest wins came from belief, clarity, and alignment. The biggest misses came from ego, fog, and confusion.

Patterns I’ve seen over and over:

• A founder who can't delegate, so the team second-guesses everything
• A people-pleasing PM who adds too much to scope so “nobody’s mad”
• An IC who doesn’t raise a critical concern for fear of looking negative

These aren’t software issues. They’re human behavior issues.

Work gets stuck at the intersection of expectations and unspoken assumptions. Clean code doesn’t win. Coherence does.

The good news? You can build coherence - but it takes intent. Train your managers in real leadership. Develop role clarity. Invest in active coaching. As I wrote in The Value of Coaching and Leadership Development, neglecting this layer stunts your growth - even with the best tools and smartest hires.

Making it tactical: what to double down on now

Here are a few sharp reminders I give clients and teams who want to actually move faster and better:

1. Owner over group: Assign one clear DRI per decision or initiative. Cross-functional doesn’t mean cross-chaotic.
2. Say the quiet part early: Encourage stakeholders to name objections or tensions in week 1, not week 8.
3. Clarify success upfront: Don’t start building until everyone can state what “done” looks like in plain English.
4. Measure trust: If your team doesn’t feel safe giving real feedback, you’re flying blind. Start with simple 1:1 prompts.
5. Ruthless scope, real time frame: Cut the fluff. Over-communication beats over-commitment.

Let’s make one thing clear: execution isn’t just process. It’s people alignment. Maybe your code delivers in milliseconds - but your org stumbles for months. Don’t blame the stack. Look upstream.

Need a refresher on balancing priorities, bias for action, and real product traction? Read this framework for growth.

Quick cheat sheet: People vs Software

Stop blaming the engineering estimate

Next time something ships late, don’t just schedule another post-mortem or tweak the velocity metric. Ask who was really aligned. Ask what fears or incentives were at play. Ask what wasn’t surfaced.

Software’s the easy part. Getting people to row in the same direction, with clarity and urgency? That’s the real challenge - and the real unlock.

Want higher velocity? Don’t hire faster coders. Build stronger relationships. Say the hard stuff earlier. Point the ship better.

When you get that part right, everything else starts to click.

Let that sink in. The biggest multiplier on business speed isn’t your sprint tool. It’s your team’s ability to be clear, candid, and committed. Make it your product.