In many digital projects—whether you’re building a new website, integrating APIs or deploying a software platform—there’s an all-too-common bottleneck that slows everything down: the account or project manager who insists on acting as the sole conduit between teams. While this often comes from a well-meaning desire to protect timelines or manage expectations, it can ultimately lead to delays, confusion and unnecessary complexity—especially when technical work is involved.
Nowhere is this problem more apparent than when internal development teams have to work with third-party vendors. It’s here that the inefficiency of filtering technical communication through nontechnical intermediaries is most painful. Picture this scenario: Developer A on your internal team discovers a bug in an integration. Instead of emailing Developer B at the vendor directly, they send their question to the account manager, who forwards it to their counterpart at the vendor, who then brings it to Developer B. Developer B asks a follow-up, and the cycle begins again.
It’s like playing a high-stakes game of telephone—and the message gets just as garbled.
The Shielding Fallacy
Many organizations have entrenched policies that discourage or outright prohibit direct communication between technical resources and clients. The rationale is often that developers need to be “shielded” from external distractions or that account managers should “own the relationship” and maintain control of the narrative. But what often gets overlooked is that when you block developers from talking to each other, you’re not protecting them—you’re handicapping them.
Let’s be honest: Very few account managers are equipped to translate technical language accurately. And even if they are, they’re still adding a layer of interpretation that introduces risk. What was originally a clear question about data structures, authentication protocols or version compatibility suddenly becomes abstract or incomplete.
Debugging Is Not a Sales Call
This issue becomes especially problematic when debugging integrated systems. Anyone who’s been in the trenches knows that debugging is not a theoretical exercise. It’s a surgical process that requires precision, context and access to logs, systems, and real-time questions and answers. Trying to resolve a technical issue through intermediaries is like trying to disarm a bomb while someone else relays instructions from a manual they don’t understand.
Often, after hours—or even days—of delay, someone will finally suggest, “Maybe we should just get the developers on a call.” And like magic, the problem gets resolved in 15 minutes. It leaves everyone wondering why that didn’t happen in the first place.
Trust the Experts
Letting developers talk directly isn’t about bypassing account managers or undermining their value. On the contrary, the best account and project managers know when to step back and empower the right people to solve the right problems. Their role isn’t to speak for the developers—it’s to make sure the developers have the access and support they need to do their best work.
When technical people are allowed to collaborate directly, they can quickly:
- Align on terms and expectations
- Share code snippets, logs and examples
- Troubleshoot live with shared tools and environments
- Develop trust and rapport that speeds up future interactions
In short, they can solve problems faster.
Rewriting the Rules
If your organization still enforces rigid communication hierarchies, it might be time to rethink them. Consider these changes:
- Create structured opportunities for developers to meet—kickoff calls, regular check-ins or shared chat channels.
- Define clear boundaries for when technical leads should be brought in, and empower project managers to facilitate those conversations.
- Encourage collaboration across company lines when third-party vendors are involved. Everyone’s goal is the same: deliver a working solution.
What It All Comes Down To
Digital projects are complex, technical and fast-moving. If we want them to succeed, we need to stop treating developers like delicate instruments that must be hidden away. Let them talk. Let them troubleshoot. Let them build relationships. Because when the right people are talking to each other, the work gets done better—and faster.
It’s not a turf war. It’s teamwork. Let the developers talk.