Engineering Product-Led Growth: What the Code Actually Looks Like

PLG Is an Engineering Problem

Product-led growth (PLG) means your product is the primary vehicle for acquiring, converting, and expanding customers. Users self-serve their way to value without requiring a sales rep.

This sounds like a product philosophy. In practice, it's a set of technical requirements:

1. Frictionless self-signup (no sales call required)
2. Time-to-value under 10 minutes
3. Usage tracking that shows you when users hit the activation event
4. In-app upgrade prompts at the right moments
5. Viral loops that make the product spread organically
6. Expansion revenue mechanics (seats, usage, features)

Each of these has an engineering implementation. Let's look at them.

Instrumentation First

PLG without data is guesswork. Before you implement any PLG feature, you need event tracking that captures the complete user journey.

The events that matter most:

// User lifecycle events
analytics.track('Signed Up', {
  method: 'google_oauth' | 'email',
  source: utm_source,
  plan: 'free',
});

analytics.track('Activated', {
  time_to_activation_seconds: 847,
  activation_event: 'created_first_project',
});

analytics.track('Invited Teammate', {
  inviter_id: user.id,
  invitee_email: invite.email,
  product_area: 'onboarding_checklist',
});

analytics.track('Hit Limit', {
  limit_type: 'projects' | 'seats' | 'api_calls',
  current_usage: 10,
  limit: 10,
  plan: 'free',
});

analytics.track('Upgraded', {
  from_plan: 'free',
  to_plan: 'pro',
  trigger: 'limit_hit' | 'feature_gate' | 'invite_prompt',
  revenue: 49,
});

Without tracking Hit Limit and its relationship to Upgraded, you can't measure whether your paywall placement is working.

Feature Gating Architecture

Feature gates control which plan can access which features. A naive implementation hardcodes plan checks:

// Bad — scattered plan checks create maintenance hell
if (user.plan === 'free') {
  throw new Error('This is a Pro feature');
}

A scalable implementation centralizes gate logic:

// lib/gates.ts
type Feature =
  | 'advanced_analytics'
  | 'custom_domain'
  | 'api_access'
  | 'sso'
  | 'audit_log';

const planFeatures: Record<string, Feature[]> = {
  free: [],
  pro: ['advanced_analytics', 'custom_domain', 'api_access'],
  enterprise: ['advanced_analytics', 'custom_domain', 'api_access', 'sso', 'audit_log'],
};

export function can(user: User, feature: Feature): boolean {
  const features = planFeatures[user.plan] ?? [];
  return features.includes(feature);
}

// Usage in a Server Component
export default async function AnalyticsPage() {
  const user = await getUser();
  
  if (!can(user, 'advanced_analytics')) {
    return <UpgradePrompt feature="advanced_analytics" />;
  }
  
  return <AnalyticsDashboard />;
}

This makes it trivial to add new features to plans, audit what's gated where, and A/B test different plan structures.

The Upgrade Prompt

The best upgrade prompts appear at the exact moment a user wants to do something they can't do on their current plan — and make upgrading the path of least resistance.

// components/UpgradePrompt.tsx
'use client';

export function UpgradePrompt({ feature }: { feature: Feature }) {
  const featureCopy = {
    advanced_analytics: {
      title: 'See exactly how users move through your product',
      description: 'Advanced analytics with funnel analysis, retention curves, and cohort breakdowns.',
      cta: 'Upgrade to Pro',
    },
    // ...
  };

  const copy = featureCopy[feature];

  return (
    <div className="upgrade-gate">
      <h3>{copy.title}</h3>
      <p>{copy.description}</p>
      <button onClick={() => openUpgradeModal(feature)}>
        {copy.cta}
      </button>
      <p className="social-proof">Trusted by 2,000+ teams</p>
    </div>
  );
}

The upgrade modal should pre-select the relevant plan, highlight the feature the user was trying to access, and get them to payment in as few clicks as possible.

Viral Loops: Engineering Organic Growth

PLG's defining characteristic is the viral loop: users doing their normal work generates exposure that brings in new users.

The strongest viral loops in SaaS:

Collaboration invites: A user adds a teammate. The teammate receives an email, creates an account, and is now a new user. Slack, Figma, and Notion all grew primarily through this loop.

Implementation requirements:

• Accept invite without prior account
• Smooth account creation on the invite landing page
• New user is immediately placed in the right context (the shared workspace)

Shared artifacts: A user shares a report, document, or design. The recipient, who doesn't have an account, can view it and is prompted to sign up to collaborate.

Implementation requirements:

• Public share links for all content types
• "View as guest" mode that doesn't require an account
• Prominent but non-intrusive signup prompt for guests who engage

Public profiles/pages: User-generated content with your branding. Dribbble shots, Notion pages, Vercel deploy previews — all carry the platform's brand to viewers who don't use the product.

Usage-Based Upgrade Triggers

Hard limits ("you've hit your 10-project limit") convert, but they create negative sentiment. Usage-based nudges that appear before the limit are more effective:

// Show an upgrade prompt at 80% of limit
function UsageIndicator({ current, limit }: { current: number; limit: number }) {
  const percentage = (current / limit) * 100;
  
  if (percentage >= 80) {
    return (
      <div className={percentage >= 100 ? 'usage-critical' : 'usage-warning'}>
        <span>{current} / {limit} projects used</span>
        {percentage >= 80 && (
          <button onClick={openUpgradeModal}>
            Get unlimited projects →
          </button>
        )}
      </div>
    );
  }
  
  return <span>{current} / {limit} projects</span>;
}

The 80% prompt converts at lower urgency but higher sentiment. The 100% prompt converts at higher urgency. Both are valuable — A/B test which drives better LTV, not just conversion rate.

Measuring PLG Health

The three metrics that tell you if your PLG motion is working:

Product Qualified Leads (PQL) rate: What percentage of free users reach activation? Target: 30%+. Below 20% means your onboarding or product isn't delivering value fast enough.

Free-to-paid conversion rate: Of activated free users, what percentage convert to paid? Target: 2–5% for broad self-serve, 5–15% for targeted B2B. Improve by: better upgrade prompts, better plan structure, better feature gating.

Time to revenue: From signup to first payment, how long does it take? Under 7 days is strong. Over 30 days means your upgrade triggers are either missing or misplaced.

PLG isn't a set-it-and-forget-it system. It requires the same data-driven iteration as any other product surface — just with revenue as the north star metric.