Skip to main content

The two-ear Product Manager: Why balanced listening is your superpower

As a software architect I've worked with multiple product managers over the years. Most of them position themselves as the "voice of the customer" or the "bridge between business and technology." Recently, while listening to the Software Captains podcast interview with Peter Janssens(in Dutch) about Product Management, Peter shared a quote that perfectly crystallized what effective product management really should look like in practice:

A product manager has two ears and should use them equally—one ear to listen to the business and customers, one ear to listen to the product and development team.

This simple metaphor aligns with my experience when my collaboration with a product manager resulted in the best possible products. I unfortunately worked with some product managers that only used one ear, resulting in a mediocre product, budget overruns and lack of innovation. 

The two ear product manager really makes all the difference.

So if you are a product manager (or have the aspiration to become one), this post is for you…

Generated with Bing Image Creator

The familiar ear: Customer and business listening

Most product managers are already skilled at using their "business ear." You conduct user interviews, analyze market research, dive into analytics, and translate business requirements into product features. This external listening is crucial—it ensures that we're solving real problems and building something people actually want.

You know how to ask the right questions:

  • What pain points are customers experiencing?
  • Which features drive the most business value?
  • How do market trends affect our product strategy?
  • What do sales teams hear from prospects?

This outward-facing listening keeps the product manager grounded in reality and market needs.

The overlooked ear: Development team insights

But here's where many product managers miss a golden opportunity: the development team is a treasure trove of innovation waiting to be tapped.

Your engineers, designers, and technical team members aren't just code-writing machines. They're creative problem solvers who:

  • See technical possibilities a might miss. That "impossible" feature request from sales? Your backend engineer might know of an elegant solution using a new technology.
  • Understand the true constraints and opportunities. While you're focused on what users want, they understand what's actually possible—and what's possible might be far more interesting than what's obvious.
  • Think systematically about problems. Developers often see patterns and connections across the codebase that can inspire entirely new product directions.
  • Have direct experience with user pain points. They're the ones building the solutions and often spot usability issues or technical debt that directly impacts user experience.

When internal innovation drives breakthrough products

Some of the most successful products emerged when product managers listened carefully to their technical teams:

  • Slack evolved from an internal communication tool that developers built for themselves. The product team listened when engineers said, "This thing we built is actually better than anything else out there."
  • Gmail's innovative features often came from engineers who had ideas about email that went far beyond user requests—like conversation threading and powerful search.
  • GitHub succeeded because its founders deeply understood developer workflows and built something that solved problems developers didn't even know they had.

How to develop your "internal ear"

1. Ask dfferent questions Instead of just "Can we build this?" try:

  • "What would be technically elegant to build?"
  • "What patterns are you seeing in the codebase that suggest new possibilities?"
  • "If you could rebuild this from scratch, what would you do differently?"

2. Create innovation time Google's 20% time wasn't just about employee satisfaction—it was about systematically listening to what engineers found interesting and valuable.

3. Include technical voices in product discovery Don't just present finished requirements to your development team. Include them in customer interviews, market research sessions, and strategic planning. Their questions often reveal insights you'd never think to explore.

4. Pay attention to technical debt complaints When developers complain about "technical debt," they're often identifying opportunities for product improvements. That clunky integration they keep griping about? It might be limiting product capabilities you don't even realize.

5. Foster psychological safety Create an environment where technical team members feel comfortable sharing "wild" ideas. The best innovations often start as seemingly impractical suggestions.

The balance is everything

The key insight isn't to choose between customer-driven and development-driven innovation—it's to balance both. Your external ear keeps you building things people want. Your internal ear helps you build things people didn't know they needed.

Great product managers become skilled translators between these two worlds. They can take a customer pain point and work with the development team to find unexpectedly elegant solutions. They can also take a technical insight and connect it to real business value.

Your two-ear challenge

This week, try an experiment: For every hour you spend listening to customers and stakeholders, spend equal time having deep conversations with your development team about possibilities, patterns, and innovations they're seeing.

Ask your engineers: "What's technically possible that we haven't explored yet?" Ask your designers: "What patterns are you noticing that we should pay attention to?" Ask your QA team: "What are you seeing that suggests we could be thinking about this problem differently?"

You might be surprised by what you hear when you start listening with both ears.


The most innovative products emerge at the intersection of customer needs and technical possibilities. As product managers, your job isn't just to hear what customers want—it's to listen carefully to all the voices that can help us build something truly remarkable.

What conversations is your development team trying to have with you? Are you listening?

More information

Van scrum coach naar Head of Product: wat leert 20 jaar coaching je over productstrategie? — SoftwareCaptains — Lead your tech team through your growth

Popular posts from this blog

Podman– Command execution failed with exit code 125

After updating WSL on one of the developer machines, Podman failed to work. When we took a look through Podman Desktop, we noticed that Podman had stopped running and returned the following error message: Error: Command execution failed with exit code 125 Here are the steps we tried to fix the issue: We started by running podman info to get some extra details on what could be wrong: >podman info OS: windows/amd64 provider: wsl version: 5.3.1 Cannot connect to Podman. Please verify your connection to the Linux system using `podman system connection list`, or try `podman machine init` and `podman machine start` to manage a new Linux VM Error: unable to connect to Podman socket: failed to connect: dial tcp 127.0.0.1:2655: connectex: No connection could be made because the target machine actively refused it. That makes sense as the podman VM was not running. Let’s check the VM: >podman machine list NAME         ...

Cache stampede: when our cache turned against us

While investigating some performance issues, we ran into an ASP.NET Core API that cached a fairly expensive aggregation query for 60 seconds. Under normal load, that was fine: one request rebuilds the cache, everyone else reads from it. Under peak load, dozens of requests would arrive in that same expiry window, all see a cache miss, and all fire the same expensive query in parallel. The database didn't like that. That was the moment when our caching layer stopped helping and started hurting. A burst of requests comes in at the same time, all miss the cache, and all go hammer the database or the downstream API at once. That's a cache stampede . The cache was supposed to protect our backend, and for a few hundred milliseconds it did the opposite. Why this happens IMemoryCache.GetOrCreate (and its async sibling) looks like it protects you, but it doesn't add any locking on its own. Look at the naive version: public async Task<Report> GetReportAsync(string key) ...

A complex system designed from scratch never works

A few years ago, I worked as an architect on a big mainframe rewrite. I still count it as one of my failures. Not because the technology was wrong, but because I couldn't convince the management team to simplify the approach. Years later, the organization is still struggling to get the new system up and running. I left the project at the time, because I couldn't put my name behind an approach that would take very long and cost a lot of money without a working system to show for it along the way. Gall’s Law That memory keeps coming back to me, because it's a textbook case of Gall's Law playing out in real life. Gall's Law , from John Gall's Systemantics , states it plainly: A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works, and it cannot be patched to make it work. You have to start over with a simple system that works. What does that mean in practice,...