Product‑Led Growth: A Playbook for Onboarding & Viral Loops

A great product sells itself only when you intentionally design it to. For early-stage companies, the two levers that move the fastest are the first few minutes of a user’s journey (onboarding) and the loops that carry your product from one person to the next (virality). This playbook provides the patterns, metrics, and checklists you need to design and ship both effectively.

PLG on One Page​

Product-Led Growth (PLG) is a go-to-market strategy that relies on the product itself as the primary driver of customer acquisition, activation, and expansion.

The Goal​

1. Turn cold traffic into activated users as quickly and efficiently as possible.
2. Turn those activated users into a distribution channel for the next cohort of users.

Two Numbers to Watch​

• Activation Rate: This measures the efficiency of your onboarding. Activation Rate = Activated Users / Sign-ups
• Viral Coefficient (k): This measures the effectiveness of your viral loops. k = (Invites sent per active user) × (Invite acceptance rate)

Aim for a k ≥ 0.1 in the early days. A k greater than 1.0 signifies exponential growth but is rare and often fragile. Remember, the cycle time (t)—the time it takes for a user to invite others—matters as much as k. A shorter cycle time compounds growth much faster.

Your North Star​

Choose a single weekly metric that is deeply tied to the core value your product delivers. Examples include "weekly active teams," "documents shared weekly," or "tasks completed by more than one collaborator." This keeps your entire team focused on what truly matters.

The First-Mile: Design for Time-to-Value (TTV)​

The first five minutes a user spends with your product are the most critical. Your only goal is to get them to the "Aha!" moment—the point where they experience the core value—as fast as possible.

Define “Activation”​

Before you do anything else, you must define what "activation" means for your product. It's not just logging in; it's the smallest, measurable action that correlates with long-term retention. Be specific.

• Examples: "Created their first project and invited one teammate," "recorded and shared their first video," or "sent their first API request that returns a 200 OK status."

Choose one definition, instrument the tracking for it, and commit your team to improving this number above all else.

First-Mile Checklist (Ship this before any growth spend)​

• Friction Audit: Remove or defer every single field you can from the signup form. Ask only for an email and a password (or better yet, a single sign-on option).
• Opinionated Defaults: Don't drop users into a blank slate. Start them in a ready-to-use workspace, either with sample data or a one-click template.
• Single Clear Path to "Aha!": Ensure there is a visible, primary call-to-action (CTA) that guides the user toward the activation event across their first three screens.
• Smart Empty-State Design: Teach users by letting them do. Use inline hints, pre-filled examples, and editable demo objects instead of static images.
• Import Fast-Lane: Your users' work already exists somewhere else. Make it easy to import from CSV, Google, Slack, Notion, GitHub, or wherever they live.
• "Done" Moments: Use confetti, checkmarks, or subtle success states to reward task completion. This reinforces progress without interrupting their flow.
• Safety Guardrails: Implement features like autosave, undo, and safe retries to reduce users' fear of making a mistake.

Low-Lift Patterns That Work​

• Template Gallery: Offer 3–7 opinionated templates at signup to help users visualize the end state.
• Interactive Checklist: Pin a simple checklist in the product ("Create X → Share Y → Invite Z") that guides users through the activation steps.
• Progressive Profiling: Ask for more user information (like role or team size) after they've activated, not before.
• Behavioral Nudges: Trigger in-app messages based on user behavior, not just time. For example, show the "Invite" prompt only after they've created something worth sharing.

Lifecycle Messaging (Keep it minimal)​

• Day 0: Send a "Here’s your next action" email with a deep link that takes them to the exact screen they need to be on.
• Day 2: If they haven't activated, send a 30-second tip tied to the specific activation step they missed.
• Day 7: Use social proof and a reason to go multiplayer. For example, "Teams on our platform complete projects 35% faster with two or more members."

Viral Loops: A Construction Kit​

Virality isn't a marketing stunt; it's use-case distribution. Design loops around product value that either requires or shines with other people.

Core Loop Types​

• Collaboration Invites (Multiplayer Loop):
  • Trigger: I'm working on something and I need a teammate to review, edit, or contribute.
  • Action: I click "Invite to workspace/doc/board."
  • Reward: My work gets unblocked, we finish faster, and I see their activity live.
• Content Sharing (Viewer Loop):
  • Trigger: I've produced something of value that I want to show others (a design, a report, a video).
  • Action: I generate and share a public link or embed the content.
  • Reward: Others see the value in what I've created. A CTA on the viewing surface ("Try this for yourself") converts them into new users. Note: The share page is a landing page—treat it like one.
• Utility Links (Single-Player Loop):
  • Examples: Scheduling links (Calendly), status pages (Linear), or code sandboxes (CodePen).
  • Reward: The recipient gets immediate value from the link, and you earn a new user with minimal friction.
• Give-Get Incentives (Referral Loop):
  • Reward: Offer credits, increased usage limits, or extended trial time. Keep the math simple and make the reward visible to both the sender and the recipient.
• Integration Loops (Ecosystem Loop):
  • Trigger: I connect your product to Slack, GitHub, or Google. Your product then posts activity notifications into those platforms, which naturally invites others to click back into your product.

Design Rules for Effective Loops​

1. Place the loop's trigger at the moment of peak user intent (right after the "Aha!" moment, before they tab away).
2. Keep the action to a single click and avoid modal dead-ends.
3. Ensure the recipient's landing surface converts with clear product framing and a strong "Try it" CTA.
4. Show the sender post-send feedback like "Invites sent (2), Pending (1)" with an easy way to resend.

Numbers That Matter​

• Invite Rate = Invites sent / Weekly Active Users (WAU)
• Acceptance Rate = Accepted invites / Sent invites
• k-factor = Invite rate × Acceptance rate
• Cycle Time (t) = The median time from when an invite is sent to when the recipient activates.
• Loop Quality = Activated recipients / Recipients who opened the shared artifact.

Copy That Moves Action (Steal This)​

• "Add a reviewer → Get it done 2× faster."
• "Share a view-only link → Your original work stays private by default."
• "Invite your team → We'll auto-assign roles based on their email domain."

Instrumentation: Track Once, Answer Forever​

A solid event tracking plan is the foundation of any PLG motion.

Minimum Viable Event Taxonomy​

• Setup: account_created, workspace_created, template_used, import_completed
• Core Actions: item_created (your core object), item_shared, invite_sent, invite_accepted
• Expansion: integration_connected, billing_started, session_start

Essential Properties: role, team_size, source (ad/organic/share), template_id, domain.

Dashboards to Build​

1. First-Mile Funnel: Sign-up → Workspace Created → Core Object Created → Activation Event.
2. Viral Loop Funnel: Invite Sent → Invite Delivered → Invite Opened → Invite Accepted → Recipient Activated.
3. Cohort Analysis: Cohorts grouped by their first value event (e.g., template used vs. imported data) and by team size at Day 1.

Queries You’ll Run Weekly​

• "What percentage of new users touched a template before activating?"
• "What is our activation rate by traffic source and by which integration they connected?"
• "How many invites are sent per activated user, and what is the acceptance rate by the recipient's email domain?"

High-Impact Experiments and Anti-Patterns​

Experiments That Usually Pay Off​

• Onboarding:
  • Skip the password step when a user's SSO domain is recognized; use an email-first magic link flow.
  • Start users in a live demo workspace with pre-made objects they can safely edit and explore.
  • Collapse steps: combine "Create X" and "Share Y" into a single "create-and-share" action.
• Virality:
  • Add a clear CTA on the public viewer page (e.g., "Duplicate this template for free").
  • Pre-fill invite roles by context ("Assign as Reviewer to this document").
  • Turn system notifications into soft invitations in your Slack or Teams integration.
• Pricing:
  • Allow free multiplayer on a narrow scope (e.g., free viewers or commenters).
  • Reward successful invitations with usage credits rather than cash, as it's closer to the product's value.
• Messaging:
  • Replace the generic "Welcome" email with one that contains a single, deep-linked task.
  • Trigger one in-app nudge if a user stalls for more than 20 seconds on the primary "Aha!" screen.

Anti-Patterns to Avoid​

• Asking for a credit card before the user has experienced value in a PLG funnel.
• Gating invites behind admin-only controls in small, collaborative workspaces.
• Using welcome tour carousels that force users to read instead of do.
• Creating referral programs that only reward the sender (the recipient needs a reason to accept, too).
• Designing share pages with no clear CTA or that demand signup before the user can even preview the content.

B2B Readiness Without Killing PLG​

You can serve enterprise buyers without adding friction for self-serve users.

• Offer SSO/SCIM but don't require it for small teams.
• Build clear roles and permissions into the invite flow, with defaults set to the least privilege.
• Make export and deletion paths evident from the start to build trust and speed up trials.
• Provide an admin overview showing seat usage, pending invites, and an audit trail to open the door for future expansion.

Quick Playbooks by Product Type​

• Collaboration Tool (e.g., Miro, Figma):
  • Activation: User creates their first item + adds one collaborator.
  • Loop: Place the "Invite" button inline on the object's toolbar. Suggest a role (e.g., "Commenter," "Editor") based on the user's last action. The share page should double as a demo with a visible "Duplicate" button.
• Async Video / Screen Capture (e.g., Loom):
  • Activation: User records a video ≥30s long, shares the link, and the recipient watches for ≥10s.
  • Loop: Automatically copy the share link to the clipboard when recording stops. Open the share page in a new tab with an embedded CTA to "Try recording for free."
• Scheduling / Utility (e.g., Calendly):
  • Activation: User connects their calendar + sends their first booking link.
  • Loop: After setup, automatically copy the booking link to their clipboard and open their public booking page so they can preview what recipients will see.
• Developer Tool / API (e.g., Stripe, Twilio):
  • Activation: User makes their first successful API request or deploys an example app.
  • Loop: Provide a one-click starter project in a public repository. In-app, auto-generate an API key and a sample curl command. Virality comes from public examples, README badges, and integration webhooks.

What Good Looks Like (Targets for Calibration, Not Dogma)​

• Activation Rate: 40–60% for self-serve B2B trials; 25–40% for horizontal prosumer apps.
• Day 1 Retention: 20–30% for B2B. Look for Week 1 to Week 4 retention to be flat or improving as team size increases.
• Invite Rate: Aim for ≥0.4 invites per Weekly Active User. Push for ≥1 for strongly multiplayer tools.
• Acceptance Rate: 20–50% is achievable when the shared surface carries clear value before signup.
• Cycle Time: A median time of under 72 hours from invite to activation is a strong signal.

Team, Rituals, and Templates​

The Team & The Meeting​

• Owner: A growth-minded Product Manager partnered with a Product Marketing Manager and a dedicated growth engineer.
• Weekly Growth Review (60 mins):
  • 15 min: Review core metrics: activation, k, t, and cohort health.
  • 15 min: Discuss learnings from the top two experiments that just concluded.
  • 30 min: Decide on and staff the next two experiments. Write lightweight PRDs on the spot.
• Your team's "Definition of Done" for any growth experiment must include event tracking, feature flags/guardrails, and a rollback plan.

Templates (Copy/Paste into your system)​

Onboarding PRD (1-Pager):

Problem: [Clear, concise user problem.] > Users Affected: [Segment.] > Target Metric Lift: [e.g., Increase Activation Rate from 40% to 45%.] > UX: [One screenshot or mock of the change.] > Events to Track: [List of new events.] > Risks: [e.g., May decrease X.] > Rollout Plan: [e.g., 50% of new users for 2 weeks.]

Viral Loop Spec:

Trigger: [When/where does the user feel the need to invite?] > User Action: [The one-click action they take.] > Recipient Surface: [Mockup of the landing page the recipient sees.] > Reward: [Value to sender and recipient.] > Event Names: invite_sent, invite_accepted. Abuse Guardrails: [e.g., Limit of 10 invites per hour.]

Experiment Card:

Hypothesis: We believe that [making this change] for [this user segment] will [cause this outcome]. We'll know we're right when [this success metric] changes. Variant(s): [Description of A/B test variants.] > Success Metric: [Primary metric, e.g., Activation Rate.] > Guardrail Metrics: [Metrics to watch to ensure no negative impact, e.g., Churn.] > Sample Size: [Number of users needed.] > Decision Rule: [e.g., Ship if variant is 5% better with 95% confidence.] > Owner: [Name.] > Ship Date: [Date.]

Your Founder To-Do List (This Week)​

1. Sit with five new users and time how long it takes them to hit your "Aha!" moment. Write down every single stall and point of confusion.
2. Ship one upgrade to an empty state and one upgrade to an invite surface.
3. Add a CTA to your public viewing/sharing surface that lets recipients try the product in one click.
4. Stand up the three dashboards listed above and get your team to formally agree on your single, measurable definition of "activation."

Make the first five minutes of your product completely obvious. Put your product on your users' shoulders so it can introduce itself to their peers. That’s PLG done right.