When I was at Asana, I got into the habit of spending time in the forum before big cross-functional meetings. It wasn’t part of any formal process. I just wanted a quick read on what customers were actually dealing with at that moment and how that was evolving over time.

If you spend even a little time in a space like that, patterns start to show up quickly. You begin to recognize the same accounts, how their questions change, and where they’re running into friction. A lot of what you see tends to fall into a few categories:

• Where people are getting blocked

• How they’re working around limitations

• What they’re trying to do that isn’t fully supported

• How their usage is changing over time

Then I’d go into a planning conversation, and that context wasn’t already in the room.

It wasn’t that people didn’t care about it. It just wasn’t part of the system they were using to make decisions, so the same customers and the same product showed up as a different set of priorities depending on where you were looking.

Where this gets expensive

One place this becomes very clear is in expansion.

You’re reviewing accounts and deciding where to spend time, and from the perspective of the systems most teams rely on, things look fine. Usage is steady, nothing is at risk, and nothing is moving in a way that demands attention. So the account ends up somewhere in the middle. It’s not something you ignore, but it’s not something you prioritize either.

At the same time, if you look at what’s happening in the community, you can see a different trajectory. The signals don’t look urgent in isolation, but taken together they tell a different story:

• Questions are shifting from basic to more advanced

• The same people are showing up repeatedly in events

• Customers are starting to answer other customers’ questions

Those are usually signs that an account is going deeper into the product and starting to figure out how to apply it in more complex ways.

From one angle, the account looks flat. From another, it looks like it’s moving. Both views are grounded in real data, but they don’t connect in a way that changes what happens next. As a result, the account stays where it is.

From the outside, that can look like a missed opportunity. From the inside, it’s a reasonable decision based on the information that’s available, which is part of what makes this hard to catch early.

How that pattern repeats

You see a similar dynamic in product conversations.

Community surfaces a steady stream of signal, and it’s not just feature requests. It’s confusion, workarounds, and patterns in how people are actually using the product. That signal usually makes its way into product discussions, but it has to be translated into something that fits how roadmap decisions are made.

That typically means it gets summarized, categorized, and compared against other inputs that are already structured in a similar way. This step is necessary, because product teams need a way to evaluate tradeoffs across many competing priorities.

At the same time, something changes in that translation.

What felt immediate and clear when you saw it in its original context becomes easier to deprioritize once it’s been reshaped. The context that made it feel urgent doesn’t fully carry through, and over time that creates a gap between what’s being surfaced and what actually influences decisions.

From one side, it can feel like the same issues keep coming up without anything changing. From the other, the signal doesn’t quite map cleanly to how decisions are made, so it gets acknowledged without materially shifting the roadmap.

Messaging drifts in a similar way

Marketing runs into a version of this that’s a bit less obvious, but follows the same pattern.

Community is one of the few places where you hear how customers actually talk about the product when they’re not trying to fit into your positioning. You get a clear sense of the language they naturally use, where they hesitate, and how they describe what they’re trying to do.

That’s useful input if you’re trying to refine how you show up in the market, but unless there’s a tight loop that brings that language into how messaging is developed and updated, it tends to stay local.

Over time, that shows up in ways that are easy to rationalize:

• Messaging feels slightly off, but not enough to trigger a full rethink

• Different teams describe the product in slightly different ways

• Customer language shows up inconsistently across channels

Nothing in that process looks broken when you’re inside it. It just takes longer to get to something that feels coherent.

Why this is hard to catch

One of the reasons this persists is that the system keeps working well enough that it doesn’t force a correction.

Expansion still happens, product still ships, and marketing still drives pipeline. From the inside, it feels like normal complexity, where each team is doing good work and decisions make sense within the context they’re operating in.

The cost shows up more in timing than anything else. You see it in opportunities that take longer to surface, decisions that take longer to line up, and messaging that takes longer to correct when it starts to drift. None of those issues trigger an immediate response, but they accumulate over time.

What’s actually going on underneath it

Each GTM function is doing what it’s designed to do. It takes in information and translates it into its own system.

Marketing is looking at pipeline and conversion, product is looking at usage and roadmap, sales is focused on deals and expansion, and customer teams are looking at retention and support. Each of those perspectives is grounded in something real.

The challenge is that the same underlying signal gets reshaped as it moves through those systems. Each step makes it easier to interpret within that context and harder to connect across contexts, which is where the drift starts to show up.

This is something I kept coming back to while writing The Community Code, because community is one of the few places where you can see the full arc of how customers actually think and behave over time. The visibility is there. What happens after the signal leaves that environment is where things start to break down.

Where I’d look first

If you’re trying to make sense of this in your own organization, I wouldn’t start by asking whether you have enough customer insight, because most teams do.

I’d start by looking at where that insight changes form, where it gets summarized, reframed, or filtered to fit a different system, and where it stops influencing decisions even though it’s still being surfaced. Those are usually the places where the underlying issue becomes visible.

Decoded Takeaways

The same customer behavior can show up across multiple systems and lead to different decisions depending on how it’s interpreted.

Each team is working with real signal, but they’re working with it in a way that fits how their system operates, which makes it harder to act on collectively.

Over time, that shows up less as obvious failure and more as delay, where opportunities, decisions, and messaging all take longer to line up than they should.

If you’re trying to improve outcomes, it’s worth paying attention to where the same signal leads to different conclusions, because that’s usually where the system is introducing friction.

Related Posts

• Community Has Impact. It Doesn’t Carry Across GTM

• Where Community Breaks Down Inside GTM

• What K-Pop Can Teach Go-to-Market 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.

Related Posts

• Community Has Impact. It Doesn’t Carry Across GTM

• Where Community Breaks Down Inside GTM

• Community x GTM Playbook: What Every Chief Product Officer & Head of Product Needs to Know

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

Today, my new book, The Community Code, is officially out.

It’s available now on Amazon.

This book comes out of a pattern I kept running into across companies, roles, and stages. Community was clearly doing something valuable. Customers were helping each other learn the product, sharing use cases, influencing adoption, and in some cases shaping pipeline and expansion.

But that impact rarely translated across the rest of the organization.

Individually, the signals were easy to point to. Collectively, they were harder to make sense of. That’s where things tend to break down.

Why this book exists

Inside the company, each team interprets what it sees through its own lens. Marketing frames it as advocacy. Product treats it as feedback. Customer success sees adoption patterns. Sales looks for proof points to support deals in motion.

All of those interpretations are valid. The problem is that they don’t connect in a way the business can actually operate on.

What looks like a cohesive system from the outside gets broken into pieces on the inside. As a result, community ends up feeling simultaneously important and hard to justify. There’s visible impact, but no shared understanding of how that impact moves through the business.

This book makes that system visible and usable.

Where community-led growth falls short

“Community-led growth” helped move the conversation forward. It gave the work more weight and tied it to outcomes leadership already cared about.

That shift mattered. But in practice, it also introduced a mismatch.

Most organizations aren’t designed for any single function to lead growth on its own. Product, marketing, sales, and customer success each control different parts of the lifecycle, and growth shows up when those parts reinforce each other over time.

Community doesn’t sit neatly inside that structure. It cuts across it. So expectations expand, but decision rights and operating models don’t change alongside them.

As companies scale, the result becomes obvious. Multiple versions of “community” start to appear across the org. Marketing builds advocacy programs. Customer success builds onboarding and support spaces. Product runs betas or feedback groups. Developer relations builds ecosystems.

Each effort makes sense in isolation. Each is tied to a clear goal. But they’re owned by different teams, measured differently, and rarely connected in a way that reflects how customers actually experience the product.

From the company’s perspective, the structure is rational. From the customer’s perspective, it’s fragmented.

The problem isn’t belief, it’s translation

At this point, most GTM leaders don’t need to be convinced that community has value. The harder problem is making that value usable.

Signal is generated in one place and consumed in another. Context gets lost along the way. Teams fall back on their own proxies because the underlying system isn’t visible enough to work from directly.

That’s why the same patterns keep repeating. Product teams see spikes in requests without full context. Marketing highlights stories that resonate externally but don’t fully reflect usage. Sales leans on isolated proof points. Customer success sees early signs of friction but struggles to connect them back to upstream decisions.

These aren’t failures of execution. They’re artifacts of how the system is structured.

Without a shared way of carrying signal across functions, each team optimizes locally. The result is a set of decisions that make sense individually but don’t consistently reinforce each other.

From fragmented signal to community-integrated GTM

A more durable approach starts by changing how community shows up in the system.

Not as a standalone program, and not as a function that owns outcomes, but as a way of feeding shared customer signal into how product, marketing, sales, and customer success actually operate.

When that signal is visible and consistently used, things change in a way that’s hard to fake. Product decisions reflect how customers are using the product in context, not just isolated requests. Marketing messaging aligns more closely with how customers describe value in their own words. Sales conversations carry examples that generalize. Customer success leans more on peer momentum instead of purely reactive support.

What changes isn’t any single output. It’s how those outputs start to reinforce each other.

That reinforcement is where leverage shows up. It’s also where most community efforts stall, not because the work isn’t valuable, but because the system around it isn’t designed to absorb and use that value consistently.

How this looks in practice

You can see this in companies that have invested in connecting customer signal across functions.

At Asana, the community forum, ambassador program, and events surfaced patterns around how teams were adopting the product, where they were getting stuck, and how use cases were evolving over time. That signal showed up in product conversations, influenced how customer stories were told, and informed how teams approached onboarding and expansion.

At Atlassian, community conversations often surface emerging needs and workarounds long before they appear in formal feedback channels. That signal feeds into product teams, partner ecosystems, and support content, creating a more connected view of how customers are actually using the platform.

In both cases, the value of community isn’t just in the interactions themselves. It’s in how those interactions inform decisions across the rest of the organization.

That doesn’t happen automatically. It requires intentional design around how signal is captured, translated, and shared.

What the book does

The Community Code breaks this down directly.

It maps how customer signal actually moves across go-to-market, where it gets lost, and how to integrate it into the way teams operate day to day.

This isn’t about elevating community as an idea. It’s about changing how work happens across product, marketing, sales, and customer success so they operate from the same underlying inputs.

If you want to go deeper, you can learn more about The Community Code here.

Decoded Takeaways

• Community generates some of the earliest and most nuanced customer signal, but that signal often fragments as it moves across teams

• “Community-led growth” elevates the importance of the work, but doesn’t resolve how it fits into vertically structured organizations

• The core issue isn’t belief in community’s value, it’s the lack of a shared system to translate that value into decisions

• A community-integrated approach creates a common layer of signal that product, marketing, sales, and customer success can operate from

• Durable advantage shows up when those functions start reinforcing each other based on the same underlying inputs

Related Posts

• Why I No Longer Say “Community-Led Growth”
  Where the language starts to fall apart in practice, and how it creates expectations most organizations can’t actually support.

• Where Community Breaks Down Inside GTM
  How community gets fragmented across marketing, product, sales, and customer success, and what that fragmentation costs the business.

• What K-Pop Can Teach Go-to-Market Teams
  A different lens on the same idea, showing how coordinated community behavior can shape distribution, adoption, and narrative without owning growth directly.

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

For years, I described my work as community-led growth. I don’t anymore.

After spending time recently in rooms full of community practitioners, I’ve been thinking more carefully about how we describe this work. The language we use shapes how organizations structure authority, expectations, and accountability.

For a long time, calling it community-led growth felt accurate and necessary.

Community teams had spent years being treated as engagement programs orbiting the “real” work of go-to-market. So when the phrase gained traction, it felt like overdue recognition. It signaled business impact. It signaled ownership. It suggested that community wasn’t just supporting growth but driving it.

And in some cases, it did drive meaningful outcomes.

But over time, the language started to feel slightly misaligned with what I was actually seeing inside organizations.

Durable growth is rarely led by one function in isolation. Product doesn’t grow the company alone. Sales doesn’t. Marketing doesn’t. Customer success doesn’t. Each function controls a vertical slice of the lifecycle, and growth shows up when those slices reinforce one another.

So saying that community “leads” growth began to feel structurally imprecise.

Vertical companies, horizontal leverage

Most companies are vertically organized.

• Product owns roadmap and prioritization.

• Marketing owns demand and narrative.

• Sales owns revenue.

• CX or Customer success owns renewals and expansion.

Each function has clear authority and defined metrics. Accountability follows the vertical.

But community rarely maps cleanly to that structure. It gets placed somewhere on the org chart, but its impact doesn’t follow a single vertical line. That’s why it often feels awkward organizationally. It inherits goals that don’t fully reflect what it influences.

Uniquely, community operates horizontally.

It spans awareness, adoption, expansion, and advocacy. It sees early curiosity before it shows up in marketing dashboards. It notices which customers are quietly becoming power users long before expansion conversations begin. It hears friction before churn metrics move. And it captures the language customers use with each other when no one from the company is steering the message.

Years ago, when I explained community in stakeholder meetings, I’d draw the core GTM teams as vertical pillars and sketch community as a horizontal layer connecting them, supporting and informing each one.

That picture still holds up.

Community connects and integrates across pillars. It doesn’t lead or replace them.

Where “community-led” overcorrected

The issue with “community-led” isn’t intent. It’s structure.

The word “led” implies authority over outcomes and decisions. Inside most organizations, community doesn’t have that authority.

What it has is insight and influence without formal control. It can surface signal, generate advocacy, highlight friction, and create momentum. But the levers that convert those inputs into measurable outcomes still sit inside other teams.

When companies adopt the language of community-led growth, expectations rise quickly. Community is asked to drive pipeline, strengthen retention, increase advocacy, surface product insight, and deepen engagement. At the same time, product still owns prioritization, marketing still owns messaging, sales still owns revenue targets, and customer success still owns expansion and retention.

So what happens to community? Responsibility expands. Authority does not.

I’ve experienced that directly. I’ve also seen a related pattern inside larger organizations.

As companies grow, they sometimes create multiple community teams across verticals. Marketing builds a brand community. Customer success builds a customer community. Product builds a beta group. Developer relations builds its own ecosystem.

Each one reports into a different vertical leader. Each one is measured against different goals.

From the inside, it feels logical, because each community program maps to what their part of the org chart is trying to achieve.

From the customer’s perspective, it’s fragmentation.

The same customer ends up navigating multiple community experiences owned by different teams, each optimized for its own metric. That’s vertical thinking applied to something customers experience horizontally.

Calling any one of those efforts “community-led” doesn’t resolve that tension.

What community was actually doing

There are moments when community genuinely feels like the tip of the spear.

At Asana, community programs helped us expand into new markets. Champions drove internal adoption inside teams. Certified partners extended our reach into customers we couldn’t directly serve. Community surfaced friction in adoption long before it showed up in executive dashboards.

But community wasn’t operating in isolation.

It strengthened product decisions. It strengthened marketing credibility. It strengthened sales conversations. It strengthened expansion.

It amplified what the system was already trying to achieve.

Introducing community-integrated GTM

What I’m calling community-integrated GTM is a model that reflects how organizations function when they’re working well.

Community’s real leverage unfolds in three layers. They build on each other.

First: Alignment.
Community surfaces live customer signal across the lifecycle. When that signal is visible across product, marketing, sales, and customer success, teams stop optimizing against slightly different versions of reality. Alignment isn’t about agreement in meetings. It’s about shared inputs.

If marketing is telling one story, product is building for another, and sales incentives pull in a third direction, community engagement won’t compensate for that drift. Shared signal is the starting point.

Second: Integration.
Signal has to be embedded into decision loops. It needs to show up in roadmap discussions, positioning reviews, enablement materials, onboarding design, and expansion strategy. When community insight lives in a quarterly recap deck, it remains peripheral. When it’s part of how decisions get made, it shapes outcomes.

This is where many organizations stall. They gather insight but don’t restructure how they act on it.

Third: Amplification.
When alignment and integration are real, community strengthens what already works. Marketing claims are reinforced by visible customer momentum. Product bets are informed by active user behavior. Sales conversations include credible proof. Customer success can plug customers into peer networks instead of solving everything one-to-one.

Amplification is what people notice. Integration is what makes it durable.

What this changes inside a GTM organization

This reframing doesn’t mean community stops working toward shared goals.

Community should absolutely tie its impact to what matters most to the business at any given time. Pipeline. Activation. Retention. Expansion. Whatever the organization is optimizing for. That’s how credibility gets built. That’s how the dots get connected.

But community’s true impact doesn’t come from owning those outcomes in isolation. It comes from shaping how the vertical teams pursue them.

When community is integrated, product decisions are informed by live user behavior. Marketing messaging reflects how customers actually describe value. Sales conversations include credible proof from engaged users. Customer success can shift from reactive support toward peer-driven momentum.

Community works toward shared goals. It just does it through a horizontal lens that no other function has.

When organizations expect community to behave like another vertical team, they measure it narrowly and eventually split it apart. You see this in larger companies where multiple community teams emerge across different departments, each reporting into a different leader and each optimized for different metrics. Marketing builds one experience. Customer success builds another. Product builds its own. Developer relations builds a separate ecosystem.

From inside the org, it feels aligned to structure. From the customer’s perspective, it’s fragmentation.

That’s vertical logic applied to something customers experience horizontally.

Designing for community-integrated GTM means tying community to shared outcomes while protecting the horizontal vantage point that gives it leverage in the first place. Product, marketing, sales, and customer success still own their vertical goals. Community influences how those goals are pursued by strengthening the links between them.

Most GTM failures aren’t dramatic collapses. They’re slow misalignments. Teams operating from slightly different assumptions about the customer. Messaging drifting from roadmap. Sales optimizing for a slightly different definition of value than product intended. Small disconnects that compound quietly.

Community, when integrated intentionally, is positioned to see that drift early and influence correction across functions.

Over time, the shift shows up in how decisions get made across teams. That’s where durable advantage builds and compounds.

This is one of the core ideas behind my upcoming book, The Community Code, which comes out April 1.

Decoded Takeaways

• Community-led growth elevated the role of community, but it didn’t fully account for how vertically structured organizations distribute authority.

• Community’s leverage is horizontal. It influences product, marketing, sales, and customer success while still tying its work to shared business goals.

• Community-integrated GTM builds in sequence: align around shared customer signal, integrate that signal into decision loops, then amplify what works.

• When community strengthens the links between vertical teams and reduces cross-functional drift, it becomes a force multiplier across the entire go-to-market system.

• Durable advantage comes from how coherently the system operates over time.

Related Posts

• Reframing Community Metrics: What GTM Leaders Need to Understand About Value and Impact

• Why Community Should Report to the COO: Driving GTM Alignment and Business Results

• The 3 Biggest Lies About Community and GTM—and the Truth

A few years ago I was sitting in a meeting with a sales team reviewing a large enterprise deal. The pitch itself was solid. The prospect understood the product, the pricing, and the implementation plan. Nothing about the conversation suggested the deal was in trouble.

Then someone pulled up a workflow from our community.

It wasn’t a marketing asset or a case study. It was a post from a customer explaining how their team had solved a messy operational problem using the product. No polish. Just screenshots and a short explanation of what they had figured out.

The sales team shared it with the prospect.

The dynamic in the room shifted almost immediately. Instead of explaining what the product could do, the conversation turned to how another company was already using it in practice. The prospect started asking different questions. The example made the value tangible in a way the slide deck hadn’t.

Moments like that happen constantly inside strong communities. Customers share what they’ve figured out, workflows spread between teams, and ideas move from one organization to another faster than any company could orchestrate on its own.

Once you start paying attention to those interactions, it becomes hard to ignore how much influence they have. They shape how customers learn a product, how quickly they adopt it, and how confidently they recommend it to others.

Over time I started noticing something else.

Companies often recognized that these dynamics were valuable, but they struggled to explain where community actually fit inside the broader go-to-market system. Community touched product, marketing, sales, and customer success, yet it was usually owned by just one of those teams.

That tension kept showing up across companies, which is ultimately what led me to write my new book, The Community Code, available in print and digital April 1.

The pattern that kept showing up

Over the past decade I’ve built and advised community programs inside a number of SaaS companies. Some of them grew into fairly large ecosystems.

At Asana, for example, the community eventually included hundreds of events, a global ambassador network, and a forum with hundreds of thousands of members. Experienced users regularly helped newer customers understand workflows, troubleshoot issues, and adopt more advanced use cases.

Those interactions had real consequences for the business.

Customers ramped faster because they could learn from peers who were already further along. Product teams gained a clearer view of how teams were adapting the product to their own processes. Marketing had a steady stream of authentic examples of how the product was being used in practice. Sales teams could reference real workflows from existing customers instead of relying entirely on positioning.

None of that happened by accident. We built systems that connected what was happening in the community back into the business. Product teams paid attention to recurring themes from community conversations. Customer stories surfaced through community programs often became the most credible examples marketing had. Experienced users sometimes introduced other organizations into the ecosystem.

Over time the community stopped feeling like a side initiative. It behaved more like connective tissue between customers and the rest of the company.

But the team responsible for it still had to live somewhere on the org chart.

After seeing those dynamics play out across multiple companies, I started trying to articulate what was actually happening. The usual explanations for community work didn’t quite capture it.

That effort eventually became a book called The Community Code. In it, I explore how communities influence adoption, learning, and product understanding, and why those dynamics often cut across the traditional boundaries of marketing, sales, customer success, and product.

Where the structural tension appears

Inside most SaaS companies, go-to-market responsibilities are fairly well defined. Marketing drives demand and narrative. Sales manages pipeline and revenue. Customer success focuses on retention and expansion. Product owns the roadmap and feedback loops.

Community interacts with all of those areas, but organizationally it usually sits inside just one of them. Sometimes it reports into marketing, sometimes customer success, occasionally product or support.

Wherever it lands, the work inevitably gets interpreted through that team’s priorities. When community sits inside marketing, the focus often shifts toward advocacy and storytelling. Inside customer success, it becomes an onboarding or support lever. Inside product, it becomes a feedback channel.

None of those interpretations are wrong. They simply reflect the lens of the team responsible for the work.

The challenge is that what actually happens inside a healthy community rarely stays confined to a single function. Customers share knowledge with each other, surface friction, demonstrate workflows, and build credibility around how the product works in practice. Those interactions influence product, marketing, sales, and customer success simultaneously.

But the organizational structure around community rarely reflects that reality. The activity spans the system while the team responsible for it sits inside a single department. Once communities start working at scale, that mismatch becomes hard to ignore.

What’s inside the book

When I started writing The Community Code, I wasn’t trying to produce another tactical guide about launching a forum or running events. There are already plenty of resources that explain how to do those things.

What I kept encountering inside companies were deeper questions about how community actually fits into the broader go-to-market system.

Leaders would recognize that community mattered, but they struggled to explain exactly how it connected to outcomes like adoption, retention, or advocacy. Community teams often found themselves translating their work into different languages depending on who they were talking to. One conversation might be about marketing impact, another about product feedback, another about customer education.

The book unpacks those dynamics.

The first section explores community as a growth system and why strong customer ecosystems often generate outcomes that traditional GTM channels struggle to replicate. The second section introduces the Community GROWTH model, a framework for designing and scaling community programs so they align with real business objectives. The final section moves into the operational side of the work, covering how communities recruit members, how engagement evolves over time, how champions emerge, and how programs scale without losing the qualities that made them valuable in the first place.

While much of the material draws from programs I’ve built or advised over the years, the book also incorporates the perspectives of other experienced community leaders. Their voices and experiences are woven throughout the chapters, offering different viewpoints on the same challenges and reinforcing how these patterns show up across many organizations.

Why I wrote it

Community has matured a lot over the past decade. When I first started working in this space, the conversation was mostly about whether communities were worth investing in at all.

That debate is largely over.

Today the more interesting questions are structural. Companies are trying to understand how community connects to product development, customer education, adoption, advocacy, and revenue.

Community doesn’t operate in isolation. It shapes how customers understand products, how they learn from each other, how they adopt new workflows, and how they share their experiences with other companies. Those dynamics are already happening inside many organizations. What’s often missing is a framework for understanding how they fit together.

That’s what The Community Code explores. Writing it forced me to revisit nearly two decades of community work and put language to patterns I had mostly been operating on instinct.

The more time I spent working with communities, the more I realized that the most interesting things weren’t happening inside marketing campaigns or onboarding programs.

They were happening between customers.

Someone sharing a workflow they had figured out. A team adapting a use case they learned from another company. Experienced practitioners helping newer users navigate the messy early stages of adoption.

Those interactions often shape how products are understood long before a company’s official messaging does.

Most organizations already sense that something valuable is happening in those spaces. What they often struggle with is understanding how those dynamics connect to the rest of the business. Community ends up living inside one department while the effects show up everywhere else.

The Community Code unpacks those patterns. It draws on programs I’ve built, ecosystems I’ve helped shape, and the perspectives of other community leaders who have been wrestling with the same questions inside their own organizations.

Because once you start paying attention to how customers actually learn from each other, it becomes clear that community isn’t just another program inside go-to-market.

It’s part of how the whole system works.

Decoded Takeaways

• Customers often learn products faster from other customers than from formal onboarding programs.

• Community interactions influence multiple parts of go-to-market at the same time.

• Many organizational challenges around community come from structural placement rather than skepticism about its value.

• Companies that design community as part of their go-to-market system unlock far more value from it.

Recommended Posts

• Community x GTM Playbook: What Every CCO & Head of Customer Experience Needs to Know

• Make it Daebak: What K-Pop Fandoms Can Teach GTM and Community Teams

• Reframing Community Metrics: What GTM Leaders Need to Understand About Value and Impact

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

The space exists. Members participate. Programs are running. From the outside, it looks healthy. Internally, though, community hasn’t fully been claimed as part of the operating system.

That’s the environment DeMario Bell stepped into at Culture Amp.

Today, he serves as Senior Community Manager, North America, Marketing Developer Experience at Amazon Web Services. In this conversation, we focused on his time leading Culture Amp’s global community of more than 100,000 HR practitioners. What he inherited wasn’t dysfunction. It was something subtler. Community had momentum, but it wasn’t tightly integrated into go-to-market strategy. It was adjacent to the business rather than embedded within it.

That distinction shaped everything.

When community exists but isn’t positioned

Early on, DeMario ran listening tours both externally and internally. Externally, he surveyed members, studied NPS, and spent time with detractors rather than only promoters. Internally, he met with stakeholders across marketing, sales, and customer success to understand how they saw community and where they thought it could contribute.

The insight wasn’t shocking, but it was clarifying. Many stakeholders didn’t fully understand the function. Some barely knew the team. In a few cases, working relationships needed repair.

Before scaling outward, he rebuilt trust inward.

That work doesn’t show up in dashboards, but it determines whether future initiatives land.

Designing in sequence

There’s pressure in community roles to demonstrate movement quickly. Launch something new. Announce a program. Show growth.

DeMario resisted that instinct and instead designed in sequence.

Moderation came first. How are conversations structured? How is ownership shared without overburdening members? What guardrails protect quality as scale increases?

Rewards and recognition followed. If members are contributing expertise and time, how are those behaviors acknowledged in ways that reinforce the culture of the space?

Only once those foundations were stable did deeper initiatives like voice of the customer and ambassador programming make sense.

The order wasn’t cosmetic. Each layer depended on the previous one. That sequencing made the system more durable.

Then the environment shifted. The team was reduced from four and a half people to two during layoffs. Director-level responsibilities landed on his desk: forecasting, attribution, stakeholder alignment, executive communication.

What could’ve destabilized the function instead sharpened it. Community became less about engagement mechanics and more about infrastructure. Data capture. Process clarity. Translating participation into signal the business could use.

That shift is what often separates early-stage community work from mature community work.

Forums, support, and the narrow mental model

Many leaders’ only exposure to community is the support forum. A place where customers troubleshoot and ask questions. That function matters. It reduces friction. It improves product understanding.

But it’s not the whole system.

A forum answers a question. Designed community shapes identity and belonging around the product. It reinforces learning before friction escalates. It surfaces qualitative signal that can influence roadmap decisions. It contributes to retention and expansion when it’s integrated thoughtfully.

None of that happens by accident. It requires deliberate mapping between member personas and business priorities. It requires deciding where community intersects with marketing, customer success, and product, and where it doesn’t.

That boundary-setting is part of the design.

The invisible labor of education

Community work carries a constant layer of internal translation.

Stakeholders change. Leadership priorities shift. Budget pressure increases. New executives enter with different assumptions.

You don’t get to quietly execute in this role.

DeMario described his posture as consultative. At times political. Not in the cynical sense, but in the sense that influence requires repeated articulation. If the value of community isn’t explained regularly, it becomes invisible. If it becomes invisible, it becomes fragile.

That ongoing education isn’t ancillary to the role. It’s central to it.

Protecting the member

As community becomes more visible internally, demand increases. Marketing wants amplification. Product wants structured feedback. Sales wants references. Customer success wants scalable engagement.

All of those requests are rational.

But member trust is finite. If the space becomes extractive, the underlying asset erodes.

Part of the community leader’s responsibility is protective. Not oppositional to the business, but protective of the conditions that allow the business to benefit in the first place. Guardrails aren’t resistance. They’re durability.

Starting with why

When asked what he tells GTM leaders considering community investment, DeMario doesn’t start with tooling or tactics.

He asks why.

Why now. What problem are we solving. What constraint inside acquisition, engagement, or retention are we addressing.

Community built because competitors have one tends to remain ornamental. Community built to solve a defined problem has a different trajectory.

Clarity at the outset determines durability later.

Decoded Insight

Community becomes durable when it’s intentionally designed to intersect with business priorities while preserving the human experience that makes participation meaningful.

Timestamps

00:01 – Identity, belonging, and how personal experience shapes community design
08:04 – Stepping into Culture Amp and clarifying the mandate
11:48 – Listening tours, NPS, and engaging detractors
19:17 – Community inside marketing and GTM alignment
27:12 – Sequencing moderation, recognition, and ambassador programs
33:08 – Layoffs, expanded scope, and operational maturity
37:13 – Forums versus intentionally designed community
46:45 – Starting with why before investing in community

Recommended Posts

• Why Your Forum Isn’t Your Community—And What to Build Instead

• Community x GTM Playbook: What Every CCO Needs to Know

• Why Nobody Cares About Your Community Engagement Metrics (and What to Do Instead)

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

Community-building superstar Max Pete is currently at Sprout Social. In this conversation, we focused on his time at Square, where he stepped into a community that had been active since 2016.

By the time he arrived, the community already had structure, history, and habits. Engagement had settled into familiar patterns. Member behavior reflected a post-pandemic normalization. Nothing dramatic was happening. But nothing felt particularly sharp either.

That’s where his work began.

When a B2B community finds its equilibrium

As communities mature, they develop gravity. Programs continue because they’ve always been there. Rituals stick around because they once worked well. Engagement levels flatten into something predictable.

Max approached the situation with a quieter kind of rigor.

He revisited onboarding to understand how new members were entering the system. He evaluated gamification to see whether incentives still matched behavior. He looked at which programs were actively supporting members and which were simply consuming time.

Square’s members are business owners. Their time is constrained. Their reasons for participating are practical. That reality shapes the design decisions.

The team refined structure instead of expanding it. They created clearer spaces for asynchronous participation. They made it easier to find event recordings. They carved out room for business conversations that extend beyond product troubleshooting.

When a community reaches this stage, the question shifts toward integration. How does this space reduce friction for customers. How does it reinforce product understanding. How does it contribute to retention and expansion patterns.

Those are operational questions. They pull community into the broader GTM system rather than leaving it adjacent to it.

At the same time, the human layer never disappears. A thoughtful tag. A quick acknowledgment. A small seasonal badge. These signals compound. Even in B2B environments, people respond to being seen.

The reporting habit that changes your posture

One of the more honest parts of our discussion centered on a program Max ran earlier in his career. Members valued it. Participation was strong. When budgets tightened, the program was cut.

What stayed with him was not frustration about the decision, but clarity about what was missing. The connection between activity and business impact had never been formally captured.

Since then, his operating model has changed.

When new initiatives launch, baseline metrics are recorded immediately. Badge distribution. Rank progression. Monthly active users. Engagement movement over time. Even when leadership has not requested that level of detail.

Collecting data early shifts posture. It allows community leaders to speak in the language of the business when necessary. It makes engagement legible.

Qualitative stories still matter. Testimonials still matter. But narrative paired with data carries further inside executive conversations.

That pairing is what allows community to move from being appreciated to being relied upon.

What actually moves engagement

We also spent time on the small mechanics of engagement, which is often where community either compounds or stalls.

One tactic Max relies on consistently is thoughtful tagging. He looks at who has contributed to similar conversations in the past, who operates in a relevant industry, who has context to add. Then he tags them directly.

It’s manual. It requires paying attention. It works.

That kind of engagement assumes that participation is not evenly distributed. Some members need a nudge. Some members need a reminder that their perspective is useful. A well-placed tag can restart a thread that would otherwise sit quietly.

Broad calls for participation tend to fade into the background. When everyone is invited in the same way, no one feels particularly needed.

The same pattern shows up with recognition. A short thank-you message. A note acknowledging that someone helped another member. These gestures take seconds, but they reinforce something deeper. Participation is visible. Contributions are noticed.

Community grows through repeated signals of attention. Not spectacle.

Decoded insight

Community becomes durable when its activity can be translated into business-relevant signal without losing its human texture.

If the work feels meaningful to members but invisible to the organization, it stays fragile. If it is measurable but disconnected from real participation, it becomes hollow. The balance between those two is where community starts to influence how a company operates.

Why Max’s perspective carries weight

Max has worked inside startup environments and scaled SaaS organizations. That range shows up in how he thinks about tradeoffs. He understands when to experiment and when to stabilize. He knows that mature communities demand a different kind of attention than early-stage ones.

He’s also one of the most well-loved builders in the community space. Not because he’s loud. Not because he’s self-promotional. People consistently describe him as warm, honest, and generous with his time. He shares what he’s learning. He admits what he’s missed. He champions other builders.

That posture matters.

Community work is relational at its core. The credibility you build with members and peers eventually becomes part of the signal you carry inside your organization. Max embodies that balance between operator discipline and human care. Max is also featured in The Community Code book, and the themes we discussed here show up in his contribution there as well.

If you’re leading community in a B2B SaaS organization that has moved beyond launch energy and into operational reality, this episode is worth your time.

You can connect with Max on LinkedIn. He means it when he says his inbox is open.

If this conversation reflects something you’re navigating inside your own organization, I’m curious how you’re thinking about it. Community gets more interesting as it matures. It also gets more complex. That tension is part of the work.

Timestamps

00:00 – From freelancing burnout to community
05:40 – Stepping into a mature Square community
09:17 – B2B vs. B2C engagement realities
13:24 – Getting internal stakeholder input
21:19 – Capturing baseline metrics early
25:58 – Surprise and delight in practice
36:28 – Calibrating content and engagement
45:04 – When programs get cut and why
48:34 – Engagement tactics that actually work
53:58 – Why he continues to do this work

Last week, a story traveled well beyond the usual AI corners of the internet. It showed up in places like Fortune, Forbes, and even the New York Post. The premise was strange enough to spread on its own: a social network designed not for people, but for AI agents.

Not humans running bot accounts. Agents interacting directly with other agents. Comparing techniques, sharing context, and learning from what was happening in real deployments.

A lot of the coverage focused on how odd that sounded. What stayed with me was how predictable the pattern felt.

As agents spread across more real-world use cases, something interesting happened. Context started traveling laterally through interaction, not through centralized oversight. Learning accumulated through exchange. Patterns surfaced without needing to be specified ahead of time.

In practice, a shared space emerged.

That move followed a familiar path. As systems grow more complex, coordination through documentation and rules starts to strain. Interaction becomes a practical way for context to move. This is the same dynamic that shows up in customer communities, practitioner groups, and internal teams once reality starts changing faster than formal processes can track.

That’s why this story matters outside the AI news cycle. It reflects a set of conditions GTM teams already recognize.

When community becomes the default response

Community often gets framed as something layered on for engagement or loyalty. Sometimes that’s true. More often, community appears because the underlying system is under pressure.

Information spreads across too many places. Learning happens through experience instead of playbooks. Context lives in people rather than tools. Coordination gets more expensive. Feedback loops stretch out.

At that point, interaction starts doing quiet work. It moves knowledge. It shortens loops. It lets participants compare notes in real time.

This holds whether the participants are customers helping each other onboard, sales engineers trading field insights, or AI agents exchanging what they’re encountering across environments. The form varies. The function stays consistent.

Moltbook is interesting in this light because it shows how quickly shared interaction becomes useful once a system crosses a certain complexity threshold.

Where AI actually helps community members

A lot of AI-in-community conversations drift toward moderation, content generation, or automation. Those uses are visible, but they don’t address the main friction members feel day to day.

People aren’t short on information. What slows them down is figuring out what applies to them right now. The conversation that matters. The example that maps to their situation. The person who’s already been there.

Used well, AI can reduce the effort it takes to surface things like:

• Conversations tied to a member’s current problem

• People who’ve recently navigated similar situations

• Content grounded in real usage rather than positioning

• Themes that cut across fragmented discussions

This doesn’t replace human interaction. It shortens the distance to it.

When members reach relevant context faster, the effects ripple outward. Marketing hears how customers describe value and confusion in their own words. Sales gains access to peer context that feels grounded in reality. Customer success sees early signs of friction. Product teams start noticing patterns instead of chasing individual requests.

The interaction stays human. AI just makes it easier to find the right one.

How AI shifts the shape of community work

Community work has always involved a lot of invisible labor. Necessary tasks, but not the kind that benefit much from human judgment.

Organizing content. Routing questions. Summarizing long threads. Identifying overlap. Tracking participation manually.

Over time, that work pulls builders away from facilitation, interpretation, and relationship building.

This is where AI can change the shape of the role in a very concrete way. When the mechanical layer is handled automatically, builders spend more time making sense of what’s happening inside the community and less time managing its surface area.

They help different teams understand what the community is revealing. They translate experience into something usable. They apply context rather than just maintaining structure.

That shift doesn’t make the role lighter; it makes it more senior.

Teams that approach AI mainly as a way to cut costs tend to miss this. The value shows up when builders have more room to think, connect, and influence across the organization.

The GTM signal that’s hard to use

From a leadership perspective, community often feels diffuse. There’s activity, but the insight doesn’t arrive in a form that’s easy to act on. Valuable context lives in threads, events, and side conversations that don’t map cleanly to how GTM teams operate.

What’s missing is translation.

AI can help by interpreting what’s happening across the community and surfacing what matters to each function.

• Marketing benefits from patterns in how customers talk about problems and outcomes.

• Sales benefits from peer stories that reflect real buying contexts.

• Customer success benefits from early signs of risk or advocacy.

• Product benefits from clusters of need that explain why something keeps coming up.

When that interpretation layer exists, community starts feeding directly into prioritization and decision making. It stops feeling like a parallel effort and starts behaving like shared intelligence.

What this moment points to

Moltbook doesn’t need to be a model anyone copies. Its value is as a signal.

It shows how quickly shared spaces emerge when systems grow more complex than their formal structures. Context moves more easily through interaction. Learning compounds without needing to be perfectly categorized. Patterns surface early, before anyone knows exactly what to ask.

Many teams struggle here by swinging too far in one direction. Some expect AI to replace community. Others treat community as a place to experiment with AI features without much intent.

There’s a more durable middle ground. Community supports learning inside complex systems. AI helps make that learning easier to see and act on.

When those roles are clear, they reinforce each other. When they aren’t, teams end up with more activity and less clarity.

The work comes down to holding onto context while making insight easier to use.

Decoded Takeaways

• Community tends to appear once systems grow faster than documentation can keep up

• AI creates leverage in community by improving relevance and visibility

• Automating mechanical tasks gives community builders more room for judgment

• Community becomes more valuable when insights are translated by function

• AI strengthens community when it helps signal travel without flattening context

P.S. A special thank you to for inspiring this post!

Most GTM teams reach for simplification when scale shows up.

As the audience grows, variation starts to feel risky. Messaging tightens. Programming narrows. Community experiences get compressed into something broad enough to include everyone, even if it doesn’t feel particularly useful to anyone.

Early on, this can look like progress. Participation stays high. The surface area feels manageable. Over time, the cracks show up in quieter ways. Conversations drift toward generalities. Experienced customers contribute less. Newer members hesitate to jump in. The community keeps moving, but it stops pulling much weight across adoption, retention, or pipeline.

There’s another way to think about scale, one that treats audience growth as a business problem rather than a moderation challenge. It comes from an industry that operates with product portfolios, monetization pressure, and constant competition for attention.

That industry is K-pop.

Not as culture. As operating model.

K-pop groups operate like product ecosystems

K-pop groups are businesses. Albums, tours, fan platforms, merchandise, and sponsorships function as products. Decisions about how to grow an audience have direct commercial consequences. As scale increases, these organizations expand the experience in more targeted ways rather than compressing it.

That’s where SHINee offers a useful case study, even for leaders who have never paid attention to the genre.

SHINee debuted as a five-member group: Onew, Jonghyun, Key, Minho, and Taemin. As a group, they established a clear identity that anchored everything else. Over time, individual members launched solo projects that leaned into different styles, audiences, and creative directions.

From a GTM lens, the structure looks familiar:

• The group functions as the flagship product.

• Solo projects behave like differentiated offerings.

• Each attracts overlapping but distinct segments.

• Engagement and revenue increase across the ecosystem.

I’ve seen SHINee perform as a full group, and I’ve also attended solo concerts from Onew, Key, and Taemin. The experiences don’t feel interchangeable. They also don’t compete for attention in the way you might expect.

Fans engage where the value feels highest for them. Some stay close to the group releases. Others invest deeply in a specific member’s work. Both paths remain visible and supported within the same ecosystem.

That structural choice is the part most business communities overlook.

Why flattening feels reasonable, and where it starts to strain

In B2B community, flattening often shows up as discipline. One forum. One Slack. One cadence of programming. One voice. As the audience grows, everything gets routed into the same shared space.

The challenge is that customer needs spread out rather than narrowing as scale increases.

New customers look for orientation and reassurance. Experienced users want nuance and edge cases. Practitioners want peers who understand their constraints. Leaders want signal they can trust. When all of that activity lives on the same surface, relevance drops unevenly.

At that point, engagement metrics start telling an incomplete story. Posts continue. Comments happen. Activity remains visible. What becomes harder to see is how that activity connects to adoption, retention, or advocacy.

K-pop avoids this tension by treating segmentation as a way to manage growth, not as something to contain.

A note for execs who see community as “nice to have”

If this still feels abstract, it helps to strip the analogy down to economics.

K-pop companies invest in solo projects because different segments monetize differently, retain differently, and create different kinds of long-term value. Forcing every fan into the same experience would cap revenue, shorten engagement cycles, and weaken loyalty over time.

SaaS businesses already operate with this logic elsewhere. Products get segmented by use case. Pricing tiers reflect value. Onboarding adapts as customers mature. Vertical solutions emerge once horizontal ones stop carrying their weight.

Community often gets excluded from this thinking. It’s treated as a single surface rather than a system. The result looks efficient, but it leaves value on the table.

When community is structured as an ecosystem, it starts behaving like one. Adoption accelerates because customers can find peers solving similar problems. Retention improves because relevance doesn’t decay after onboarding. Expansion and advocacy show up because deeper engagement creates stronger attachment.

This isn’t about belonging for its own sake. It’s about whether community is allowed to do the same strategic work as the rest of your GTM system.

Sub-communities increase relevance without weakening the core

SHINee’s solo projects extend the group rather than pulling it apart.

The group identity stays intact, while fans move into different experiences based on taste, interest, and energy. Some remain loosely connected to the group’s releases. Others invest deeply in a specific member’s work. Both paths coexist without forcing everyone into the same mode of participation.

That pattern maps cleanly to how scalable community-led growth works in SaaS.

Strong communities tend to develop layers over time. There’s a shared identity at the center that anchors trust and belonging. Around it, more focused spaces emerge that reflect how customers actually use the product and how their needs evolve.

Those spaces end up carrying real weight. They absorb complexity that would otherwise overwhelm the core. They give advanced users somewhere to go. They help newer members understand what progress looks like. Conversations stay specific without fragmenting the audience.

In practice, this often shows up as:

• Role-based depth, where admins, builders, or operators compare approaches without rehashing fundamentals.

• Use-case or industry depth, where peers share constraints and tradeoffs that don’t apply universally.

• Lifecycle depth, separating early adoption questions from longer-term optimization and influence.

As these layers mature, the community often becomes easier to navigate rather than harder. People spend less time scanning for relevance and more time contributing where their experience actually fits.

A quick test GTM leaders can run

If you’re trying to understand whether your community is flattening as it grows, you don’t need a new platform or a full redesign. The signals usually show up in behavior.

Look at where your most advanced customers spend their time. When they outgrow your primary community space, do they disappear, or do they create side channels and backchannels to get what they need?

Pay attention to which conversations regularly stall. Are people talking past each other because they’re at very different stages, or trying to solve fundamentally different problems in the same thread?

Notice how clearly intent shows up. When someone engages deeply in your community, can your sales or customer success teams tell why they’re there without asking? Or does everything register as the same generic “engaged user”?

Finally, compare community activity to downstream outcomes. When adoption accelerates or retention dips, does anything change in the community itself? If the answer is no, that often points to an experience that’s become too broad to reflect what customers are actually doing.

None of this appears neatly in a dashboard. It shows up in where people cluster, where they linger, and where they stop participating once the community no longer meets them where they are.

Where GTM impact starts to show up

When community is structured this way, the GTM effects become easier to see.

Marketing gains clearer signal around which narratives resonate with specific audiences, based on where conversations concentrate and what members respond to. Sales sees intent through participation patterns that reveal context, not just volume. Customer success teams notice faster adoption when customers can learn from peers facing similar constraints. Product teams hear feedback from users operating in comparable environments, which makes patterns easier to interpret.

Over time, community stops being a debate about platforms or formats and starts behaving like infrastructure. It supports adoption, retention, pipeline, and advocacy in ways other channels struggle to match.

The risk most teams underestimate

Many leaders worry that sub-communities will fracture the audience or dilute the brand. In practice, the strain shows up elsewhere.

When everything is designed for everyone, experienced users disengage quietly. Newer members hesitate to participate. The core weakens, even though activity continues.

K-pop succeeds because it preserves a strong center while expanding relevance outward. Belonging and specificity coexist. Growth adds depth instead of smoothing it away.

Business communities can do the same, but only when segmentation is treated as a strategic choice rather than a concession to complexity.

Decoded Takeaways

• Communities lose GTM impact when scale prioritizes uniformity over relevance.

• Sub-communities strengthen the core when they’re anchored to a clear shared identity.

• Self-selection into depth produces clearer signals than one-size-fits-all programming.

• Community-led growth compounds when segmentation improves signal for marketing, sales, customer success, and product.

• When a community stays active but struggles to influence adoption, retention, or advocacy, the issue often traces back to flattened experiences rather than lack of scale.

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

The conversation usually shows up right around planning season.

A founder is looking at a new year with a mix of ambition and fatigue. Last year didn’t fall apart, but it didn’t quite come together either. Pipeline felt harder to predict. Support volume crept up. Retention held, but only with more effort than expected. Product shipped, but adoption lagged behind the roadmap.

Somewhere between goal-setting decks and headcount spreadsheets, someone floats the idea of building a community.

Not as a campaign. Not as a side project. As a way to change the shape of the business. More engaged customers. Stronger advocacy. Better feedback loops. Maybe even a little lift across the funnel.

This is usually the moment when community starts carrying expectations it was never meant to bear. It’s rarely framed as a fix, but it often functions like one. A way to address a cluster of problems without naming each of them directly.

That’s where expectations start to drift.

Community has real power, but it isn’t corrective by default. It doesn’t resolve underlying tension. It reflects it, at scale.

Why community becomes the answer to everything

Community tends to enter the picture when the edges between teams start to fray.

Marketing is under pressure to drive customer engagement without leaning harder on paid channels. Sales is being asked to do more with warmer leads and longer cycles. Customer success is trying to move from reactive support to proactive retention. Product wants clearer signals about what actually matters to customers, not just who is loud.

Community appears to offer something to each of those groups at once.

And in isolation, each of those expectations is reasonable.

The trouble starts when no one reconciles them.

Community gets positioned as a shared resource without shared accountability. Marketing expects stories. Sales expects proof. Success expects deflection. Product expects insight. Everyone agrees community is strategic, but no one agrees on what tradeoffs it’s meant to absorb. Over time, this ambiguity stalls community and weakens trust in the function itself.

At that point, community doesn’t fail loudly. It fails quietly.

The conversations don’t quite land. Engagement looks fine on the surface, but nothing downstream changes. Teams struggle to point to concrete impact, so they start narrating intent instead. Community becomes busy without being directional.

This is often when leaders conclude that community-led growth is slow, or hard to measure, or not worth the investment.

What’s usually happening is simpler. The company hasn’t decided what it wants amplified.

What community is actually good at supporting

When community works, it tends to work in very specific ways.

It reinforces behaviors that already exist among customers. It accelerates trust where trust is already forming. It makes patterns visible that are already repeating across accounts.

In B2B environments especially, community-led growth shows up less as a spike and more as a drag reduction. Sales conversations move faster because prospects have context. Onboarding gets smoother because customers can see how others navigate complexity. Retention improves because customers feel oriented, not because they feel entertained.

For marketing, community sharpens language. You hear how customers explain value to each other, not how they respond to positioning tests. For customer success, it creates air cover. Fewer tickets about the same issues. More room to focus on moments that actually affect adoption. For product, it reveals where friction compounds across workflows, not just where features are requested.

None of this requires community to persuade customers to care. It assumes they already do.

That assumption matters more than most teams realize.

What community can’t carry for you

Community struggles when it’s asked to compensate for things the business hasn’t resolved.

If customers are unclear on who the product is for, community doesn’t clarify that. It turns into a place where mismatched use cases collide. If sales sets expectations the product can’t consistently meet, community becomes the record of those gaps. If internal teams disagree on what success after purchase looks like, community reflects that disagreement in real time.

These issues don’t show up as a single moment you can fix. They accumulate.

Questions linger without response because ownership is unclear. Power users disengage because they’re tired of translating for everyone else. New members watch more than they participate, picking up on tone before content.

From the outside, it can look like low engagement or poor community management. From the inside, it’s usually a signal that the system around the community isn’t stable enough to support it.

This is where the distinction between a community and a forum becomes less academic. Forums collect activity. Communities expose relationships. If the underlying relationships between teams and customers are strained, community doesn’t hide that. It gives it a microphone.

A few questions worth sitting with this year

If you’re entering a new year thinking about community, these aren’t questions to answer quickly. They’re questions that tend to surface whether you ask them now or later. The difference is whether you engage with them deliberately, or let your community surface them for you.

• Are customers already helping each other in small, informal ways?
  If not, community won’t create that instinct on demand. It will feel manufactured.

• Do teams agree on what happens after the deal closes?
  If retention, adoption, and expansion mean different things internally, community will surface those seams.

• Is there clarity on who acts on what the community reveals?
  When insights pile up without response, customers notice.

• Are you prepared for more visibility into frustration as well as success?
  Community doesn’t filter sentiment. It aggregates it.

• Is there patience for impact that compounds rather than converts?
  Community supports pipeline and advocacy over time, not on a campaign calendar.

If these questions feel uncomfortable, that’s not a reason to avoid community. It’s a reason to understand what it will amplify.

Reframing the decision for the year ahead

At the start of a new year, it’s tempting to ask whether community should be on the roadmap.

A more useful question is what you’re willing to hear more clearly.

Community can make momentum louder. It can also make friction harder to ignore. It doesn’t change the direction of the business. It shows whether that direction holds up once customers start talking to each other.

That’s why this idea shows up early in The Community Code, a book I’m publishing later this spring. Not as a warning or gatekeeping exercise, but as a grounding one. Community-led growth rewards coherence, and it also exposes its absence.

Decoded Takeaways

• Community amplifies existing GTM systems. If those systems are unclear, the amplification makes that visible fast.

• When community feels noisy or unfocused, it often reflects upstream misalignment.

• Scalable community depends more on internal clarity than external engagement.

• Treating community as a fix usually delays harder strategic decisions.

• The real choice is whether you’re ready for visibility, not whether you want engagement.

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

Tiffany Oda has spent more than a decade working in community roles at companies like Salesforce, Talkbase, and now Asana. That range matters more than it might seem at first glance.

She’s built programs from scratch, stepped into communities that needed to evolve, and worked inside large organizations where community sits right alongside support, operations, and customer experience. She’s also lived the part of the job that rarely shows up in job descriptions: constant education, internal alignment, and translating between what members need and what the business expects.

Today, Tiffany is part of the community team at Asana, where the support community plays an active role in how customers learn, troubleshoot, and help one another. That work was recently nominated for CMX Support Community of the Year, which says a lot about how intentionally the program is designed and run.

When we sat down to talk, we weren’t aiming for theory. We wanted to unpack what actually makes community work, especially when it’s closely tied to support and GTM.

What “community” actually means inside a company

One thing Tiffany came back to early in our conversation is that community rarely means the same thing to everyone internally. To some teams, it’s peer-to-peer support. To others, it’s advocacy, education, or engagement. When those definitions aren’t aligned, community teams end up absorbing the confusion.

A lot of Tiffany’s work across roles involved internal clarification. Not evangelizing, but grounding expectations. What problems is community meant to help solve? What isn’t it responsible for? How does it complement support instead of quietly becoming a replacement for it?

As companies grow, this clarity matters even more. Without it, community programs can turn into catch-alls for unresolved needs or get measured against goals they were never designed to support.

Where support and community actually intersect

A big part of Tiffany’s current work at Asana sits right at the intersection of support and community, which is where this conversation gets especially relevant for GTM leaders.

Support communities, when they’re designed intentionally, do more than deflect tickets. They give customers a place to learn in context, hear from peers who’ve been there before, and build confidence using the product. That kind of learning is hard to replicate through documentation alone.

Tiffany talked about community as an extension of the support experience, not a separate destination. Customers arrive with real questions and real friction. Community adds value by pairing official guidance with lived experience, and by letting patterns surface that support teams can learn from over time.

That’s where community starts to compound its value. It helps teams scale without losing trust, reduces repetitive support load, and creates feedback loops that benefit product, support, and GTM teams all at once.

Building from scratch takes more patience than most teams expect

Across Salesforce, Talkbase, and Asana, Tiffany has helped launch community programs from the ground up. One lesson shows up every time: most organizations underestimate how much planning and alignment needs to happen before anything should go live.

When teams rush to launch, the cleanup work shows up later. Stakeholders have different expectations. Tools get chosen before use cases are clear. Early members arrive without enough context to participate meaningfully.

Tiffany emphasized slowing down early. Getting clear on goals. Involving cross-functional partners, especially support and product. Thinking through how members will actually use the space, not just how it looks in a slide deck.

Community wasn’t built in a day, and trying to shortcut that reality usually creates friction down the line.

Vendor choices shape behavior more than we admit

Tooling came up as a surprisingly important part of our conversation. Tiffany was clear that vendor selection isn’t just a technical decision. It’s a strategic one.

Who gets involved matters. Support, community, and GTM teams all bring different needs to the table, and leaving any of them out tends to create downstream issues. The right tool isn’t the one with the longest feature list. It’s the one that supports the kind of participation and outcomes you’re actually trying to create.

She also pointed out that tools should serve the program, not define it. Communities evolve, assumptions change, and flexibility usually matters more than perfection.

Engagement shifts from transactional to relational

Another theme that kept coming up was how engagement evolves over time.

Early participation is often transactional, especially in support-driven communities. People show up with questions and want answers. That’s expected. Over time, though, the strongest communities create space for something deeper.

Tiffany talked about the shift toward intrinsic motivation. Members start helping because they want to. They recognize each other. They feel ownership. The community becomes a place they return to, not just a resource they use once.

Designing for that shift takes intention. Feedback matters. Recognition matters. And so does paying attention to how people are actually using the space, not how the team originally imagined they would.

Feedback is how community stays relevant

If there was one principle Tiffany returned to throughout the conversation, it was this: community programs have to evolve.

Member needs change. Business priorities shift. Support volumes fluctuate. Communities that stay static eventually lose relevance, even if they start strong.

Feedback isn’t a checkbox. It’s the input that keeps programs aligned. That includes surveys, but it also includes everyday signals from participation, questions, and behavior. The work is never really done, and that’s not a failure. It’s the nature of community.

Decoded Insight

The strongest communities live where support, trust, and shared learning come together.

Closing thoughts

If you’re building or scaling a community that touches support, customer experience, or GTM, Tiffany’s perspective offers a grounded look at what actually makes these programs work over time.

You can connect with Tiffany Oda on LinkedIn to keep the conversation going. And if this post sparked a thought or challenged an assumption, feel free to leave a comment or share it with someone navigating similar terrain.

Timestamps

00:00 – Tiffany’s path into community
03:04 – Defining community inside organizations
06:08 – How community roles vary by company
08:47 – Community’s role in support and GTM
11:59 – Building community from scratch
14:56 – Vendor selection and alignment
18:07 – Launching with support in mind
20:53 – Engagement and motivation
23:56 – Evolving established programs
27:08 – Feedback and iteration
29:45 – Final reflections

We talk incessantly about ICPs, personas, and segments. In most GTM teams, these are sacrosanct, even fetishized, as if they hold the secret to unlocking rational decision-making, predictable retention, efficient pipeline. If only! Here’s the problem: while personas have their place, they’re not people. And when your strategy treats personas like people, you’re designing for the average instead of the individual, driving a wedge between your go-to-market strategy and the messy, emotional, human reality of your customers.

At a recent dinner I attended with other GTM leaders, a guest mentioned how Gen Z’s trust operates on what they called a “vibe check.” That line stuck with me. It captured something I’ve been thinking about for a while: GTM teams rely so heavily on personas that they often miss the nuances of real people. I’ve seen this repeatedly in community-led growth initiatives, cross-functional GTM alignment efforts, and product-community integrations. It’s time we stop confusing persona for person.

A persona is a model. A person is real.

When we talk about a persona, what we usually mean is a composite: role, title, industry, pain-point bucket, decision-maker checklist. It’s tidy. It fits nicely into spreadsheets, slide decks, and demand-gen campaigns. But a person doesn’t fit that neat box. A person is also dealing with uncertainties, emotions, competing priorities, and politics, often irrational ones.

Why this matters for GTM and community-driven engagement:

• Personas direct you toward product features, value propositions, and messaging templates. Persons push you toward listening, empathy, and nuance.

• Personas create discrete handoffs where marketing owns “the persona” up front, sales picks it up in outreach, and CS manages “the same persona” in renewal. Persons demand alignment across functions because one human experiences the company as one brand.

• Personas optimize for average behavior. Persons optimize for diversity of behavior, for outliers, and for growth levers through advocacy and community.

In other words, designing around a persona often leads to fragmentation of experience. Designing around a person leads to alignment.

How this plays out in GTM and community

If your company has a “persona” mindset you might see:

• Marketing develops templated campaigns: “VP of Engineering, innovation in regulated enterprise.”

• Product builds “modules for that persona”: “Dashboard for VP metrics.”

• CS segments “that persona” as a renewal cohort: “All renewals where VP of Engineering signed off.”

Each team increments the persona’s “representation” in isolation. They forget that behind that persona is a human with a job, a team, a political mandate, a weekend hobby, maybe a side hustle. They bring their personal context to every interaction, even if we ignore it.

If instead you bring a “person-centric” mindset, your GTM strategy shifts. You start asking:

• What are the emotional stakes this individual has beyond the job title?

• What community or peer group does this person belong to, and how can we tap that?

• How does this person’s journey through marketing, product, community, and CS feel as a continuous thread rather than three separate handoffs?

• How might this individual become an advocate or network connector, not just a unit to convert or retain?

Take a real example: dbt Labs built its product around analytics engineers, but its growth engine wasn’t just a persona narrative. The company leaned into real people; practitioners who wanted connection, peer learning, conference meetups, and contributions to open source. Their community generated a meaningful portion of inbound leads, and product adoption grew via word of mouth through these humans, not just an ICP checklist.

For cross-functional GTM alignment across marketing, product, CS, and community, this matters deeply. When you treat people as personas, each function builds for “their version” of that persona. But the customer only experiences one company. When you treat people as people, you align the touchpoints: marketing creates relevant invitations, community fosters connection, product delivers value, and CS drives outcomes together.

Why personas persist (and when they become a trap)

Personas endure because they offer simplicity in complexity. In B2B, especially, you have to distill myriad variables (industry, org size, role, decision process, etc.) into something digestible. The danger comes when:

• A persona becomes the strategy instead of a tool.

• You stop drilling into actual motivations, behaviors, communities, or peer networks behind the persona.

• You rely on historical data and assume the persona remains stable, when real people and markets are shifting fast.

In that same dinner conversation about Gen Z’s “vibe check,” I pushed the group to think about what that means for modern GTM. If your strategy for Gen Z-influenced buyers still treats them as traditional personas defined by role, title, or budget authority, you’re missing how they actually evaluate trust, community, and peer signal. One letter separates “persona” from “person,” but the gap between them is huge.

How to shift from persona-driven to person-centered GTM

Here’s how to reorient your GTM strategy without throwing out persona work entirely:

1. Map actual journeys, not just idealized ones.
Go talk to real users in that persona bucket. What were they doing just before discovery? What peer forums do they belong to? What frustrations moved them to search? Use these qualitative insights to enrich the persona and make it human.

2. Audit cross-functional touchpoints through the human lens.
Marketing, community, product, and CS each play a part. At every handoff, ask: “What will this person think, feel, and do here? What cues matter?” If each team builds for the persona without coordinating the human flow, you’ll hear complaints like “We were promised one thing and delivered another.”

3. Design your community as a place for real people, not just customers.
If you’re building a scalable community, don’t focus only on “users of product X.” Build for “practitioners who care about topic Y.” That subtle shift expands your reach from the immediate persona to the human motivation behind it. Community then becomes a GTM lever across retention, advocacy, and adoption.

4. Measure behaviors that reflect people, not just personas.
Don’t just track the percentage of persona X who convert. Track how many members of the network contribute, refer, or co-create. These are signals of person-level engagement. For example, dbt tracks contribution, advocacy, and community journey, not just headcounts.

5. Iterate your persona based on what real people show you.
Your “ideal persona” was a hypothesis. Let it evolve by observing people. Ask what different contexts they’re in, what adjacent roles matter, and which peer networks they’re embedded in. Over time the model adapts and becomes richer.

Say it with me: personas are not people

If your GTM strategy refuses to grapple with the complexity of real people, if it stays anchored in tidy persona boxes, you’re limiting your ability to build engaged communities, differentiated product experiences, and aligned customer journeys. But if you make the shift—designing for people who exist, not just personas you invented—you open the door to deeper engagement, stronger retention, and a community-led growth flywheel instead of a segmented funnel. Personas aren’t useless. But person-centric thinking should be your default.

Decoded Takeaways

• When you treat customers as personas you design for “average.” When you treat them as people you design for connection, diversity, and meaningful engagement.

• GTM alignment improves when all functions build for the same human experience, not isolated persona fragments.

• Community is a powerful lever for shifting from persona to person because it reveals motivations, networks, and peer behavior that personas alone miss.

• Real people show you what the persona model leaves out—peer context, emotional stakes, and unexpected use cases. Use that to iterate and grow.

• Measuring person-centric signals like contribution, advocacy, and referral gives you a fuller view of community-led growth, adoption, and retention than just tracking “persona X sign-up rate.”

  Thanks for reading The Community Code! Subscribe for free to receive new posts and support my work.

You can watch our full conversation in the video above or read on for highlights and takeaways.

Jason’s path into community leadership wasn’t traditional. He earned a master’s degree in biblical exegesis and expected to spend his career in teaching or ministry. Along the way he discovered Logos, a research tool used by pastors, theologians, and scholars. He began sharing tips and support through Facebook groups and newsletters, which eventually led to a role in marketing. Over time Jason transitioned into community leadership, helping Logos evolve from a collection of legacy forums into a modern, connected community.

Turning a legacy forum into a living community

When Jason took on his new role, Logos already had more than twenty years of forum history. It was an incredible resource for user-to-user support but not yet a true community. He led the migration of that system to Higher Logic Vanilla, a move that gave the company a chance to rethink what community could mean for its users.

Instead of focusing only on troubleshooting, Jason wanted to make the experience about connection and learning. His team added an events calendar, built product feedback loops, and introduced AI-suggested answers to help members find relevant information faster. These steps transformed the space from a traditional forum into a place people wanted to visit regularly, not just when they needed help.

He also consolidated multiple user portals, including support, feedback, and the knowledge base, into one hub at community.logos.com. That small but strategic change made it much easier for members to find answers, share feedback, and stay involved.

Balancing passion, structure, and internal alignment

Faith-based communities come with unique dynamics. Theological conversations can turn passionate quickly, and moderation requires both empathy and structure. Jason relies on a long-standing volunteer group called MVPs (Most Volunteer Posts) to help monitor discussions and keep conversations healthy. These volunteers are essential partners who help identify issues early and maintain a respectful environment.

One story he shared stood out. A member posted a heated message that crossed the line. Jason had to step in and issue a temporary ban, which turned into a weekend-long email exchange. The member eventually returned to post a public apology. The community responded with understanding and encouragement. Jason saw this as a defining moment. “That’s the difference between a forum and a community,” he said.

Internally, Jason has been working to help others at Logos understand the strategic role of community. He created clear escalation paths, launched a company-wide Slack space called “Ask Community”, and started regular reporting updates to share key metrics and insights. These consistent touchpoints helped shift perceptions inside the company, moving community from a support function to a cross-functional program that drives connection, feedback, and learning.

Making community everyone’s business

At Logos, the community function sits within the customer success organization. That structure fits naturally but also introduces competing priorities. Marketing wants visibility, product wants feedback, and CS wants faster answers. Jason’s approach is to stay transparent about what the community can realistically deliver while keeping the focus on outcomes that support customers.

His primary metrics tie back to customer success, such as faster response times and increased satisfaction. He also tracks secondary signals like engagement, churn risk, and how often users reference the community during support interactions. By connecting these dots, he helps other departments see how community strengthens the broader customer journey.

He also makes collaboration an ongoing process. Jason works closely with product, support, and marketing leaders to ensure community insights feed into decision-making. His internal “roadshow” updates keep everyone informed and invested, showing that community is not a side project. It is a critical part of how Logos serves and learns from its users.

Why he does this work

When I asked Jason what keeps him motivated after wearing so many hats—educator, marketer, and community manager—his answer was immediate. It’s the people. He shared a story about two users who met through the Logos community, became friends, and eventually introduced their families to each other. To Jason, that story captures the real value of this work.

“I’ve done social and SEO, but those things can feel transactional,” he told me. “Community is life-giving. It changes people.”

That sense of connection and shared purpose is what drives him. The product may be the starting point, but the relationships people build around it are what make the work meaningful.

Key Takeaways

• Community programs can evolve at any stage, even in long-established organizations.

• Volunteer leaders are powerful partners when they’re supported with clear roles and recognition.

• Internal storytelling builds credibility. Share community wins across the company to make the impact visible.

• Replatforming is an opportunity to redesign how people connect, not just move data.

• Cross-functional alignment requires clarity. Define what community is, and what it is not, so others don’t define it for you.

• Empathy and transparency build trust. Sometimes the best community outcomes come from difficult conversations.

Decoded Insight

A thriving community isn’t built on technology. It’s built on clarity, connection, and consistency.

The tools matter, but they only go as far as the vision that guides them. Jason’s story at Logos is a reminder that communities evolve not just through new platforms or AI features, but through the intention behind them. He focused on connection first, process second, and technology third, and that order made all the difference.

As GTM and community leaders, it’s easy to get caught up in growth metrics or new engagement tools. But sustainable community programs come from doing the slow, patient work of defining purpose, setting expectations, and building trust both with members and internally across teams.

The next time you evaluate your community strategy, ask yourself: are we building systems, or are we building connection? The answer will tell you whether you’re building a forum or a true community.

Want to connect with Jason?

You can find him at community.logos.com. Reach out if you’re interested in how Logos approaches community building.

If this conversation sparked ideas or new perspectives, feel free to leave a comment or share the post with someone who’d enjoy it.

Timestamps

00:00 – Introduction to Faith-Based Community Building
02:41 – Jason’s Journey into Community Management
06:41 – The Community Program at Logos
11:16 – Modernizing a 20-Year-Old Forum
15:57 – Navigating Theological Discussions and Conflict
19:26 – Managing Sensitive Conversations and Moderation
24:37 – Building Internal Buy-In and Collaboration
29:52 – Creating Communication and Escalation Channels
34:05 – Defining Success and Reporting Metrics
39:39 – The Value and Flexibility of Community Management
43:39 – Why Community Work is Life-Giving

Everyone is asking how AI will disrupt GTM. The better question is what happens when AI runs without community. The short answer is, it doesn’t.

AI isn’t replacing connection, it’s exposing the need for it

AI has worked its way into every corner of GTM. Sales teams are experimenting with it for prospecting emails and call notes. Marketing is using it to draft campaigns. Customer success is rolling out bots for front-line support. Product teams are running it across feedback in search of insights.

When you see AI everywhere, it’s easy to wonder if community is next. If a model can answer questions, recommend resources, or provide onboarding, why invest in creating a space for customers to talk to each other?

That assumption is wrong. AI generates information. Community creates trust. And trust is the actual lever in GTM. Without it, all those outputs are just noise.

Efficiency is a mirage without trust

Executives love efficiency. AI promises faster output, fewer repetitive tasks, lower costs. Those are fine, but efficiency isn’t what changes customer behavior. Connection is.

I see the efficiency mirage play out all the time:

• Marketing. You can churn out content at scale, but if no one believes it, it won’t drive a single deal.

• Sales. You can identify perfect-fit leads, but without community proof points, conversion stalls. Trust is what moves deals across the line.

• Customer success. You can answer more tickets with bots, but customers who feel dismissed are more likely to leave. Retention is built on being heard.

• Product. You can cluster feedback with AI, but if you don’t engage in conversations, you miss the nuance that fuels adoption.

AI makes things faster. Community makes them credible. If you confuse the two, you’ll end up with busy dashboards and flat results.

Redefinition: how AI and community work together

The smartest play isn’t to choose between AI or community. It’s to use them together — AI for scale, community for meaning.

Here’s how the relationship works when you design it with intent:

• AI surfaces signals. Community makes sense of them. A model can flag patterns in behavior, but customers explain why they matter and what to do with them.

• AI automates content. Community decides what’s credible. AI drafts tutorials or scripts. Community vets them, improves them, and makes them usable.

• AI generates recommendations. Community gives people confidence to act. An algorithm can suggest next steps. People act when they see peers who already made those steps work.

This is community redefined. Not a forum. Not a support channel. It’s the trust layer that makes AI-driven GTM believable.

Forward-thinking companies are already pairing community with AI-driven GTM efforts

This isn’t hypothetical. Companies are already showing what happens when AI is paired with community.

• Replit. Developers experiment with AI coding agents, then share the work in forums. Peers refine, troubleshoot, and improve it. Individual hacks become collective knowledge that accelerates adoption.

• Runway ML. The generative video platform highlights community-built projects powered by AI features. These examples aren’t just flashy demos. They give other creators the confidence to test new features themselves.

• Character.AI. Users don’t just interact with AI characters. They create their own and build sub-communities around them. The staying power comes from people, not the model.

AI can spark activity. Community is what sustains it. That pattern is already in play.

The client lesson: why credibility beats scale

If you’re running marketing, sales, CS, or product, you’ll keep hearing pitches about how AI will make you faster or leaner. Some of that is true. But the real problem isn’t speed. It’s credibility.

I worked with an advisory client recently who had to choose which lever to pull. They could have leaned on AI to pump out more content, automate outreach, and create the appearance of scale. Instead, they made a different bet. They invested in building a community anchored in peer relationships and trust.

Their reasoning was blunt: their mission depended on credibility, and customers weren’t going to find that in a campaign or a recommendation from a model. They needed to see people like them navigating the same challenges and succeeding.

Together, we built a framework that gave customers space to share stories, compare experiences, and validate each other’s progress. The company still used AI behind the scenes, but the centerpiece was human connection. The goal wasn’t volume. It was confidence.

That decision stood out because it was the harder path. Efficiency would have been easier to sell internally. But the leadership team understood that peer trust was the only thing that could move their audience. And that’s the shift I’m starting to see across GTM. The real question isn’t “how fast can we go?” It’s “how believable are we?”

Decoded Takeaways

Community isn’t being replaced by AI. It’s becoming more important because AI on its own doesn’t create trust.

• AI doesn’t build belief. It generates outputs, but customers only act when they hear proof from peers.

• Community makes AI usable. AI can produce signals, recommendations, and content. Community filters, contextualizes, and makes them actionable.

• AI without community is a vanity metric machine. It produces activity, but activity without trust doesn’t translate into growth.

• The GTM payoff spans every team. Marketing gains credibility, sales closes more deals, customer success drives retention, and product fuels adoption when AI and community are designed to work together.

• We already see the pattern. Replit, Runway ML, and Character.AI prove that AI activity becomes meaningful only when community sustains it.

AI will accelerate what’s possible, but it won’t do the hard work of building trust. That’s still the job of community. And in a GTM environment obsessed with efficiency, trust might be the most valuable asset left.

If you’ve ever presented community results to your leadership team, you probably know the look. You show a slide full of stats about active members, posts created, or webinar RSVPs. People nod politely, maybe even smile. And then someone asks the question you were hoping wouldn’t come: “So how does this help with pipeline?” or “Is this improving retention?”

That’s the problem. Engagement metrics matter to community teams because they tell us if people are showing up and if the engine is running. But to GTM leaders, they don’t mean much. A CMO isn’t reporting forum post counts to the board. A CRO isn’t celebrating likes on your latest recap. A CCO can’t defend budget with member login data. Their jobs are tied to growth, adoption, retention, and expansion. Unless community metrics are translated into those outcomes, executives will tune out.

This disconnect is one of the biggest reasons community programs get sidelined. Leaders may like the idea of community, but if they don’t see how it ties to their goals, it stays in the “nice to have” bucket. If you want community to be part of the growth engine, the way you measure and report has to change.

Why engagement metrics fall short

Engagement metrics aren’t meaningless. They’re your pulse check. They help you see if the community is alive, if content is resonating, and if members are showing up. Without them, you’re flying blind.

But they don’t tell the story that matters outside the community team.

• Active members doesn’t say whether those members renewed or expanded into larger accounts.

• Posts created doesn’t prove that knowledge sharing reduced support costs.

• Event attendance doesn’t show whether attendees adopted more features or influenced pipeline.

These metrics show motion, not direction. They’re good for operational insight, but they don’t answer the questions GTM leaders are measured on. Worse, when presented in isolation, they can make community look like it’s chasing activity for activity’s sake.

Two tiers of measurement

A better way to frame community measurement is in two tiers.

Program health metrics are the traditional engagement stats—logins, posts, replies, attendance, responsiveness, satisfaction scores. They help you track what’s happening inside the walls of the community and spot trends. Think of them as the dashboard lights that tell you if the program is functioning.

Business impact metrics are the translation layer between community activity and GTM outcomes. They’re the numbers executives actually care about:

• Acquisition: new leads, pipeline, or influenced opportunities through community

• Adoption: faster onboarding or deeper feature use among members

• Retention: higher renewal rates for community-engaged customers compared to those who never participate

• Expansion: larger deal sizes, upsells, or cross-sells within active accounts

• Advocacy: customer stories, referrals, reviews, or user-generated content

You need both. Program health metrics prove the engine is running. Business impact metrics prove why it matters. One helps you manage day to day. The other earns you budget and executive sponsorship.

What this looks like in practice

Some companies have gotten this right. They haven’t thrown out engagement metrics—they’ve reframed them as inputs that lead to business outcomes.

• Zapier: Their community-built automation library is full of “Zaps” created by users. Zapier doesn’t just report how many automations get published. They track how peer-created workflows accelerate adoption, showing that customers onboard faster and stick longer when they use examples from the community.

• Figma: The Figma community produces plug-ins, templates, and shared files. Instead of reporting raw contributions, Figma connects those assets to usage data, demonstrating that they drive deeper adoption across entire teams. Community here isn’t just an activity hub—it’s an expansion lever.

• Amplitude: Amplitude links community learning and discussion to product depth. Customers who participate in their education programs and forums use more features and adopt best practices faster, which directly correlates with stronger retention and account growth.

These examples show what “good” looks like. Engagement is tracked, but the story is always about how that engagement leads to adoption, retention, and growth.

Speaking GTM’s language

The real shift comes when community stops reporting metrics in isolation and starts speaking in the language of GTM leaders. Each function has its own scoreboard. To earn credibility, you need to connect to those metrics, not invent a separate set of goals.

• Marketing: Show how campaigns, events, or ambassador programs generated leads or influenced pipeline.

• Sales: Highlight how accounts engaged in community close at higher rates or move faster through the funnel.

• Customer Success: Demonstrate that community-engaged customers renew more often, expand faster, and log fewer support tickets.

• Product: Connect feature adoption to community promotion or show how roadmap decisions were influenced by feedback captured in community.

This requires plumbing. Community platforms rarely integrate cleanly with CRM, CS systems, or product analytics. Building those connections isn’t glamorous, but it’s what turns “we had 500 posts last month” into “community-engaged customers renewed at a 15% higher rate.” One is activity. The other is impact. Only one changes the conversation in the exec room.

Decoded Takeaways

Community metrics have to evolve if you want community to be taken seriously as part of GTM. Engagement metrics are useful for program health, but they’re not the story leadership needs to hear.

• Program health is your pulse check. These metrics help you run the program and adjust in real time, but they’re for you, not your executives.

• Business impact is your proof. This is what convinces leaders that community is a growth lever. Acquisition, adoption, retention, expansion, and advocacy are the currencies they trade in.

• Integration is your bridge. Unless you connect community platforms to CRM, CS, and product analytics, you’ll never make the leap from activity to outcomes. That’s the work that builds credibility.

Engagement tells you if people are showing up. Business impact tells you if it matters. When you frame community in GTM’s language—pipeline, adoption, retention, expansion—you stop being the person with “interesting stats” and become the one showing how community drives growth.

Customers don’t (and shouldn’t) care which department helps them. They just want to solve their problem, get value quickly, and know they’re supported.

Inside companies, though, these responsibilities are usually divided. Community often sits within marketing or success. Customer education might report to success, support, or product. From an internal org chart perspective, that makes sense. From the customer’s perspective, it creates a fragmented experience. Customers end up navigating multiple portals, hearing slightly different messages, or not realizing valuable resources even exist.

The irony is that both teams are working toward the same goal: helping customers succeed. The difference is in how they approach it. Community leans on peer-to-peer connection, conversation, and engagement channels. Education focuses on structured content, training, and expertise. Each has something the other needs. When they work together, customers get a seamless experience and GTM leaders see measurable impact on adoption, retention, and growth.

Why the overlap matters

Community thrives on energy, relationships, and discovery. People come to forums, events, and member programs to connect with others like them. They want to see how their peers solve problems and apply tools in the real world. Education brings the discipline of structured learning, product depth, and the ability to design experiences that guide people step by step.

When these two functions align, you get a multiplier effect. Training resources don’t just live in a learning platform. They get surfaced in forums, referenced in events, and amplified by members. Community conversations don’t just rely on the luck of peer responses. They can connect people directly to accurate, expert-created content. The result is faster learning, deeper engagement, and stronger customer outcomes.

A closer look at Asana

At Asana, the community and customer education teams treated each other as essential partners. When the education team launched Asana Academy, the community team helped distribute it. Academy courses were highlighted in community newsletters, surfaced in the forum, and embedded in live events. Members were encouraged to participate and then share what they learned with their networks.

This partnership produced clear results. Monthly active users of the Academy doubled after launch, and engagement could be tied directly to NPS, adoption, and retention. Nearly a quarter of members reported discovering the Academy through community programs. That feedback loop showed how each team extended the other’s reach.

The collaboration also flowed in the other direction. When recurring themes surfaced in the community (like confusion about advanced workflow features), the education team created new modules or videos to address them. Community became an early-warning system that directed where education should invest next. The loop kept both teams relevant and closely aligned to customer needs.

Other companies proving the model

This approach isn’t unique to Asana. Several other companies have seen success by connecting community and education:

• MongoDB: The company offers free courses through MongoDB University, which has trained millions of developers worldwide. Their community forum often points people to these courses when questions arise. Instead of duplicating answers, community managers rely on the education team’s resources. Learners gain confidence, and the education program reaches audiences it might not otherwise.

• Airtable: Airtable blends structured training with real-world community use cases. The education team builds foundational content, while the community team highlights workflows created by members at events and in online spaces. Customers get both guided learning and inspiration from peers, which accelerates time to value.

• Miro: Miro’s education team builds learning paths for new users, while its online community showcases templates and boards designed by experts and practitioners. Community discussions regularly reference education materials, and education resources point learners back to the community for discussion and collaboration. The handoff between the two functions helps reduce churn among new users.

Each example underscores that when customers experience education and community together, they learn faster, gain confidence, and stick with the product longer.

A playbook for GTM leaders

For GTM leaders, the question isn’t whether these teams should work together, but how to make that collaboration real. Here’s a simple playbook you can start applying right away:

1. Set shared objectives. Start by aligning both teams around one or two common goals. Instead of community aiming for engagement and education aiming for course completions, agree on outcomes like product adoption or improved retention. Shared goals create shared accountability.

2. Build regular feedback loops. Establish a monthly sync where each team shares insights. Community managers can bring top customer questions and member feedback. Education leads can share course data, common drop-off points, and content gaps. Use this meeting to identify joint priorities.

3. Create co-owned programs. Choose one initiative each quarter to run together. This could be a webinar series, a certification tied to community recognition, or a challenge where learners apply new skills and showcase them in the community. Co-owned programs build trust and deliver visible wins.

4. Integrate content and channels. Make cross-promotion the rule, not the exception. Every course should point learners to the community for discussion. Every community event should highlight the latest education resources. Build simple processes so these connections aren’t left to chance.

5. Measure what matters. Define a small set of shared KPIs that link activity to business outcomes. Examples include time-to-first-value, retention within trained cohorts, or expansion within accounts that participate in both community and education. Report on these together, not separately.

6. Use tools to connect data. Modern tools like Gradual that span community and educational initiatives let you easily see how members are moving between them and the impact they’re creating. If you have multiple community and learning platforms, connect the dots between tools so you can better understand the overlap between learning activity and community engagement. Even lightweight integrations through Zapier or APIs can help create a clearer picture. Leaders are more likely to invest when they see the combined impact.

Decoded Takeaways

Here are the lessons to carry forward if you’re thinking about how to connect community and customer education:

• Customers expect a seamless experience. They don’t care which team delivers the answer, only that it feels consistent and accessible.

• Community and education bring complementary strengths: peer connection and distribution on one side, structured expertise and depth on the other.

• Examples from Asana, MongoDB, Airtable, and Miro show that when these teams collaborate, adoption, retention, and customer confidence all improve.

• Leaders can activate this partnership by setting shared goals, creating feedback loops, co-owning programs, integrating channels, aligning metrics, and connecting data.

• The result is more scalable engagement, stronger retention, and a clear path toward community-led growth.

Bringing these teams together isn’t just about efficiency. It’s how you create customer experiences that stick and build programs that reinforce each other.

The cost of staying siloed

When community and education continue to operate in isolation, customers get a fragmented experience, teams duplicate work, and valuable insights never reach the right audience. You end up with great content that no one sees, and rich conversations that never inform training or strategy. That’s a missed opportunity at every level, from the customer who struggles to find answers, to the GTM leader who misses the chance to accelerate adoption and retention.

The good news is that the fix is within reach. These teams don’t need a complete re-org to start collaborating. They just need permission and a push to connect. The payoff is worth it: a seamless customer journey, stronger GTM outcomes, and programs that multiply each other’s impact.

Last weekend, I joined over 125,000 K-pop fans at KCON LA 2025, a three-day celebration of Korean pop culture that took over the Los Angeles Convention Center and Crypto.com Arena. This wasn’t just another music festival. It was an engagement masterclass. Everywhere I turned, fans had the freedom to choose their own adventure. Some went straight to the main stage for the M Countdown concerts. Others spent hours exploring the festival booths. Some quietly collected photo cards while others danced in front of a crowd on the Dance Stage.

The magic wasn’t in one single event. It was in the way KCON layered experiences, letting each attendee craft their own path. As a community builder and GTM strategist, I couldn’t help but think: this is exactly how brand communities should work. Give people agency, create moments of personal connection, and meet them wherever they are on the engagement spectrum.

KCON at a Glance: Why It Matters Beyond K-pop

First held in 2012, KCON has grown into the largest Korean culture convention and music festival in the world. It now attracts tens of thousands of attendees per city and millions more via live streaming. What began as a niche fan gathering has evolved into a global platform for music, culture, and commerce. It’s also a living case study in how to scale engagement without losing the personal, passionate energy that makes a community thrive. For GTM leaders, it’s proof that when you give people the tools, spaces, and freedom to participate, they will turn your brand into something much bigger than you can on your own.

Layered Engagement: Let People Pick Their Own Path

One of the most striking things about KCON LA 2025 was how it catered to every type of fan. If you wanted an intense, high-touch experience, you could book a Meet & Greet, participate in a Hi-Wave send-off, or get your name called out by an idol on the Artist Stage.

If you preferred to observe from the sidelines, you could explore the 358 booths that filled the Festival Grounds, ranging from beauty and fashion to food and lifestyle brands. Some people bounced between the smaller stages, like the X Stage for up-and-coming acts or the Dance Stage. Still others practiced choreography to audition for the Dream Stage, where lucky fans danced with NCT 127, MONSTA X, and HxW.

GTM and community takeaway: Too often, brand communities assume there is one “right” way to engage, usually a default like posting in a forum or attending a webinar. Instead, create multiple layers of participation, from passive content consumption to high-intensity, one-on-one interaction. Let members choose the level that fits their comfort, time, and interest.

Example in practice: A SaaS company could offer quick polls and resource threads for light engagement, monthly product workshops for those ready to invest more time, and small-group strategy calls with product managers for the most engaged members.

Micro-Moments That Feel Massive

KCON understood that even small, well-orchestrated interactions can leave lasting emotional impact.

• The Call Me By My Name program turned something as simple as name recognition into a heart-stopping moment, as idols read fans’ names aloud on stage.

• Meet & Greets often went beyond a handshake, with some featuring games, special photo ops, or group send-offs that made fans feel personally acknowledged.

• On the Dream Stage, the thrill of performing alongside your favorite group elevated fans from spectators to participants.

GTM and community takeaway: Think about the “micro-moments” in your own community. Could you spotlight a member in a newsletter? Give them the mic in a webinar? Invite them to co-create a resource? It doesn’t need to be expensive or elaborate, just meaningful and personal.

Example in practice: A customer success team could surprise members by personally congratulating them in a live webinar when they reach a milestone, or by inviting them to co-host a tutorial on how they use the product.

Multi-Channel Exposure Meets Fan Creativity

The festival didn’t just rely on what organizers created. Fans were active contributors to the experience.

• Attendees brought their own fan-made swag, traded stickers, and swapped photo cards, which created a stream of user-generated content that fueled the event’s energy.

• Booth activations from brands like Tous Les Jours and K-Story & Comics offered immersive settings perfect for photos and social sharing.

• For the first time, KCON streamed live on Prime Video and Twitch, expanding the audience well beyond those who could attend in person.

This year, I joined in for the first time as a UGC creator myself. Before KCON, I designed and printed custom photo cards featuring my favorite idols and brought them to give away to fellow fans. Watching someone’s face light up when I handed them a card was pure joy. It also gave me a deeper appreciation for the creative energy fans pour into these spaces. I wasn’t just attending anymore. I was contributing.

GTM and community takeaway: Communities thrive when you encourage co-creation and showcase it. Whether it’s a member-created template, a case study, or a how-to video, amplify it across multiple channels. And don’t limit participation to those who can attend physically. Digital access can dramatically widen your reach.

The Engagement Flywheel in Action

KCON’s design fuels a loop of participation:

1. Organizers create experiences worth sharing.

2. Fans capture and share those moments online.

3. That content inspires others to join in, either this year or next.

4. The new participants add their own creativity back into the system.

GTM and community takeaway: You can create a similar flywheel in your own brand community. Focus on designing shareable moments, spotlighting member contributions, and making participation visible. The more people see themselves reflected in the community, the more they’ll want to engage.

A Festival-Fair Ethos That Works for Business Communities

KCON’s theme this year, Klover’s Club Fair, embraced a school-club-style spirit. Instead of forcing attendees down a single track, the event was more like a fairground where you could wander from one experience to another.

This format has powerful implications for brand communities. Imagine an online “festival” where members could drop into different tracks, one focused on product deep-dives, another on career development, another on creative projects, without needing to commit to a single long session.

GTM and community takeaway: When you think about programming, imagine it like a fair, not a lecture hall. Offer diverse entry points and let members self-select their path. Variety drives discovery, and discovery fuels deeper engagement.

What Didn’t Work (and What Brands Can Learn)

For all the magic of the event, KCON LA 2025 had its friction points, and those moments spread just as fast online as the positive ones.

• Ticketing frustration: In the lead-up to the event, social media was full of complaints about high prices, confusing package tiers, and difficulty securing seats. Some fans reported glitches during the sale that left them empty-handed, while resale prices skyrocketed.

• Overcrowding in certain areas: Popular booths and stages sometimes drew more attendees than they could handle, leading to long waits and blocked walkways.

• Clarity gaps in scheduling: With multiple stages and overlapping events, it was easy for attendees to miss something they wanted to see, especially if they weren’t familiar with how to navigate the app or maps.

GTM and community takeaway: Friction in core operational areas like access, wayfinding, or pricing can overshadow even the best engagement programming. Great communities require as much investment in infrastructure and clarity as they do in creative experiences. Before launching new initiatives, test the journey from your member’s perspective, identify potential pain points, and resolve them early.

Designing for Belonging

KCON LA 2025 was more than a celebration of music and culture. It was a living example of how communities can be designed to invite participation at every level. From layered engagement options to intimate, personal moments, from member-driven creativity to a structure that encouraged exploration, it showed how powerful it can be when people have agency over their experience.

The missteps—ticketing challenges, overcrowding, and communication gaps—were reminders that engagement magic can be dulled if operational basics aren’t in place. For GTM leaders and community builders, the lesson is to balance creativity with flawless execution.

Try this in your own community:

• Audit your engagement layers and add at least one low-effort and one high-touch option.

• Identify one micro-moment you can personalize for members this month.

• Create a space or challenge for member-generated content and promote it.

• Map out an “engagement flywheel” for your community and look for where it breaks.

When you get both creativity and execution right, you don’t just attract participants. You create belonging. And belonging is what turns a crowd into a community.

As a Chief Product Officer or Head of Product, you’re not just building products. You’re crafting experiences, shaping markets, and driving the core of your company’s growth strategy. The stakes are high, and the room for error is shrinking. Customer expectations are evolving faster than ever, and product-market fit feels more like a moving target than a box to check. So, how do you stay ahead?

Enter community. With a thriving community, you gain a real-time, unfiltered view of your customers’ preferences, pain points, and aspirations. It’s not just a sounding board for product ideas; it’s a supercharged feedback mechanism offering insights traditional research often misses. If you’re not already leveraging community as part of your product strategy, you’re missing out on one of the strongest tools for maintaining competitive momentum and building smarter, faster, and more effective products.

Community is more than a feel-good initiative. It’s your secret weapon for validating ideas, capturing emerging needs, and directly influencing customer loyalty and satisfaction by co-creating with the people who matter most. Ignore it at your peril.

What Happens When You Ignore Community

Here’s the reality: without community, you’re flying blind. Instead of uncovering hidden needs or spotting usability issues early, your team is forced to rely on assumptions, small-sample usability studies, or post-mortem customer surveys. The result? You risk focusing on the wrong problems, building features no one asked for, or delivering updates that frustrate your core users.

Peloton’s treadmill recall in 2021 is a prime example. Although safety concerns triggered the backlash, the deeper issue was a lack of proactive engagement with their community. Customers voiced concerns about usability and risks early on, but Peloton failed to engage with these signals until headlines painted them into a corner. The aftermath included a costly recall, public apologies, and lost trust. This could have been avoided with a stronger community-driven feedback loop, which is ironic given that Peloton largely grew via word-of-mouth community advocacy.

Contrast this with Figma’s rise as a community-centric product innovator. Figma built a collaborative design platform alongside a passionate community eager to share feedback, workflows, and feature requests. Their open dialogue with users resulted in features like FigJam and team libraries, which directly reflected the wants and needs of designers. This approach didn’t just inspire loyalty; it elevated them to market leader status within an intensely competitive space.

Ignoring community won’t just slow you down. It means losing out on insights that could transform your roadmap, while creating blind spots where missteps are inevitable.

What You’ll Gain by Working with Community

If you fully embrace community, you won’t just build better products; you’ll create a dynamic, growth-oriented ecosystem around them. Community gives you:

• Faster product validation: Instead of waiting for post-launch analytics to figure out whether a feature hit the mark, use your community to beta test ideas and collect real-time feedback. Spotify demonstrates this approach by launching regional feature rollouts and closely monitoring community sentiments before committing globally. The result is continuous refinement without bad press or disengagement.

• Stronger product-market fit: Your community provides unfiltered conversations that reveal deeper customer needs, many of which you might miss in interviews or focus groups. Airtable capitalized on these insights by identifying how small businesses creatively adapted their product for lightweight CRMs, content calendars, and beyond. By noticing these trends in community discussions, Airtable positioned itself better in key verticals.

• Advocacy and adoption: Products built with user input are also adopted faster. When community members contribute ideas or see their feedback implemented, they willingly advocate for the product’s success. This is exactly how Miro, with its public voting platform for feature prioritization, bolstered customer loyalty and ensured strong adoption.

• Proactive issue detection: A thriving community works as an early-warning system. Before bugs or frustrations escalate into tickets, users organically surface real-world challenges. Lattice leveraged this structure during its launches, addressing usability bottlenecks early by collecting feedback and refining their approach. This prevented churn in its early growth stages.

These aren’t abstract benefits. They directly translate to metrics like higher retention, improved Net Promoter Scores, and more engaged users delivering continuous product insights.

What Community Isn’t for a CPO

To benefit from community without falling into common traps, it’s important to be clear on what it isn’t:

• A feature checklist: Not all feedback is actionable. Your job is to discern high-signal insights from one-off opinions by examining trends over time.

• A shortcut for strategy: Community input doesn’t replace your team’s experience and vision. It sharpens it. Let user voices inform you without handing them the wheel entirely.

• Only a bug forum: Communities are much more than complaint hubs. By engaging deeply, you discover not just problems but also new opportunities for collaboration and inspiration.

Community works best when paired with disciplined processes and clear expectations. It should make your strategy smarter, not cluttered.

What Community Is for a CPO

A thriving community is an engine of insight and opportunity for a Chief Product Officer. It’s:

• A research lab: Observe behaviors, extract trends, and inform your roadmap by watching how conversations evolve in real time.

• A beta testing ground: Reward engaged users with early access to your releases. Their expertise ensures you go to market with confidence.

• A co-author of innovation: Almost no great product emerges in isolation. By partnering with your community, new directions reveal themselves that improve adoption and differentiation.

Think of community as a living feedback loop with exponential returns.

Ideas for Tapping Into Community’s Potential

Communities are an ideal partner for bridging the gap between customer sentiment and innovation, and what makes it work is the intentionality behind it. Here’s how to unlock that potential and engage strategically:

• Host interactive roadmap sessions: Share your roadmap and priorities with your community. Invite their input on features or pain points. Use platforms like Zoom or forums to gather insights and synthesize actionable next steps.

• Build a feature voting system: Encourage your community to propose ideas and vote on improvements they find most valuable. Publicly track progress on these goals to show transparency and credibility.

• Run beta or usability programs: Select active members and allow them to test prototypes. Frame this collaboration as an ongoing partnership that shapes final designs and builds advocacy.

• Organize emerging trend panels: Regularly invite members to weigh in on broader trends impacting your space, which helps your team align with evolving customer mindsets.

These initiatives validate the importance of customer involvement while delivering actionable insights for your team in real time.

Good Intentions, Bad Outcomes

Approaching community as a CPO is nuanced. You go in with the best intentions, but without a thoughtful execution strategy, those good intentions can veer off track. The community space is dynamic, unfiltered, and brimming with feedback, from excited advocates to vocal critics. While this can lead to actionable insights, it’s also easy to fall into common traps that undermine both the purpose of community engagement and the trust of your users.

When communities fail to deliver value for product teams, it’s rarely because they lack potential. More often, the breakdown happens when leaders mismanage expectations or overlook important dynamics. Don’t let these avoidable mistakes dilute your efforts:

Listening to the loud few. It’s natural to give attention to the most visible contributors in the community—those who post often or shout the loudest. But this skews priorities toward the needs of a minority, often leaving broader user groups underrepresented. The lesson here is to balance your input sources. While active users are critical collaborators, quieter segments of your community can offer equally valuable insights. Use surveys, polls, or analytics to ensure you’re hearing from a larger pool.

Breaking the feedback loop. Asking for feedback is only the first step. Failing to acknowledge, address, or act on those inputs can erode trust quickly. Your users want to know that they’re being heard, even if their suggestions don’t immediately result in changes. A simple way to close the loop is by communicating openly, sharing updates on what’s in progress, and explaining why certain requests may not be feasible right now. Transparency builds goodwill and keeps users engaged.

Trying to control the message. Community is authentic by nature, and that means you don’t get to filter what people say. Sometimes they’ll love your release and share it widely. Other times, they’ll be vocal about what’s missing or not working for them. And they’ll do it publicly, because they care and want to be heard. This kind of real, unfiltered feedback is what gives community its power. But it also requires internal alignment. Product teams need to be prepared to hear both the praise and the criticism, and resist the urge to manage sentiment. You can’t tell your users what to feel, say, or share. And if they sense that you’re trying to, they’ll disengage, or worse, stop trusting you. Embracing community means embracing honesty, even when it’s uncomfortable.

Treating engagement as a one-off project. Communities thrive on consistent attention, not sporadic efforts. Too often, teams approach community as a temporary push: interview some users, beta-test a feature, move on. This transactional mindset hurts both participation and trust. Instead, view community engagement as an ongoing practice. The only way to continuously tap into its potential is to stay present and proactive, even between major launches.

The key to avoiding missteps is recognizing that consistency and transparency are just as important as the feedback itself. An effective community strategy doesn’t rely on individual moments of engagement but on a sustained connection that evolves with your team’s goals and your users’ needs.

Begin by creating a clear collaboration framework. Who owns community insights within your team? What’s the process for absorbing, analyzing, and acting on them? Build a system that integrates these workflows naturally into your product pipeline, and make sure every interaction with your community has a clear next step.

Finally, approach engagement with humility. Your community doesn’t expect you to act on every piece of feedback, but they do expect partnership, acknowledgment, and communication. By shifting to a model of consistent collaboration, you turn your community from a source of ideas into a true asset that shapes your business outcomes.

No More Hand-Waving. Here’s What to Actually Do

By now, you see the value of community, but it’s easy to feel stuck at the starting line. You might be asking: What’s the first step? How do I make this work in tandem with everything my team is already doing? Building a community-led product strategy isn’t about overhauling your workflow. It’s about integrating new, scalable ways to listen, learn, and act.

Here’s the good news: you don’t need to rewire everything at once. With small, thoughtful adjustments, you can begin turning community into an engine for impact. These steps are designed to spark action and create momentum:

• Align internally: Schedule a working session with your product and community teams this week. Begin by identifying recurring customer themes from your community conversations or forums. What are users consistently asking for? Are there patterns tied to specific pain points or features? Use this workshop to address two things: which insights are actionable today, and which require deeper exploration. A single cross-functional meeting can set the foundation for real alignment.

• Pilot simple feedback loops: Using an upcoming feature or release, create an experiment with community input. For example, invite members to beta test a new feature through a dedicated forum or session. Collect their feedback systematically, documenting patterns and outliers. This is less about solving everything immediately and more about learning how customers engage with your roadmap in real time.

• Develop a regular feedback cadence: Community engagement isn’t a one-time effort. Establish a consistent process for collaboration, such as monthly check-ins between the community and product teams or regular reports on trending requests. By maintaining a rhythm, these insights will come to feel like a natural extension of your development process instead of an add-on.

• Close the feedback loop: Build trust with your community by sharing how their input drives decisions. For example, after beta-testing a feature or having a public vote on product improvements, summarize the results, explain what’s next, and highlight changes you’re implementing based on their feedback. Users value progress—even more so when they see how they’ve influenced it.

These steps are not lofty or time-intensive. They’re foundational, actionable changes that weave community into your product practice. Even one or two of these initiatives will begin generating value immediately.

Community, Reframed

For a Chief Product Officer, community isn’t just a resource. It is a living, breathing engine of growth, innovation, and trust. It’s how you build not just with customers, but for them, turning distant users into invested advocates.

It’s not about doing more. It’s in doing consistently better. When product teams approach community as a long-term partnership, the benefits compound over time. Engaging with your users regularly creates a relationship based on mutual understanding and trust, which can’t be built overnight.

As you move forward, ask yourself: How can I make community engagement a core part of my team’s DNA? What purpose does your product serve for the people who rely on it most? The answer, found directly in their voices, will guide both your immediate priorities and your long-term success.

The bottom line is this: community doesn’t sit next to your product strategy. It is your product strategy. Are you ready to take the leap?

Whether you’re considering starting a member-led community program or looking to enhance your existing one, Kevin’s insights are packed with practical advice for fostering strong, meaningful connections. I learned a lot on this one!

Connect with Kevin in the Slack Community at slackcommunity.com/san-francisco/ and on LinkedIn.

Chapters

• 00:00 Introduction to Kevin Cox and His Background

• 02:58 Defining Community: A Human Endeavor

• 05:58 The Importance of Listening in Community Building

• 09:01 Experiences in Community Leadership

• 12:02 Leading the San Francisco Slack Community

• 14:55 Engagement Strategies for Community Events

• 18:01 Event Format and Structure

• 20:52 Challenges of Volunteer Community Leadership

• 24:02 The Work Behind Community Events

• 26:30 Motivation for Volunteering

• 29:49 Qualities of a Good Community Leader

• 33:01 Understanding Community ROI

• 38:09 Making Volunteer Leadership Easier

• 42:25 Advice for Organizations Starting Community Programs

• 44:25 Future Aspirations for the Community

We also dive into key engagement strategies, the role of cross-functional collaboration, and what the future holds for Slack’s community. If you’re looking to build or scale a successful community, this conversation is packed with insights you won’t want to miss.

Learn more about the Slack Community and get in touch with Jacob at slackcommunity.com

Chapters

• 00:00 Introduction to Community Building

• 02:57 Transitioning into Community Roles

• 06:00 Defining Community and Its Purpose

• 09:02 The Role of Passion in Community Engagement

• 11:53 The Evolution of Slack's Community

• 15:00 Balancing B2B and B2C in Community Programs

• 17:58 Elements of the Slack Community Program

• 21:06 Engagement Strategies and User Experience

• 24:01 Finding and Recruiting Community Members

• 26:20 Creating Authentic Community Engagement

• 31:16 Cross-Functional Collaboration for Community Success

• 37:16 The Value of Community in Product Development

• 43:22 Understanding Distributed Control in Community Management

• 48:16 Future Aspirations for Slack's Community Program

  Thanks for reading The Community Code! This post is public so feel free to share it.

  Share