Journey Mapping for Product-Led Growth: Where the Loop Reenters the Map

A PLG journey map works only when it stops at the acquisition funnel's edge and starts folding back on itself: the moment an activated user invites, shares, or publishes, mark that action as a new input to the top of the map, not an endpoint. That single re-entry arrow is what separates a growth loop from a funnel.

Quick answer: Map your PLG journey as a loop, not a line. Follow one user from activation to the moment their action (invite, share, publish) creates a new touchpoint for someone else, then draw an arrow from that output stage back to the top of the map. That arrow is the re-entry point — the actual growth engine.

Why a Straight Line Can't Show You Where Growth Comes From

Traditional journey maps run left to right: awareness, consideration, onboarding, adoption, renewal. That works for a purchase decision with one buyer and one product experience, but a PLG product's growth mostly happens inside the used product, when one user's action creates the entry point for the next user's journey — something a straight timeline can't render.

Most journey-mapping templates were built for a sales-led world, where a buying committee evaluates, signs, and hands the product to end users who mostly just consume it. That's still real for enterprise PLG deals — see B2B buying committee journey mapping for how multiple stakeholders enter a single deal — but it doesn't explain how a workspace grows from three people to three hundred, or how someone watching a shared video ends up creating their own account.

Wes Bush, who popularized the term through ProductLed and his book Product-Led Growth, frames the distinction simply: in a sales-led motion the product is the result of a conversion; in a product-led motion the product is the conversion mechanism. Growth doesn't happen despite the product experience — it happens because of specific moments inside it.

That distinction matters for mapping because most teams inherit a methodology built for the first world and force-fit it onto the second. Our complete guide to customer journey mapping covers the standard stage, emotion, and touchpoint columns — still useful — but PLG needs one more column: does this stage produce a new acquisition input?

The funnel undercounts what a loop reveals

Brian Balfour and the team at Reforge popularized growth loops as a replacement for the AARRR funnel, arguing that funnels describe a single pass through a system while durable growth comes from output recycling back into input. Kevin Kwok's widely circulated essay "Growth Loops Are the New Funnels" makes the same case: a funnel treats each new user as arriving from an unexplained outside source, while a loop model asks where that user actually came from — usually, another user's action.

OpenView Partners' annual SaaS Benchmarks research has, across several editions, shown product-led companies posting stronger net revenue retention than sales-led peers in the same cohort — directionally consistent with the idea that in-product loops keep compounding long after the initial signup, not just at renewal time.

This doesn't make the linear map wrong — it makes it incomplete for PLG. You still need it to diagnose friction and emotion at each stage; you now also need to name which stage functions as the loop's re-entry point.

The Four Parts of Every Growth Loop — And Where Each One Lives on Your Map

Every growth loop breaks into four parts: an input (a user enters the system), an action (they do something inside the product), an output (that action creates an artifact — an invite, a share, a public page), and a re-entry trigger (the output pulls a new input in). Map all four before drawing arrows.

1. Input — a person or piece of content entering your system for the first time (a new signup, a shared document, an invited teammate).
2. Action — the core behavior your product needs from that person (create a doc, invite a collaborator, publish a page).
3. Output — the artifact the action produces that's visible to someone outside the current user (a notification, a shared link, a public gallery entry).
4. Re-entry trigger — the mechanism that turns that output into a new input for someone else (an email invite, an @mention, an indexed public URL).

The action that creates output rarely happens because a user wants your activation metric to go up — it happens because sharing does a job for them. Getting a colleague unblocked, looking competent to a client, or delegating a task is the actual job being hired.

Skip that motivational layer and you'll misdiagnose why an invite feature underperforms. Our JTBD framework guide walks through Ulwick-style opportunity scoring for exactly this kind of causal digging — useful before you assume a "share" button just needs a bigger call-to-action.

Mapping an Invite-to-Share Loop, Stage by Stage

To map an invite/share loop, run one activated user through six checkpoints: activation, trigger, action, output, propagation, and re-entry — marking emotional state and friction at each stop. The worked example below covers a B2B collaboration tool, but the same six checkpoints apply to any loop mechanic, whether it's an invite, a share, or user-generated content.

Notice the last row: re-entry isn't a new stage you invent — it's the moment the invitee lands back at row one, Activation, for their own account. That's the fold. Draw six boxes in a row and you'll present a finished funnel; draw an arrow from row six back to row one, and it's obviously a wheel, not a hallway.

What makes this loop strong or weak

• Cycle time — how long from Action to Re-entry. Days is healthy; weeks quietly kills compounding.
• Conversion rate at each arrow — invite-sent to invite-accepted, invitee-viewed to invitee-signed-up. Andrew Chen's research in The Cold Start Problem repeatedly shows invite-acceptance rates sitting in the single digits to low double digits for most products, meaning loop strength lives mostly in volume and repeat cycles, not per-invite conversion.
• Amplification factor — how many outputs one action produces (one invite versus one page indexed by search and viewed by hundreds).
• Decay — whether the loop weakens each cycle (invite fatigue) or holds steady.

A journey map that stops at "user is retained" answers whether you keep the customer. A journey map that shows the re-entry arrow answers whether the customer is quietly building your funnel for you.

Marking the Re-Entry Stage: Where an Activated User Becomes New Acquisition

Mark re-entry as a distinct, labeled stage on the map — not an implied footnote — placed where the loop's output connects back to the top. Give it its own owner, its own success metric (loop conversion rate, not just retention), and its own friction audit, because teams that don't name it rarely invest in improving it.

Most teams already map "retention" or "advocacy" as a late-funnel stage. That's not the same as re-entry. Retention asks: does this person stay a customer? Re-entry asks: does this person's continued use manufacture a new customer? A retained user who never invites anyone is valuable revenue; a retained user who invites three teammates a month is a growth channel.

1. Find the artifact. Every real re-entry point has an artifact attached — a link, an @mention, a shared file, a public profile. No nameable artifact usually means you've found a hope, not a loop.
2. Draw the fold explicitly. Add an arrow — not just an annotation — from the output stage back to the earliest relevant stage for the next user, not the current one.
3. Give it a metric that isn't retention. Loop conversion rate, invites-per-active-user, k-factor, or share-to-signup rate are all fair game; retention alone hides loop decay.
4. Assign an owner. This stage usually falls in a no-man's-land between growth, product, and lifecycle marketing. Name an owner or it will quietly rot.

Front-stage and back-stage friction at re-entry

The re-entry moment has a visible front-stage experience (the invitee sees a link) and an invisible back-stage system making it work — permissioning, deliverability, rate limits to stop abuse. Mapping only the front-stage hides why loops decay; our service blueprint versus journey map guide covers adding that back-stage layer without losing the map's readability.

From Loop Map to Causal-Loop Diagram: Modeling the Reinforcing Feedback

A journey map, even a folded one, shows a single trip around the loop — it can't show what happens over ten cycles, or which variable actually limits growth. For that, translate the loop into a causal-loop diagram: a systems-thinking tool that models reinforcing loops and balancing loops as they compound or cap out.

Donella Meadows, in Thinking in Systems, formalized the distinction product teams now borrow for growth: a reinforcing loop amplifies whatever's already happening (more invites lead to more users, which leads to more invites), while a balancing loop pulls a system back toward equilibrium (invite fatigue, spam filters, market saturation). Our systems thinking complete guide covers the notation in depth if it's new to your team.

A causal-loop diagram takes the same four parts you just mapped — input, action, output, re-entry — and redraws them as a circle of variables connected by arrows marked + (more of this causes more of that) or - (more of this causes less of that). Where every arrow around the circle multiplies in the same direction, you have a reinforcing loop, and growth compounds until something outside it caps the ceiling.

Use both tools in sequence, not instead of each other. The emotion curve from your journey map tells you where users hesitate before inviting someone; the causal-loop diagram tells you whether fixing that hesitation actually compounds growth or just moves the bottleneck. If you've already built an emotion curve for this flow, our guide on turning an emotion curve into a prioritized backlog shows how to rank friction points by where they sit in the loop, not just by how painful they feel.

Common balancing forces worth naming before you celebrate a reinforcing loop:

• Notification fatigue — invitees start ignoring invite emails after repeated exposure.
• Market saturation — every plausible teammate is already invited or already has an account.
• Anti-abuse throttling — email and messaging platforms rate-limit or flag invite-like behavior.
• Value dilution — a shared view that's genuinely useful the first time becomes noise the tenth time.

Tooling the Loop: From Whiteboard Arrows to a Living Model

As a prototype today, that means laying out the six-stage loop above as an actual journey artifact, marking the re-entry stage explicitly instead of burying it in a footnote, then switching to a causal-loop view to reason through which variable — invite volume, acceptance rate, or signup friction — is the one actually worth fixing first. It's a way of keeping the fold visible, quarter over quarter, instead of redrawing it from memory every time growth stalls.

Key Takeaways

• PLG journeys are loops, not lines — the growth mechanic is a user's action producing the next user's input, which a straight-line map can't render.
• Every loop has four parts: input, action, output, and re-entry trigger — name all four before you draw arrows.
• Mark re-entry as its own labeled stage, with its own owner and its own metric (loop conversion rate, not retention), or it will get ignored.
• Cycle time and amplification factor matter as much as conversion rate — a slow loop barely compounds even at healthy per-step conversion.
• A causal-loop diagram (reinforcing vs. balancing loops) shows whether fixing a friction point actually compounds growth, which a journey map alone cannot.
• B2B PLG products often need two nested loops mapped: an individual usage loop and a committee-approval loop layered on top.
• Use the emotion curve to find where users hesitate, and the causal-loop diagram to decide whether it's worth fixing.