The PLG Product Manager.

In Product-Led Growth, the product itself — not the sales team — is the primary engine of acquisition, activation, conversion and expansion. The PLG PM owns that engine. Synthesis based on the Kaltura PLG PM role, the PLG canon (Bush, OpenView) and field practice.

01What PLG is — and how the role differs

— the user discovers value self-serve; revenue follows usage, not sales calls

The term was coined by the VC firm OpenView Partners (~2016). The model: a free entry point (freemium or free trial), an onboarding that gets the user to value fast, usage data that identifies who is ready to pay, and in-product prompts that convert them — with no human intervention for the core motion. Kaltura frames the role as sitting at "the intersection of product, growth, marketing, payments, and data."

Compared to a classic feature PM, the PLG PM :

Owns a funnel and a metric, not a feature area. The deliverable is a moved number (activation rate, free→paid conversion), not a shipped feature.
Ships experiments, not roadmap items. The unit of work is an A/B test with a hypothesis and a measurable outcome — Kaltura asks explicitly for "experiments with clear hypotheses and measurable outcomes."
Lives in the analytics tool daily (Amplitude, Mixpanel, Segment are named in the job spec). Behavioral data is the backlog source: instrument journeys → find friction → test a fix.
Treats pricing, packaging and billing as product surfaces — paywall placement, trial length, seat limits and upgrade prompts are product decisions, tested like any UI change.

02The missions, in priority order

— sequenced by leverage: activation first, monetization second, loops third

1 · Activation & time-to-value Own the activation funnel end-to-end — from signup to the "aha moment", the action where the user first experiences the core value. This comes first because everything downstream (conversion, retention, referral) compounds on it. Work: cut steps, delay account friction, pre-fill, guide with checklists and empty-states. Example — famous activation milestones: Facebook "7 friends in 10 days", Slack "2,000 messages sent in a team". For a video platform like Kaltura: "first video published & played".

2 · Free → paid conversion Design the free offer and its limits (freemium tiers, trial length, feature gates, seat caps) so that the upgrade moment lands exactly when the user hits real value. Test paywall placement and in-product upgrade prompts. Example — a "you've used 9/10 free projects" banner converts better than a generic pricing email, because it fires at the moment of need.

3 · PQL pipeline Define Product Qualified Leads — accounts whose usage signals buying intent (team size, feature depth, frequency) — and route them: self-serve upgrade for small accounts, sales-assist handoff for large ones. This is where PLG meets the sales team. Example — a PQL rule: "≥ 3 active users AND ≥ 1 integration connected within 14 days".

4 · Experimentation program Run a continuous A/B testing cadence on conversion, engagement and retention. Each experiment: hypothesis → metric → decision. The PLG PM's roadmap is a prioritized backlog of experiments, re-ranked by expected impact on the north-star funnel.

5 · Viral & expansion loops Build the loops that make the product spread on its own: invites, sharing, collaborative features, public artifacts. Example — every Calendly booking link exposes a non-user to the product; Figma files force collaborators to create an account.

6 · New self-serve entry points Expand the PLG surface — Kaltura words it as "identifying new self-serve entry points, use cases, and packaging": new landing→product flows, templates, integrations or micro-tools that let a new segment start without talking to anyone.

Anti-pattern

Optimizing signup volume while activation is broken. More traffic into a leaky funnel just burns acquisition spend — fix time-to-value before scaling the top.

03KPIs — formula and exact instrumentation

— each metric, how to compute it, and the events to tag in the product

These are the KPIs named in the Kaltura spec ("activation rate, conversion, time-to-value, PLG revenue, PQL generation") plus the standard retention and loop metrics. The tagging column is the event plan to implement in Amplitude / Mixpanel via Segment.

KPI	Formula	Events to tag
Signup rate	accounts created ÷ unique visitors	`page_view` (with UTM props), `signup_started`, `account_created`
Activation rate	accounts reaching the aha event ≤ N days after signup ÷ accounts created (cohort)	one named `aha_event` per product — e.g. `first_video_published` — plus the funnel steps before it: `onboarding_step_completed` (step property)
Time-to-value	median(t_{aha_event} − t_{account_created})	same two events, timestamped — no extra tagging, but clocks must come from the backend, not the client
Free → paid	accounts upgraded ÷ free accounts, per signup cohort	`paywall_viewed` (trigger property), `upgrade_clicked`, `checkout_started`, `plan_upgraded` (plan, seats, MRR props)
PQL rate	accounts matching the PQL rule ÷ active free accounts	the rule's underlying signals: `invite_sent`, `invite_accepted`, `integration_connected`, feature-depth events; PQL itself is computed, not tagged
Retention D7 / D30	cohort still active at day N ÷ cohort size	a product-specific activity event (e.g. `video_played`), not raw `session_start` — sessions overstate real usage
Viral coefficient K	invites per user × invite→signup conversion	`invite_sent`, `invite_accepted`, `account_created` with `source=invite` property
PLG revenue	MRR from accounts with zero sales touch	an account-level `acquisition_motion` property (self-serve / sales-assist / sales-led), set at creation and never overwritten
NRR	(MRR_start + expansion − contraction − churn) ÷ MRR_start	billing-system data (plan changes, seat changes) joined to product accounts — comes from the billing pipeline, not front-end tags

Tagging rule

Tag actions, not pages, name events object_verb, attach properties instead of multiplying events, and version the tracking plan with the data team — every KPI above dies if the underlying event fires inconsistently.

04Stakeholders, in working order

— who the PLG PM needs, and for what, ranked by frequency of contact

Growth eng & Data Daily. Instrumentation, experiment infrastructure, tracking plan, feature flags. Kaltura asks for "technical fluency to work closely with engineering on integrations, tracking, and scalable systems" — this pair is the engine room.

Marketing & PMM Weekly. Explicitly named by Kaltura: alignment on "acquisition, messaging, and onboarding". The landing page promise and the first in-product screen must tell one continuous story — a seam between them shows up directly as activation drop.

Sales Weekly. The PQL handoff contract: which accounts go self-serve vs sales-assist, what usage context sales sees, and feedback on PQL quality — the loop that makes the hybrid motion work.

Billing / Ops / Finance Per initiative. Trials, plan changes, payments, invoicing (Kaltura lists subscription/billing/payments experience as a plus). Pricing tests are cross-signed with finance.

Design & CS Per initiative. Design for onboarding UX; Customer Support as a friction-signal source — support tickets on the first-run experience are activation bugs by another name.

05Canon — authors & reference reading

— the short list that defines the discipline

Wes Bush — Product-Led Growth: How to Build a Product That Sells Itself (2019). The method book; free-model choice (freemium vs trial), the "value gap", the ProductLed framework. Official site: productled.com. Book summary in French: Le Ticket — la synthèse du livre méthode.
OpenView Partners — the VC firm that coined "Product-Led Growth" (~2016, Blake Bartlett) and published the reference benchmarks and PQL literature.
Kyle Poyar — ex-OpenView; Growth Unhinged, the leading practitioner newsletter on PLG pricing, benchmarks and hybrid motions: growthunhinged.com.
Elena Verna — growth leadership (Miro, Amplitude, Dropbox, SurveyMonkey); reference writing on growth models, PLG↔sales hybrids and the growth org: elenaverna.com.
Sean Ellis & Morgan Brown — Hacking Growth (2017); the experimentation cadence, and Ellis's PMF survey ("how disappointed would you be...") used upstream of any PLG push.
Dave McClure — the AARRR "pirate metrics" funnel (2007): Acquisition, Activation, Retention, Referral, Revenue — still the skeleton of every PLG dashboard.
Brian Balfour — founder of Reforge; the growth loops model (loops beat funnels: each cohort's output feeds the next cohort's input): reforge.com.
Le Ticket 🇫🇷 — French-language PLG guide: Wes Bush's method summarized, interviews (John Cutler; Enzo Avigo, June.so) and French case studies (Yousign, Fleet): le-ticket.fr.
Userpilot — vendor guide, practical rather than canonical: Product Growth Strategy: A Guide for SaaS Companies (2024). Useful for the Ansoff Matrix applied to SaaS growth, the North Star / auxiliary / counter-metric triad — counter-metrics guard against optimising one number at another's expense — and worked examples (Slack, Calendly, Dropbox).

The PLG PM in one sentence: instrument the journey, find where users leak before value, run the experiment that fixes it, and let usage — not a sales pitch — qualify who pays. Priorities follow the funnel: activation before monetization, monetization before loops.

← Back to the process