How Your Org Structure Distorts Customer Signal
Why do so many GTM problems show up when customer-facing work moves between teams?
If you spend time inside most go-to-market teams, the work generally looks fine. Marketing is generating demand, product is shipping features, sales is closing deals, and customer teams are running onboarding, driving adoption, and trying to protect retention. You can sit with any one of those teams and they can usually explain what they’re doing, why they’re doing it, and how they measure success.
That part is rarely the issue. When I was at Asana, and in most of the companies I’ve worked with since, the internal story at the team level was usually coherent. People were thoughtful about their tradeoffs. The work was intentional. There was a clear sense of progress.
But customers don’t experience teams. They experience the system those teams create together. And when you look at it from that angle, things start to feel less connected. The message they hear early doesn’t always carry into onboarding. The context they build up during onboarding doesn’t always show up in product decisions. The signals they’re sending in one place don’t seem to exist in another.
No single team owns that gap, which is why it persists. The work inside each function holds up, but the system between them doesn’t.
Where things actually start to drift
The way I’d think about this is that GTM systems don’t usually break inside workflows. They drift at the seams, where work moves from one team to another and has to be reinterpreted.
Onboarding is one of the clearest places to see it. Marketing spends a lot of time getting the story right. Who this is for, what problem it solves, and what success looks like. That’s usually the result of a lot of iteration and pressure to improve conversion.
Then the customer lands in the product or in an onboarding program that’s optimized for something slightly different. Product might be focused on feature exposure. Customer success might be focused on time-to-first-value. Support might be trying to reduce ticket volume. All of those are reasonable goals, but they don’t always line up with the promise that brought the customer in.
So the customer ends up doing the translation work themselves. They’re trying to reconcile what they were told with what they’re now being asked to do. That gap isn’t the result of a bad decision by any one team. It’s the result of how the work is structured across teams.
You see the same pattern with product feedback. Community surfaces a constant stream of signal, not just feature requests, but confusion, workarounds, and the language customers actually use to describe what they’re trying to accomplish. Product teams want that signal and will often set up processes to capture it.
But once that signal moves into product, it has to fit how product makes decisions. It gets summarized, categorized, and prioritized alongside roadmap commitments, sales input, and internal hypotheses. In that process, a lot of the context gets stripped out, and what started as a clear signal turns into something more abstract and easier to deprioritize.
Nothing is broken inside the function. The hand-off changes the meaning.
Every team defines success differently
This is where the issue becomes more structural. Each GTM function is operating against a different definition of success, and those definitions shape how customer behavior gets interpreted.
Marketing is looking at conversion and pipeline. Product is focused on adoption and usage. Sales is looking at deal velocity and size. Customer teams are tracking retention, expansion, and support load. All of those are valid, but they create different lenses on the same underlying reality.
A spike in community questions might signal strong engagement from one perspective and product friction from another. A highly active customer in the community might be seen as an advocate by one team, but not show up as expansion-ready in another team’s systems. So each team takes the signal and reshapes it to fit its own model.
Over time, that creates drift. Not because anyone is doing something wrong. It’s just that there’s no shared mechanism to carry meaning across those interpretations.
Community sees more than it can carry
Community sits in an unusual position in all of this. It often has visibility across the entire customer journey, from early interest through onboarding, product usage, and expansion. It hears the same customer talk about different parts of their experience over time, which gives it a more continuous view than most other functions.
In theory, that makes it a useful connective layer. In practice, it’s usually embedded inside a single team, most often marketing or customer success, and that placement shapes how its work is interpreted.
If it sits in marketing, its insights tend to get pulled toward demand and engagement. If it sits in customer success, they get framed around retention and support. Either way, it struggles to carry signal cleanly across the rest of the system. It can surface insight and advocate for it, but it rarely has the structural authority to ensure that insight changes how other teams operate.
So it becomes a source of signal without a reliable path for that signal to travel.
What this looks like in real workflows
You can see this most clearly in a few recurring workflows, but one that stands out from my time at Asana is expansion.
We had accounts where, from a traditional lens, things looked stable but unremarkable. Usage was steady, no major support issues, nothing that would trigger immediate attention from sales or customer success. If you were looking purely at product analytics or account health scores, these accounts would sit somewhere in the middle of the pack.
At the same time, if you looked at community behavior, a different picture emerged. You’d see people from those same accounts showing up consistently in events, asking increasingly sophisticated questions in the forum, and in some cases, answering other customers’ questions. They were moving from basic usage into deeper workflows.
That’s not a vanity signal. That’s a leading indicator of maturity.
The problem was that this context didn’t consistently show up in the systems that sales or customer teams were using to prioritize expansion. So decisions were being made based on a partial view of the account.
If you map that out, it tends to look something like this:
Product sees stable usage and no obvious risk, so the account is “healthy but not urgent”
Customer success sees limited expansion activity, so it doesn’t rise to the top of the queue
Sales focuses on accounts with clearer, more immediate signals tied to pipeline
Meanwhile, community is seeing depth, curiosity, and increasing sophistication, but that signal isn’t structured in a way that carries into those decisions.
No one is making a bad call. They’re making a rational call based on the data available to them. The issue is that the system isn’t designed to bring those signals together in a way that changes how the account is handled.
So expansion opportunities get missed, or at least delayed, not because the signal isn’t there, but because it doesn’t travel.
You see a similar pattern in messaging. Community hears how customers actually talk about the product, what language resonates, what confuses them, what they struggle to explain internally. That’s valuable input for marketing.
But unless there’s a tight loop, that language tends to stay local. It might influence a few pieces of content or a specific campaign, but it doesn’t consistently shape how the company talks about itself across channels.
Each team continues refining its own version of the story, and over time those versions start to diverge.
Why this stays hidden for so long
One of the more frustrating aspects of this is that the system can operate this way for a long time without forcing a correction. Nothing fully breaks. There’s enough overlap and redundancy to keep things moving. Teams compensate, build their own processes, and fill in gaps manually.
From the inside, it feels like normal complexity. From the outside, it shows up as inconsistency.
Customers don’t see the internal structure. They experience the system as a whole. When signal doesn’t carry across hand-offs, that shows up as repeated context, mismatched expectations, and small moments of friction that accumulate over time. None of those moments are catastrophic on their own, but they compound.
Where things go sideways
If you step back, the issue isn’t that teams aren’t doing good work. It’s that the system they’re part of isn’t designed to preserve intent as work moves across boundaries.
Each team takes in customer signal, interprets it through its own lens, and optimizes accordingly. That’s rational behavior, and it’s also what causes the drift. Community makes this more visible because it sits across those boundaries and hears when customers notice the gaps, but without structural support, it ends up compensating rather than resolving.
Teams respond by trying to improve the work inside each function. Better onboarding, clearer messaging, stronger feedback loops. Those are all worthwhile, but they don’t address the underlying issue.
The breakdown isn’t inside the work. It’s in how the work connects.
So where does it break for you?
If you’ve tried to make this work across teams, you’ve probably felt some version of this already. The more useful question isn’t whether your teams are doing good work. It’s where that work starts to lose meaning as it moves between them.
Where does the original intent get diluted or reshaped? Is it onboarding, where the promise doesn’t quite carry into the experience? Is it product feedback, where signal gets filtered to the point of being unrecognizable? Is it expansion, where you know more about the account than your systems reflect?
Or is it somewhere else entirely? I’m curious where this shows up most clearly for you.
Decoded Takeaways
Most GTM teams don’t struggle because individual functions are underperforming. They struggle because the system connecting those functions isn’t designed to preserve meaning as work moves across it.
Each team is operating with a different definition of success, and that shapes how it interprets customer behavior. Over time, that creates consistent distortion. The same signal gets translated differently depending on where it lands, which makes it harder to act on collectively.
What makes this difficult to address is that the system continues to function. There’s enough overlap to keep things moving, which hides the underlying issue. Teams compensate instead of fixing the structure.
Community sits in the middle of this. It often has the clearest view of the full customer journey, but it doesn’t have the authority to ensure that signal carries across teams in a consistent way. It surfaces insight, but it can’t guarantee that insight changes how the system operates.
If you’re trying to improve outcomes, the instinct is to optimize within a function. That helps, but it doesn’t solve the problem.
The more important question is where intent gets lost between functions. That’s where the system actually needs to change.