Build PLG Lead Scoring in HubSpot Without Code (2024 Guide)

Quick answer: Build PLG lead scoring in HubSpot by syncing product usage data to custom properties, then score contacts based on activation milestones, feature usage, and engagement frequency. No warehouse or engineering required—use HubSpot's native scoring tool with real-time product data.

• Traditional reverse ETL – Requires data warehouse, ETL pipeline, $50K+ setup, 2-3 months. Most accurate but engineering-heavy.
• Zoody – Real-time product event sync to HubSpot, no warehouse. RevOps teams set up in days, $149/mo.
• HubSpot native scoring – Built into Professional+ plans. Works great once you have product data in custom properties.
• iPaaS tools (Zapier, Workato) – Can sync some events, but limited scale and higher latency.

Why Traditional Lead Scoring Fails for PLG Companies

Traditional lead scoring in HubSpot assigns points for email opens, form submissions, demo requests, whitepaper downloads, and demographic fit. A VP at a Fortune 500 company who opens three emails gets 45 points. An engineer at a startup who logs into your product daily gets zero.

For product-led growth companies, this creates a blind spot. Your best leads are the ones actively using your product—building projects, inviting teammates, hitting usage milestones. But HubSpot doesn't see any of that behavior because it lives in your application database or analytics tool (Mixpanel, Amplitude, Segment), not in HubSpot contact properties.

The Marketing-Centric Scoring Problem

HubSpot's default lead scoring templates optimize for traditional B2B sales motions:

• +10 points for opening a pricing page
• +5 points for email engagement
• +20 points if job title contains "Director" or "VP"
• +15 points for attending a webinar

None of these tell you whether someone is actually getting value from your product.

Real example from a B2B SaaS company we talked to: Their top-scoring lead (87 points) had downloaded three whitepapers, attended a webinar, and had the right job title. Sales called. The person had never logged into the product. Meanwhile, a user with 12 points (low email engagement, no downloads) was using the product every day, had invited four team members, and was hitting free plan limits. Sales found out about them three weeks later when the user upgraded themselves.

The cost of this blind spot: wasted sales cycles on "marketing-qualified" leads who ghost after a discovery call, while power users who are ready to buy get ignored.

What PLG Lead Scoring Actually Requires

PLG lead scoring needs to prioritize product behavior:

• Did they complete onboarding?
• Have they reached their "aha moment" (first meaningful outcome)?
• How frequently do they use core features?
• Are they inviting teammates or expanding usage?
• Are they hitting limits that signal upgrade readiness?

You still care about ICP fit (company size, industry, role), but product engagement is the primary signal. A daily active user at a small company is a hotter lead than a VP who signed up and never came back.

The challenge: getting product usage data into HubSpot where your scoring rules can use it.

The Technical Challenge: Getting Product Data Into HubSpot

Your product usage data lives in one of three places:

1. Your application database (PostgreSQL, MySQL, MongoDB)
2. Your product analytics tool (Mixpanel, Amplitude, PostHog, Heap)
3. Your customer data platform (Segment, RudderStack)

HubSpot doesn't have direct access to any of these. To score leads on product behavior, you need that data flowing into HubSpot contact and company properties.

The Data Warehouse + Reverse ETL Stack

The "correct" enterprise approach:

1. Set up a data warehouse (Snowflake, BigQuery, Redshift)
2. Pipe event data from your product and analytics tools into the warehouse (using Fivetran, Airbyte, or custom ETL)
3. Transform the raw events into aggregated metrics (dbt models: "days since last login", "feature X usage count", "activation completed")
4. Use a reverse ETL tool (Hightouch, Census) to sync the aggregated metrics from the warehouse to HubSpot custom properties
5. Set up HubSpot scoring rules on those synced properties

Timeline: 2-3 months to get production-ready data flowing.

Cost:

• Data warehouse: $200-$1,000/mo depending on scale
• Ingestion tools: $0-$500/mo (Segment starts at $120/mo, Fivetran starts at $360/mo)
• Reverse ETL: $350-$800/mo (Hightouch starts at $350/mo, Census similar)
• Engineering time: 80-120 hours setup, 10-20 hours/month ongoing maintenance
• Total first-year cost: $50K-$80K including eng time

This approach works. It's battle-tested at companies like Slack, Figma, and Notion. But it requires engineering resources and a data team.

Why This Blocks RevOps Teams

Most RevOps managers at $1M-$50M ARR companies don't have a data warehouse yet. They're running on HubSpot, Stripe, and their product database. They know they need PLG scoring, but they can't get engineering to prioritize a multi-month data infrastructure project.

The conversation goes:

• RevOps: "We need product usage in HubSpot so we can score PQLs and route to sales."
• Engineering: "That's on the roadmap for Q3. We need to set up the warehouse first, then build the data models, then the reverse ETL pipeline. Also we're two engineers down and shipping features."
• RevOps: "So… six months?"
• Engineering: "More like nine, realistically."

By the time the warehouse project ships, half your power users have churned or self-served into paid plans without sales ever talking to them.

The No-Code Alternative

A faster path for RevOps teams:

1. Track product events using an analytics SDK (Segment, Mixpanel, PostHog, or your own event tracking)
2. Sync those events directly to HubSpot using a tool built for this purpose (Zoody sends product events to HubSpot in real time, no warehouse)
3. Map events to HubSpot custom properties: "Completed onboarding" (boolean), "Logins last 7 days" (number), "Last feature X usage date" (date)
4. Build scoring rules in HubSpot on those properties

Setup time: 1-2 days to instrument events, 1 day to configure sync and scoring.

Tradeoff: You're not building a full data warehouse (you'll eventually want one as you scale), and you're limited to HubSpot as your destination. But for RevOps teams who need PLG scoring now, it unblocks you without waiting on engineering.

Zoody fits this use case—it receives events from Segment, your backend, or client-side tracking, then pushes them to HubSpot contact and company records in real time. You define which events matter for scoring, map them to properties, and build HubSpot scoring rules. No warehouse, no reverse ETL stack, no engineering dependencies beyond instrumenting the initial events.

Essential PLG Lead Scoring Criteria (What to Score On)

Once product data is flowing into HubSpot, you need a scoring framework. Don't score everything—pick 5-10 high-impact behaviors that correlate with conversion and expansion.

Activation & Onboarding Signals

Activation is the moment a user gets their first meaningful outcome from your product. For Slack, it's sending 2,000 team messages. For Dropbox, it's installing the desktop app and syncing a folder. For a dashboard tool, it's creating and sharing your first dashboard.

Score high on activation milestones:

• Completed onboarding tutorial: +15 points
• Reached "aha moment": +25 points (your product's specific activation metric)
• First meaningful action completed: +20 points (e.g., first API call, first report generated, first project created)
• Connected an integration or data source: +15 points (shows intent to embed your product in their workflow)

Create HubSpot boolean properties for each milestone:

• product_onboarding_completed (true/false)
• product_activated (true/false)
• product_integration_connected (true/false)

Then build scoring rules: "If product_activated is true, add 25 points."

Usage Patterns That Indicate Intent

Frequency and recency matter more than total lifetime usage. A user who logged in 100 times last year but hasn't been back in 60 days is cold. A user who logged in 10 times this week is hot.

Key usage metrics to score:

• Daily active user (last 7 days): +10 points per week of daily usage
• Weekly active user (last 30 days): +5 points per week
• Core feature usage in last 7 days: +15 points (define "core feature" as your product's main value prop)
• Session count last 30 days: +1 point per session, cap at 20 points
• Days since last login: Negative scoring: -5 points if >14 days, -10 points if >30 days

Create number and date properties:

• product_logins_last_7_days (number)
• product_sessions_last_30_days (number)
• product_last_login_date (date)
• product_core_feature_used_last_7_days (boolean)

HubSpot scoring rules: "If product_logins_last_7_days is greater than or equal to 5, add 10 points."

Expansion & Upgrade Readiness Signals

Users close to plan limits or exploring premium features are high-intent leads. These signals predict imminent upgrades.

Score these behaviors heavily:

• Invited team members: +10 points per invite, cap at 30 points
• Created multiple projects/workspaces: +5 points each, cap at 25 points
• Hit usage limit (API calls, storage, seats): +30 points
• Used a premium feature on free plan: +20 points (indicates they want it badly enough to explore locked features)
• Accessed billing or pricing page from product: +25 points
• Team size growth (week-over-week): +15 points

Create properties:

• product_team_members_invited (number)
• product_workspaces_created (number)
• product_hit_usage_limit (boolean)
• product_premium_feature_attempted (boolean)

Scoring rule example: "If product_hit_usage_limit is true, add 30 points."

These are your hottest leads. Route them to sales immediately when they cross a threshold.

Combining Product + Fit Scoring

Product engagement doesn't replace ICP fit—it complements it. The ideal lead is both a power user and a good fit.

Two-axis scoring:

• Engagement score (0-100): Product usage, activation, frequency
• Fit score (0-100): Company size, industry, role, tech stack

A user with 80 engagement + 60 fit is a better lead than 50 engagement + 90 fit. Prioritize users who are getting value, even if they're at smaller companies or less "ideal" industries. They'll convert faster and with less sales effort.

Build two separate HubSpot scores (Professional plan and above lets you create custom scores):

1. "Product Engagement Score" – Only product behavior
2. "ICP Fit Score" – Demographics, firmographics, technographics

Then create a combined view: High engagement + high fit = tier 1, high engagement + low fit = tier 2, etc.

How to Sync Product Events to HubSpot Without Code

You need product events in HubSpot before you can score them. Here's how to set up the sync without building infrastructure.

Choosing Your Product Events

Start small. Identify 5-10 product events that map to the scoring criteria above. Don't try to sync every event your product emits—just the ones that predict conversion.

Example event list for a project management SaaS:

1. user_signed_up
2. onboarding_completed
3. project_created
4. task_completed
5. team_member_invited
6. integration_connected
7. user_logged_in
8. premium_feature_attempted
9. usage_limit_hit
10. billing_page_viewed

For each event, note:

• Event name (standardize naming: lowercase, underscores)
• Frequency (one-time milestone or recurring action?)
• Associated properties (e.g., project_created might include project_type, is_public)
• Which HubSpot property it should update

If you're already tracking events in Segment, Mixpanel, or PostHog, you have these events. If not, add lightweight event tracking to your app using an SDK:

• Segment: analytics.track('project_created', { project_type: 'team' })
• Mixpanel: mixpanel.track('project_created', { project_type: 'team' })
• PostHog: posthog.capture('project_created', { project_type: 'team' })

Setting Up Real-Time Sync (Without Engineering)

Option 1: Zoody (purpose-built for HubSpot + product data)

Zoody receives product events and syncs them to HubSpot contact and company records in real time.

Setup steps:

1. Connect Zoody to HubSpot (OAuth, 2 clicks)
2. Send events to Zoody's API or connect Segment/Mixpanel as a source
3. Define property mappings: which events create/update which HubSpot properties
4. Zoody auto-creates custom properties on contacts and companies
5. Verify data flow in HubSpot contact records

Example: Send project_created events to Zoody. It increments a product_projects_created number property on the HubSpot contact, updates product_last_project_created_date, and sets product_has_created_project to true.

Timeline: 1-2 hours to connect and configure, events start flowing immediately.

Cost: Free sandbox (100 events/mo), $149/mo Pro (unlimited events).

Limitation: Only works with HubSpot. Doesn't replace your product analytics tool (you still need Mixpanel/Amplitude/PostHog for dashboards and analysis).

Option 2: HubSpot Operations Hub Professional custom code workflows

HubSpot Operations Hub (starts at $800/mo) includes custom code workflow actions. You can write a Node.js function that calls an external API to fetch product data and updates properties.

Setup:

1. Create a workflow triggered on contact create or daily schedule
2. Add a "Custom code" action (Node.js)
3. Write code to fetch user data from your API: const userData = await fetch('https://api.yourapp.com/users/' + email)
4. Parse the response and update HubSpot properties: outputFields.productLoginsLast7Days = userData.logins_count

Limitations:

• Workflow execution delays (minutes to hours, not real-time)
• API rate limits (you're calling your own API from HubSpot, which has execution time limits)
• Engineering required to build and maintain the API endpoint and workflow code
• High cost ($800/mo Operations Hub Pro + engineering time)

Best for companies already on Operations Hub who want to keep everything in HubSpot.

Option 3: iPaaS tools (Zapier, Make, Workato)

iPaaS tools can connect event sources (webhooks from Segment, Mixpanel) to HubSpot property updates.

Setup:

1. Create a webhook trigger in your iPaaS tool
2. Send product events to that webhook URL from Segment/Mixpanel/your backend
3. Map event data to HubSpot property updates via the iPaaS HubSpot integration

Limitations:

• High latency (30 seconds to several minutes between event and HubSpot update)
• Zapier task limits (free plan: 100 tasks/mo, paid starts at $20/mo for 750 tasks)
• Complex multi-step zaps required for aggregation (counting events, calculating recency)
• Not built for high-volume event syncing (gets expensive fast)

Works for low-volume use cases (a few hundred events/day). Not scalable for PLG products with thousands of active users.

Creating the Right HubSpot Properties

For each product behavior you're scoring, create a custom property on contacts and/or companies.

Property types:

• Boolean (checkbox): One-time milestones (activation completed, integration connected)
• Number: Counters (logins last 7 days, projects created, team size)
• Date: Recency tracking (last login date, last feature X usage)
• Single-line text: Categorical data (plan type, activation status)

Property naming convention: Prefix with product_ to keep them organized.

Example properties for PLG scoring:

• product_activated (boolean)
• product_onboarding_completed (boolean)
• product_logins_last_7_days (number)
• product_logins_last_30_days (number)
• product_last_login_date (date)
• product_projects_created (number)
• product_team_size (number)
• product_premium_feature_attempted (boolean)
• product_usage_limit_hit (boolean)

If you're using Zoody, it auto-creates these properties based on your event schema. If you're building custom sync logic, create them manually in HubSpot Settings > Properties.

For company-level scoring (important for team products), create the same properties on the Company object. Zoody and most sync tools can roll up contact-level events to company records (e.g., sum of all team member logins = company activity score).

Testing Your Data Flow

Before building scoring rules, verify data is flowing correctly:

1. Trigger a test event in your product (or staging environment). Example: Complete onboarding as a test user.
2. Check the HubSpot contact record for that user's email. Verify product_onboarding_completed is now true.
3. Trigger a recurring event (log in, create a project). Check that counters increment and dates update.
4. Test company rollups (if applicable). Invite a team member, trigger events as both users, check that the company record reflects combined activity.

Common issues:

• Wrong email identifier: Make sure the email in your product event matches the email in HubSpot exactly (case-sensitive, no leading/trailing spaces).
• Property not created: Check that custom properties exist before events start flowing.
• Delayed updates: If using workflows or iPaaS tools, expect minutes of lag. If using Zoody, updates happen in <1 second.

Once data is confirmed flowing, you're ready to build scoring rules.

Building Your PLG Lead Scoring Model in HubSpot

HubSpot Professional and above includes a native lead scoring tool. You'll use this to assign points based on the product properties now syncing into contact records.

Accessing HubSpot's Lead Scoring Tool

Navigate to Settings (gear icon) > Data Management > Predictive lead scoring or search "scoring" in the settings search bar.

HubSpot offers two scoring types:

1. Predictive lead scoring (Enterprise only): Machine learning model that analyzes historical data to predict close likelihood. Requires 12+ months of data and at least 150 closed deals.
2. Manual lead scoring (Professional+): You define the rules and point values. This is what you'll use for PLG scoring.

Click "Create score" > Choose "Manual lead scoring".

Name your score: "Product Engagement Score" or "PQL Score".

Configuring Product-Based Scoring Rules

Add scoring criteria by clicking "Add criteria". Each criterion is a condition: "If [property] [operator] [value], add [X] points."

Start with activation milestones:

Positive scoring rules:

• If product_onboarding_completed is true, add +15 points
• If product_activated is true, add +25 points
• If product_integration_connected is true, add +15 points

Add usage frequency rules:

• If product_logins_last_7_days is greater than or equal to 5, add +10 points
• If product_logins_last_30_days is greater than or equal to 15, add +10 points
• If product_projects_created is greater than or equal to 3, add +15 points
• If product_team_size is greater than or equal to 3, add +20 points (multi-user = expansion signal)

Add high-intent signals:

• If product_usage_limit_hit is true, add +30 points
• If product_premium_feature_attempted is true, add +20 points

Negative scoring (decay for inactivity):

• If product_last_login_date is older than 14 days ago, subtract -5 points
• If product_last_login_date is older than 30 days ago, subtract -10 points
• If product_last_login_date is older than 60 days ago, subtract -20 points

HubSpot recalculates scores automatically when property values change (in real time with live data sync).

Sample PLG Scoring Framework

Here's a full scoring model for a B2B SaaS collaboration tool:

Criteria	Points	Rationale
Onboarding completed	+15	Basic setup, shows commitment
Activated (first project created + shared)	+25	Core value achieved
Integration connected (Slack, GitHub, etc.)	+15	Workflow integration = stickiness
5+ logins last 7 days	+10	Daily active user
15+ logins last 30 days	+10	Consistent engagement
3+ projects created	+15	Power user
3+ team members invited	+20	Expansion signal
Premium feature attempted	+20	Clear upgrade intent
Hit usage limit	+30	Ready to buy
Last login 14-30 days ago	-5	Cooling off
Last login 30-60 days ago	-10	At-risk
Last login 60+ days ago	-20	Likely churned

Maximum possible score: 135 points (if they hit all positive criteria).

Most users will score 0-100. Top 10% will be 60+.

Setting Thresholds & Sales Handoff Triggers

Define score bands that map to sales actions:

• 0-30 points (Cold): Marketing nurture only, no sales outreach
• 31-60 points (Warm): Sales Development Rep (SDR) outreach, soft touch
• 61-100 points (Hot): Account Executive (AE) outreach, schedule demo
• 101+ points (Urgent): Immediate AE outreach, likely to convert in days

Create HubSpot workflows to route leads automatically:

Workflow 1: Hot PQL handoff

• Trigger: "Product Engagement Score" changes to greater than or equal to 61
• Action: Create task for AE ("High-engagement PQL ready for outreach")
• Action: Send internal Slack notification to sales channel
• Action: Update lifecycle stage to "Product Qualified Lead"

Workflow 2: Urgent upgrade-ready handoff

• Trigger: product_usage_limit_hit is true OR product_premium_feature_attempted is true
• Condition: "Product Engagement Score" greater than 50
• Action: Create high-priority task for AE ("User hit limit, ready to upgrade")
• Action: Send personalized email from AE with upgrade link

These workflows ensure sales reaches out within hours of a user hitting high-intent signals, not weeks later.

Advanced PLG Scoring Strategies

Once your basic scoring model is running, layer in advanced strategies to improve accuracy.

Engagement vs. Fit: Two-Axis Scoring

Create two separate scores:

Product Engagement Score (0-100):

• Only product usage behaviors
• Activation, frequency, feature adoption, expansion signals
• No demographic or firmographic data

ICP Fit Score (0-100):

• Company size (20+ employees: +25 points, 100+: +40 points)
• Industry (target verticals: +20 points each)
• Role/title (RevOps, Head of Growth, etc.: +15 points)
• Tech stack (uses HubSpot: +10 points, uses Salesforce: -10 points)

Plot leads on a 2x2 matrix:

• High engagement, high fit: Tier 1 PQLs, top priority
• High engagement, low fit: Tier 2 PQLs, still valuable (small companies become big companies)
• Low engagement, high fit: Traditional MQLs, nurture with product education
• Low engagement, low fit: Cold, marketing automation only

This prevents two failure modes:

1. Ignoring power users at "wrong" company sizes
2. Wasting sales time on perfect-fit companies whose users barely use the product

Company-Level Scoring for Team Products

If you sell to teams (Slack, Notion, Figma), individual user scores don't tell the full story. You need company-level scoring.

Aggregate contact scores to company records:

Create company properties:

• product_total_team_logins_last_7_days (sum of all contact logins)
• product_active_users_last_30_days (count of contacts with login in last 30 days)
• product_total_projects_created (sum across all team members)
• product_workspace_count (number of shared workspaces)

Score companies on:

• Team activation: 50%+ of invited users logged in last 30 days (+25 points)
• Cross-functional usage: 3+ departments using the product (+20 points)
• Collaborative activity: 10+ shared projects or docs (+15 points)
• Team growth week-over-week: +1 active user per week (+10 points)
• Company hit limit: Any user on the team hit usage limit (+30 points)

Company scoring is especially important for sales handoff in PLG. The best time to reach out is when the team is actively collaborating and one user hits a limit—the team is bought in, and there's urgency.

Incorporating Time-Based Decay

Scores should decay over time to reflect disengagement. A user who was a power user 6 months ago but hasn't logged in since is not a hot lead.

HubSpot doesn't have native time-decay scoring, but you can simulate it with workflows:

Workflow: Weekly score decay for inactive users

• Trigger: Scheduled to run weekly
• Condition: product_last_login_date is older than 14 days ago AND "Product Engagement Score" is greater than 20
• Action: Decrease "Product Engagement Score" by 5 points

Run this weekly. Users who stop logging in will gradually lose score points.

Alternatively, use negative scoring rules (as shown earlier): static deductions based on product_last_login_date age. HubSpot recalculates automatically.

For more sophisticated decay (exponential decay, half-life scoring), you need external calculation (data warehouse + reverse ETL or custom code workflows in Operations Hub).

Real-World PLG Lead Scoring Examples

Example 1: Collaboration SaaS Scoring Model

Product: Team workspace tool (similar to Notion, Coda, Airtable).

Core activation: Create a workspace + invite 2+ team members.

Scoring criteria:

• Created workspace: +15
• Invited 1 team member: +10
• Invited 2+ team members: +20
• Created 3+ pages/docs: +15
• Used template gallery: +10
• Connected integration (Slack, Google Drive): +15
• 5+ logins last 7 days: +10
• 10+ collaborative edits (multiple users editing same doc): +20
• Hit page limit on free plan: +30
• Shared workspace externally (client/partner): +25

Thresholds:

• 60+ points: SDR outreach ("We see your team is collaborating in [Product]. Want to unlock [premium feature]?")
• 80+ points + hit limit: AE immediate outreach with upgrade offer

Result: 35% of leads scoring 80+ convert to paid within 7 days (vs. 8% baseline conversion rate).

Example 2: Developer Platform Scoring

Product: API-first developer tool (similar to Stripe, Twilio, Auth0).

Core activation: Make 10 successful API calls in production.

Scoring criteria:

• Signed up: +5
• Generated API key: +10
• Made first API call (test mode): +15
• Made 10+ API calls (test mode): +10
• Deployed to production: +25
• 100+ API calls (production): +20
• 1,000+ API calls (production): +30
• Read advanced docs (webhooks, rate limits): +15
• Hit rate limit: +30
• Used premium endpoint (production): +25

Thresholds:

• 70+ points: SDR outreach to discuss scale needs
• Hit rate limit OR 1,000+ calls: AE outreach with custom pricing

Result: 50% of developers scoring 70+ with production usage convert to paid plans. 80% of developers who hit rate limits convert immediately when contacted within 24 hours.

Example 3: Analytics Tool Scoring

Product: Business intelligence dashboard tool (similar to Looker, Metabase, Mode).

Core activation: Connect data source + create dashboard + share with team.

Scoring criteria:

• Connected data source (SQL, API, CSV): +20
• Created first dashboard: +15
• Added 5+ visualizations: +10
• Shared dashboard with team: +20
• Scheduled report: +15
• 3+ users viewing dashboards weekly: +25
• Exported data or dashboard: +10
• Used SQL editor (advanced): +20
• Hit data row limit: +30
• Embedded dashboard in external app: +25

Thresholds:

• 65+ points: SDR outreach about data needs
• Hit limit OR embedded dashboard: AE outreach, high likelihood of enterprise sale

Result: Users who share dashboards and hit limits convert at 60% (vs. 12% overall trial-to-paid rate). Time to conversion drops from 45 days (average trial) to 8 days when sales reaches out at high-score threshold.

Measuring & Optimizing Your PLG Lead Scoring Model

Lead scoring is not set-it-and-forget-it. You need to measure effectiveness and iterate.

Essential Metrics to Monitor

Track these in HubSpot reports (Reporting > Analytics Tools > Custom Report):

Score distribution:

• How many contacts in each score band (0-30, 31-60, 61-100)?
• Is the distribution skewed (most at 0, few at high scores)? If so, scoring might be too strict.

Conversion rate by score band:

• What % of 0-30 score contacts convert to paid? (Should be low, <5%)
• What % of 31-60 score contacts convert? (Target: 10-20%)
• What % of 61-100 score contacts convert? (Target: 30-50%+)
• If high-score bands aren't converting significantly better than low-score bands, your scoring model isn't predictive.

Time to conversion by score band:

• How many days from reaching high score to closing? (Target: <14 days for 61-100 band)
• If high-score leads take 60+ days to close, they're not as "hot" as your scoring suggests.

Sales feedback (qualitative):

• Are sales reps complaining that high-score leads aren't responsive?
• Are they finding hot leads that scored low?
• Survey your AE team monthly: "Are the PQLs we're routing actually high-quality?"

Validating Scoring Accuracy

Run a cohort analysis every quarter:

1. Pull all contacts who reached 61+ score in the last 90 days
2. Check how many converted to paid (HubSpot deal closed-won)
3. Calculate conversion rate: Closed-won / Total high-score leads
4. Compare to baseline: Overall trial-to-paid conversion rate

If your high-score conversion rate isn't at least 2-3x your baseline, your scoring model needs work.

Red flags:

• High-score leads ghosting sales outreach (score is inflated, not reflecting true intent)
• Low-score leads converting at high rates (you're missing important signals)
• No correlation between score and revenue (scoring criteria don't predict outcomes)

Iterating Based on Data

Adjust scoring weights based on what actually predicts conversion:

Analyze closed-won deals:

1. Pull all closed-won customers from the last 6 months
2. Look at their product usage properties at time of conversion
3. Which behaviors were most common? (e.g., 90% had invited 3+ team members, 80% had hit usage limits)
4. Increase point values for those high-correlation behaviors

Remove or reduce low-impact criteria:

• If "used template gallery" appears in only 20% of closed-won deals, remove it from scoring or reduce points.
• If "logins last 30 days" has no correlation with conversion, it's noise—drop it.

Test threshold changes:

• Experiment with lowering the sales handoff threshold (from 61 to 51) and measure impact on conversion rate and sales efficiency.
• If lowering the threshold increases volume but tanks conversion rate, revert.

A/B test scoring models:

• Run two scoring models in parallel for 30 days (split your contact database randomly).
• Model A: Current scoring rules.
• Model B: Adjusted weights based on closed-won analysis.
• Compare conversion rates, sales feedback, and time-to-close.
• Roll out the winning model.

Iterate quarterly. As your product evolves, your activation definition will change, and scoring should reflect that.

Common Mistakes to Avoid

Over-complicating the model: New RevOps teams often start with 30+ scoring rules across 15 product behaviors. Result: the model is fragile, hard to maintain, and no more accurate than a simple 5-rule model. Start with 5-10 high-impact criteria. Add more only if conversion analysis proves they matter.

Scoring on vanity metrics: Page views, time on site, email opens sound good but don't predict revenue. Focus on product actions that reflect value delivered. A user who viewed 50 pages but never created a project is not a PQL.

Ignoring data quality: If 40% of your contacts have missing or stale product data, scoring is garbage-in-garbage-out. Audit your data sync pipeline weekly. Check for: contacts with no product_last_login_date (sync broken?), properties stuck at old values (stale data?), events not flowing (API down?).

Set-it-and-forget-it: Your product evolves, your ICP evolves, your pricing evolves. Scoring rules from 6 months ago might not reflect today's reality. Schedule quarterly scoring audits. Review conversion data, talk to sales, adjust weights.

Not aligning with sales: RevOps builds a scoring model in a vacuum, hands it to sales, and wonders why reps ignore it. Involve your AE team in defining "hot lead" criteria. Ask them: "What product behaviors make you excited to call a lead?" Build scoring around those signals, not theoretical best practices.

Routing too early: Just because a user scored 61 points doesn't mean they want to talk to sales today. Layer in intent signals: Did they view pricing? Did they hit a limit? Did they ask a question in support chat? Combine high score + high intent before routing to AE.

Not measuring success: If you're not tracking conversion rate by score band, you're flying blind. HubSpot gives you the reporting tools—use them. If your scoring model isn't improving conversion rates or sales efficiency, it's not working.

FAQ

How do I set up lead scoring in HubSpot?

Go to Settings > Data Management > Predictive lead scoring (Professional plan and above). Click "Create score" and choose "Manual lead scoring". Add criteria: "If [property] [operator] [value], add [X] points." For PLG scoring, base criteria on product usage properties synced from your product (logins, activation milestones, feature usage). Define thresholds (e.g., 61+ points = hot lead) and create workflows to route high-scoring contacts to sales automatically.

How to automate lead scoring?

HubSpot recalculates scores automatically whenever property values change. If you sync product events in real time (using Zoody or similar), scores update instantly as users engage with your product. Then create workflows triggered by score thresholds: "When Product Engagement Score reaches 61+, create task for AE" or "When score reaches 80+ AND usage limit hit, send alert to sales Slack channel." This removes manual lead review—sales gets notified the moment a lead becomes hot.

How to build lead scoring?

Start by identifying 5-10 product behaviors that correlate with conversion (activation milestones, feature usage, team invites, hitting limits). Sync those behaviors into HubSpot custom properties (boolean, number, date fields). In HubSpot's lead scoring tool, create rules: add points for positive signals (activated: +25, daily usage: +10), subtract points for inactivity (no login in 30 days: -10). Set thresholds (60+ = hot lead) and build workflows to route high-scoring leads to sales. Test for 30 days, measure conversion rate by score band, and adjust weights based on data.

Can you do product-led growth lead scoring without a data warehouse?

Yes. Use a tool like Zoody that syncs product events directly to HubSpot in real time, no warehouse required. You track events in your product (user activated, login, feature used), send them to Zoody's API, and Zoody pushes them to HubSpot contact properties. Then build scoring rules in HubSpot on those properties. This skips the data warehouse + reverse ETL stack, which costs $50K+ and takes 2-3 months to set up. Tradeoff: you're limited to HubSpot as a destination, but for RevOps teams who just need PLG scoring, it's faster and doesn't require engineering resources.

What product events should I use for PLG lead scoring?

Focus on activation (onboarding completed, first core action taken), usage frequency (logins last 7 days, feature usage count), and expansion signals (team members invited, hit usage limit, attempted premium feature). Specific examples: For a collaboration tool, score on "created workspace", "invited 3+ users", "5+ logins last week", "hit storage limit". For a developer tool, score on "made first API call", "deployed to production", "1,000+ API calls", "hit rate limit". Start with 5-10 high-impact events that map to your product's activation and upgrade triggers. Don't score every event—just the ones that predict conversion.