Build a PQL Scoring Model in HubSpot Workflows (2025 Guide)

Quick answer: Build a PQL scoring model in HubSpot by syncing product usage events to custom properties, then creating workflows that increment a PQL score based on activation milestones, feature adoption, and team expansion signals.

• Sync product data to HubSpot - Use Zoody, reverse ETL, or custom API integration to push usage events as contact/company properties
• Define scoring criteria - Assign point values to activation events (20 pts), power usage (30 pts), team expansion (40 pts)
• Build scoring workflows - Enroll contacts when usage properties change, increment score with workflow actions
• Set PQL thresholds - Typically 60-80 points triggers sales handoff, adjust based on your conversion data
• Add score decay - Re-enroll workflows to deduct points for 7+ days of inactivity

What is PQL Scoring and Why It Matters for Product-Led Growth

Product Qualified Leads (PQLs) are users who have demonstrated buying intent through meaningful product usage, not just form fills or demographic fit. A PQL has experienced your product's value firsthand - they've hit activation milestones, adopted core features, or started bringing their team onto the platform.

Traditional lead scoring in HubSpot focuses on demographic data (job title, company size, industry) and engagement signals (email opens, website visits, content downloads). These MQL models predict interest, but not readiness to buy. For SaaS companies, especially product-led growth (PLG) businesses offering free trials or freemium tiers, product usage data is 3-5x more predictive of conversion than demographic scoring alone.

The numbers back this up. OpenView's 2024 PLG Benchmarks report shows PQL-to-customer conversion rates of 25-40% for well-tuned models, compared to 5-15% for traditional MQLs. Users who have already experienced your product's core value are fundamentally different prospects than cold leads who downloaded a whitepaper.

PQL vs MQL: Understanding the Difference

An MQL (Marketing Qualified Lead) downloaded your pricing guide, attended a webinar, and has a VP title at a 500-person company. They fit your ICP and they're engaged with your content. But have they used your product? Do they understand what it does? Have they experienced the aha moment that makes customers stick?

A PQL created a project in your app, connected their data source, built three dashboards, and invited two teammates. They've experienced the value. They've invested time. They're seeing results. This person is objectively more ready to buy than the VP who downloaded a PDF.

For RevOps teams running HubSpot, the challenge isn't philosophical - it's practical. How do you get product usage data into HubSpot contact records so you can score and route these high-intent users?

Why Traditional Lead Scoring Falls Short for SaaS Companies

HubSpot's native predictive lead scoring relies on historical deal data to identify patterns in demographic and engagement properties. It works well for traditional B2B sales motions where buying committees research for months before requesting a demo.

It breaks down for PLG companies where:

• Users sign up with personal emails, not company domains
• Job titles don't predict usage patterns (an engineer might be the economic buyer)
• The buying process starts inside the product, not on marketing pages
• Free users convert based on usage intensity, not content engagement
• Team expansion (inviting colleagues) is a stronger signal than downloading an ebook

You need a scoring model built on what users actually do in your product, not what they do on your website.

Key Product Usage Signals That Define High-Quality PQLs

Not all product usage is equal. A user who logged in once and clicked around is different from a user who completed your onboarding flow, adopted three core features, and started inviting teammates.

The best PQL scoring models combine breadth (how many features), depth (how intensely they use core features), and expansion (how many teammates they bring).

Activation Events and Aha Moments

Every SaaS product has an activation milestone - the moment when a user experiences the core value and is likely to stick around. For Slack, it's sending 2,000 messages. For Dropbox, it's adding a file to a synced folder on one device and seeing it appear on another.

Your activation event might be:

• Creating their first project or workspace
• Connecting a data source or integration
• Publishing their first report or dashboard
• Completing onboarding setup
• Inviting their first teammate

In HubSpot, track activation as a boolean property (has_activated) and a timestamp (activation_date). Score 20-30 points when a contact hits activation. This is your strongest early signal.

For Zoody, activation happens when a user successfully syncs their first product event to HubSpot and sees it appear on a contact record. That's the aha moment where they realize they can route product data without building a reverse ETL pipeline.

Frequency vs. Depth: Which Usage Metrics Matter Most

Raw login counts don't predict conversion well. A user who logs in daily but only views their dashboard is less qualified than a user who logs in twice a week but runs reports, exports data, and updates settings.

Track both frequency and depth:

Frequency metrics:

• Days active in the last 7/14/30 days (days_active_l7d, days_active_l30d)
• Session count this week (sessions_this_week)
• Last activity date (last_product_activity)

Depth metrics:

• Core feature usage count (e.g., reports_created, api_calls_made, files_uploaded)
• Advanced feature adoption (used_advanced_filters, connected_integration, used_api)
• Time in product per session (avg_session_duration)

Score depth higher than frequency. A user who ran 10 reports this month is more qualified than a user who logged in 20 times but didn't do anything.

Team Expansion as a Buying Signal

Individual users trial products. Teams buy products. When a free user invites colleagues, they're signaling two things: they find enough value to share it, and they're likely moving toward a paid plan (most SaaS pricing scales with seats).

Track:

• Teammates invited (teammates_invited_count)
• Seats occupied (active_seats)
• Team created (has_team)
• Admin role assigned to multiple users (admin_count)

Score team expansion heavily - 30-50 points when a user invites their first teammate. This is often the clearest buying signal in a freemium model.

The Missing Link: Getting Product Usage Data Into HubSpot

You can't score PQLs in HubSpot if product usage data lives in your analytics tool (Mixpanel, Amplitude, PostHog) or your application database. HubSpot doesn't natively connect to these systems. This is the gap that kills most PQL scoring projects.

Why Most Companies Struggle to Connect Product Data to HubSpot

The standard approach requires a data warehouse (Snowflake, BigQuery, Redshift) sitting between your product and HubSpot. Product events flow to the warehouse via your analytics SDK, then a reverse ETL tool (Hightouch, Census, or a custom-built script) syncs computed properties to HubSpot.

This works, but the setup cost is high:

• Data warehouse: $200-$2,000/mo depending on scale
• Reverse ETL tool: $350-$800/mo (Hightouch starts at $350, Census at $500)
• Engineering time to configure pipelines, write SQL transforms, map fields
• Ongoing maintenance when event schemas change

For early-stage SaaS companies ($1M-$10M ARR), this stack is overkill. You need product data in HubSpot, but you don't need a full data warehouse just to score PQLs.

The second challenge: latency. Reverse ETL syncs run on schedules (hourly, daily). A user hits activation at 2pm, but HubSpot doesn't know until the 6pm sync runs. By the time sales gets the lead, it's 4 hours cold.

Real-Time Product Data Sync: The Zoody Solution

Zoody syncs product events directly to HubSpot in real time, no warehouse required. You track events in your product (using Segment, RudderStack, PostHog, or custom event tracking), and Zoody pushes them to HubSpot contact and company properties immediately.

Setup takes 20 minutes:

1. Connect Zoody to your HubSpot account (OAuth integration)
2. Define which events and properties to sync (report_created, days_active_l7d, teammates_invited_count)
3. Map them to HubSpot contact or company properties
4. Events start flowing

When a user invites a teammate, HubSpot knows within seconds. Your PQL scoring workflow can fire immediately. Sales gets the lead while they're still active in the product.

Zoody works only with HubSpot (if you run Salesforce, you need a different solution). It doesn't replace your product analytics tool - you still need Mixpanel/Amplitude/PostHog for detailed behavioral analysis. But if your CRM is HubSpot and you need product data on contact records for scoring and routing, it's the fastest path.

Flat pricing: $149/mo Pro, $249/mo Growth. No per-user fees, no sync limits, no warehouse costs.

Setting Up Product Event Tracking for HubSpot

Before you can score PQLs in HubSpot, you need to decide which events and properties to track. Start with 5-10 signals, not 50. You can always add more later.

Must-track events:

• User activated (boolean + timestamp)
• Core feature used (count or timestamp of last use)
• Teammate invited (count)
• Last product activity (timestamp)

Good-to-track properties:

• Days active in last 30 days (number)
• Key feature adoption flags (booleans)
• Account health score (number, if you compute it in your product)

Map these to HubSpot contact properties if you score individual users, or company properties if you score accounts. For PLG companies with self-serve sign-ups, contact-level scoring is more common. For enterprise sales motions, score at the company level.

In Zoody, you define this mapping in the web app. In a reverse ETL setup, you write SQL queries to compute these properties from event tables, then map them in Hightouch/Census.

Step-by-Step: Building Your PQL Scoring Model in HubSpot Workflows

Once product data flows into HubSpot, you build scoring workflows that increment a pql_score property based on usage signals.

Creating Custom PQL Score Properties

Go to Settings > Properties > Create property. You need:

1. PQL Score (pql_score)

   • Type: Number
   • Object: Contact (or Company if scoring accounts)
   • Default value: 0
   • Description: "Product usage-based lead score. 60+ = sales-ready PQL."

2. PQL Tier (pql_tier)

   • Type: Dropdown select
   • Options: Cold (0-29), Warm (30-59), Hot (60-79), Sales-Ready (80+)
   • Automatically set by workflow based on score ranges

3. Last Score Update (last_pql_score_update)

   • Type: Date picker
   • Auto-set to current date when score changes (useful for debugging)

Don't use HubSpot's built-in HubSpot Score property for PQLs. Create a separate property so you can run product-based scoring alongside traditional lead scoring if needed.

Workflow Setup: Enrollment Triggers and Scoring Actions

Create a new contact-based workflow: "PQL Score - Increment." This workflow enrolls contacts when product usage properties change and increments their score.

Enrollment triggers (OR logic):

• has_activated is equal to true (re-enrollment off - score this once)
• teammates_invited_count increases (re-enrollment on)
• reports_created increases (re-enrollment on)
• integrations_connected increases (re-enrollment on)
• days_active_l30d increases (re-enrollment on)

For each trigger, add workflow actions that increment the score:

If has_activated is true:

• Set pql_score to: {{pql_score}} + 20

If teammates_invited_count increased:

• Set pql_score to: {{pql_score}} + 40

If reports_created increased by 5+:

• Set pql_score to: {{pql_score}} + 30

If integrations_connected increased:

• Set pql_score to: {{pql_score}} + 25

If days_active_l30d is 15+:

• Set pql_score to: {{pql_score}} + 20 (only score once - use "Has not completed this workflow" as a goal)

Use branch logic (if/then branch) to handle different score increments based on the trigger. HubSpot workflows don't natively support dynamic math based on "how much" a property increased, so you may need multiple branches (e.g., "If teammates_invited_count is 1" = +30, "If teammates_invited_count is 3+" = +50).

After score actions, set last_pql_score_update to the current date and update pql_tier using a series of if/then branches based on score ranges.

Implementing Score Decay for Inactive Users

Users who stop using your product are less qualified. Implement score decay to deduct points for inactivity.

Create a second workflow: "PQL Score - Decay."

Enrollment trigger:

• last_product_activity is more than 7 days ago
• Re-enrollment: Every 7 days (so score decays weekly while inactive)

Workflow action:

• Set pql_score to: {{pql_score}} - 10
• Set minimum to 0 (don't go negative)

This keeps your PQL scores fresh. A user who was hot 3 months ago but hasn't logged in since shouldn't still have an 80 score.

Alternative approach: use time-based branches. Instead of a static score, weight recent activity higher. If days_since_last_activity is less than 7, apply full score. If 7-14 days, apply 50% of score. If 14+ days, apply 0. This requires more complex workflow logic but gives you finer control.

Building PQL Segments and Lists

Once scores are flowing, create active lists to segment PQLs:

Sales-Ready PQLs:

• pql_score is greater than or equal to 80
• last_product_activity is less than 7 days ago (still active)
• lifecycle_stage is not customer (don't route existing customers)

Warm PQLs:

• pql_score is between 60 and 79
• has_activated is true

At-Risk PQLs:

• pql_score was greater than 60 (use "Has ever been" filter)
• last_product_activity is more than 14 days ago
• Route these to re-engagement campaigns, not sales

Use these lists to trigger sales tasks, send targeted email sequences, or fire Slack notifications to account owners.

Real PQL Scoring Examples from SaaS Companies

Here are three real-world PQL models adjusted for different product types. Point values are guidelines - tune based on your own conversion data.

Example 1: Project Management SaaS PQL Model

Product: Team collaboration tool with free plan (up to 5 users), $10/user/mo paid plan unlocks advanced features, integrations, and unlimited projects.

Activation event: Created first project and invited at least one task assignee.

Scoring framework:

Signal	Points	Notes
Account created	0	Baseline, no score
Activated (first project + task assigned)	25	Core aha moment
Created 3+ projects	20	Multi-project usage = team need
Invited 2+ teammates	40	Team expansion, likely to convert
Invited 5+ teammates	60	Hit free plan limit, conversion imminent
Used integration (Slack, Google Drive, etc.)	30	Workflow integration = stickiness
Active 15+ days in last 30	25	High engagement frequency
Created 20+ tasks	15	Depth of use
Used advanced filter or automation (paid feature)	35	Tried paid feature, likely to convert
Inactivity (7+ days)	-10/week	Score decay

PQL threshold: 80 points. Typical path: Activate (25) + invite 2 teammates (40) + use integration (30) = 95 points, route to sales.

Sales handoff: When contact hits 80 points, create task for SDR: "PQL handoff - [Contact Name] at [Company] activated, invited team, and connected Slack. Offer demo of advanced automation features."

Example 2: Analytics Platform PQL Scoring

Product: Data visualization and reporting SaaS. Free tier allows 1 data source and 3 dashboards. Paid plans ($49-$299/mo) unlock unlimited data sources, scheduled reports, API access, and team sharing.

Activation event: Connected first data source and created first dashboard with at least 3 visualizations.

Scoring framework:

Signal	Points	Notes
Connected first data source	30	Activation milestone
Created first dashboard	20	Value realization
Created 3+ dashboards	25	Power user behavior
Connected 2+ data sources	40	Hit free tier limit
Shared dashboard with teammate	35	Team collaboration signal
Scheduled report (paid feature)	45	Tried paid feature
Used API (paid feature)	50	Technical user, likely to pay
Exported data 5+ times	20	Workflow integration
Active 20+ days in last 30	30	High engagement
Built custom SQL query	25	Advanced use case
Inactivity (10+ days)	-15/week	Faster decay for analytics tools

PQL threshold: 75 points. Typical path: Connect data source (30) + create 3 dashboards (45) + share with teammate (35) = 110 points, hot PQL.

Sales motion: When contact hits 75 points and has connected 2 data sources or tried a paid feature, route to AE with context: "This user is pushing free tier limits. Offer Pro plan with custom demo showing unlimited data sources and scheduled reports."

Example 3: Collaboration Tool PQL Framework

Product: Async video messaging and screen recording tool. Free plan allows 25 videos/month. Paid plan ($15/user/mo) is unlimited videos, longer recordings, and team workspaces.

Activation event: Recorded and shared first video with at least one recipient.

Scoring framework:

Signal	Points	Notes
Recorded first video	25	Activation
Shared video with 3+ people	20	Multi-recipient use = team value
Recorded 10+ videos	30	Hit free tier limit approaching
Recorded 20+ videos (limit hit)	50	Need paid plan
Created team workspace	60	Enterprise buying signal
Invited 3+ teammates to workspace	40	Team adoption
Video avg view rate >60%	25	High-quality content, recipients engaged
Used branded landing page (paid feature)	35	Tried paid feature
Active 12+ days in last 30	20	Regular use
Inactivity (14+ days)	-10/week	Slower decay, async tools have sporadic use

PQL threshold: 70 points. Typical path: Activate (25) + record 20 videos (80 cumulative) + create workspace (60) = 165, enterprise PQL.

Segmentation: Split PQLs into "Individual" (no workspace, <3 teammates) and "Team" (workspace created or 3+ teammates). Route individual PQLs to self-serve conversion email sequence. Route team PQLs to sales for custom pricing discussion.

Optimizing and Testing Your PQL Scoring Model

Your first PQL model won't be perfect. Plan to iterate based on conversion data.

Measuring PQL Model Effectiveness

Track these metrics in HubSpot reports:

PQL volume and conversion:

• Contacts entering "Sales-Ready PQL" list per week
• PQL-to-opportunity conversion rate (what % of 80+ score contacts become deals?)
• PQL-to-customer conversion rate (closed-won deals from PQLs)
• Time from PQL threshold to deal created (speed matters - hot leads go cold)

Scoring calibration:

• Distribution of scores (are 90% of contacts in the 0-20 range? Adjust thresholds.)
• Average score at deal close (if most closed-won deals were 60-point PQLs, your 80-point threshold is too high)
• False positive rate (how many 80+ PQLs don't convert? If it's >80%, tighten criteria.)

Create a dashboard showing:

• Active PQL count by tier (Cold, Warm, Hot, Sales-Ready)
• PQL conversion funnel (PQL > Opportunity > Closed-Won)
• Average score by lifecycle stage (Subscriber, Lead, MQL, Opportunity, Customer)
• Top signals contributing to high scores (which events correlate with conversion?)

Run this analysis monthly. If you see that 90% of closed-won customers had used_integration set to true, increase the point value for that signal.

Sales and RevOps Alignment on PQL Handoffs

PQL scoring fails when sales and RevOps aren't aligned on what a "sales-ready" lead looks like.

Run a calibration session every quarter:

1. Pull a sample of 20 recent "Sales-Ready PQLs" (80+ score)
2. Ask sales: "Would you have wanted this lead routed to you?" for each one
3. Look for patterns in false positives (high score, but not actually qualified)
4. Adjust scoring criteria based on feedback

Common misalignments:

• RevOps scores individual users, sales wants team decision-makers. Solution: Add a branch in your routing workflow that only creates tasks for PQLs with job_title containing "Manager", "Director", "VP", or "Head of".
• Sales complains leads are cold by the time they get them. Solution: Reduce handoff threshold or add real-time Slack notifications when PQLs hit thresholds.
• Sales says "these users are active but not ready to buy." Solution: Increase point values for buying signals (team expansion, paid feature trials) and decrease points for generic usage (logins, views).

Document your PQL definition in a shared doc. Example: "A Sales-Ready PQL is a contact with 80+ points who has (1) activated, (2) invited at least one teammate OR connected an integration, and (3) been active in the last 7 days. We route to sales within 2 hours of hitting 80 points."

Common PQL Scoring Mistakes to Avoid

Over-scoring activation. Don't give 50 points just for signing up and logging in. Activation should be meaningful (completed onboarding, used core feature, experienced value).

Ignoring negative signals. If a user churned off a paid plan back to free, deduct points. If they haven't logged in for 30 days, their score should decay to near-zero. Stale scores create false positives.

Not updating the model. Your product changes. You add features. You change your free tier limits. Your PQL model should change too. Review quarterly.

Scoring demographics, not behavior. Don't add points for company_size > 100 or job_title = VP. That's traditional lead scoring. PQL scoring is purely product usage. (You can layer demographic scoring on top later in a multi-dimensional model - see Advanced Tactics below.)

Setting thresholds without data. Don't pick 80 points because it sounds right. Look at your closed-won deals. What was their average score when they converted? Set your threshold 10-20% below that to catch leads earlier.

Scoring one-time events repeatedly. If a user activates, they should get points once. Don't re-enroll them every time has_activated is true. Use "Has not completed this workflow" as a suppression goal.

Advanced PQL Scoring Tactics for HubSpot Power Users

Once your basic PQL model is running, add these layers for more precision.

Combining Product Usage with Firmographic Scoring

Pure PQL scoring is product-usage-only. But in reality, a highly engaged user at a 5-person startup is different from a highly engaged user at a 5,000-person enterprise.

Build a multi-dimensional score that combines:

• Product score (0-100): Usage-based PQL score as described above
• Fit score (0-100): Traditional demographic scoring (company size, industry, job title)
• Engagement score (0-100): Marketing engagement (email opens, webinar attendance, content downloads)

Total score = weighted average. For PLG companies, weight product highest:

• Product: 60%
• Fit: 25%
• Engagement: 15%

Create three separate score properties (product_score, fit_score, engagement_score) and a calculation property total_pql_score that computes the weighted average.

Route leads to sales when total_pql_score > 70 AND product_score > 60. This filters out low-usage, high-fit leads (not ready) and high-usage, bad-fit leads (unlikely to close).

Account-Level PQL Scoring for Enterprise Sales

If you sell to teams with multiple users (e.g., 10 people at a company all have free accounts), scoring individual contacts doesn't capture the full picture. Score at the company level instead.

Sync product events to company properties, not contact properties:

• company_total_activated_users
• company_total_seats_occupied
• company_days_active_l30d (distinct users active in last 30 days)
• company_total_projects_created

Build a company-based scoring workflow that increments company_pql_score when these roll-up properties change.

Account-level signals to score highly:

• 5+ users activated (+50 points)
• 10+ users in workspace (+80 points)
• Multi-department usage (users from Engineering + Marketing + Sales using the tool) (+60 points)
• Admin role assigned (+30 points, someone is taking ownership)

Route accounts, not contacts, to sales. Create a task on the account owner when company_pql_score > 100 with context: "This account has 8 activated users across 3 departments. Reach out to [primary contact name] to discuss team plan."

Automated PQL Alerts and Sales Handoffs

Don't make sales dig through lists. Push PQLs to them in real time.

Slack notifications: Use a webhook workflow action (native HubSpot or via Zapier) to post to a #pql-alerts Slack channel when a contact hits 80 points. Include:

• Contact name, email, company
• Current PQL score and tier
• Key signals triggered (e.g., "Invited 3 teammates, connected Slack integration")
• Link to HubSpot contact record

Auto-create sales tasks: When a contact enters your "Sales-Ready PQL" list, create a task assigned to the contact owner (or round-robin to SDR team):

• Task title: "PQL Handoff: [Contact Name]"
• Due date: Today (PQLs go cold fast)
• Description: "This contact hit 85 PQL score by [list of signals]. Last active [X] hours ago. Recommend outreach: [suggested talking points based on features used]."

Enroll in sales sequences: For self-serve PLG motions, enroll high-score PQLs in an automated email sequence:

• Email 1 (immediate): "Hey [Name], noticed you've been using [Product Feature]. Want to see how [Advanced Feature] can save you even more time?"
• Email 2 (+2 days): Share case study from similar company
• Email 3 (+5 days): Offer to book demo or answer questions

Use HubSpot sequences (for one-to-one emails from sales) or marketing emails (for scaled outreach). Gate enrollment with pql_score >= 70 and last_product_activity is less than 7 days ago.

Integration with playbooks: If your sales team uses HubSpot playbooks (guided scripts), create a PQL-specific playbook that surfaces when reps open a PQL contact. Include:

• Which features the contact has used
• Suggested talking points ("They've hit the free plan limit on dashboards - ask if they'd like to upgrade")
• Common objections based on usage patterns

This gives reps context without requiring them to manually check product properties.

FAQ

How to set up scoring in HubSpot?

Create a custom number property for your score (e.g., pql_score), then build workflows that enroll contacts when qualifying properties change and use "Set property value" actions to increment the score. For product-based scoring, you need product usage data synced to HubSpot properties first (via Zoody, reverse ETL, or custom API). Set up separate workflows for score increments (when usage increases) and score decay (when users go inactive). Use if/then branches to award different point values based on which criteria triggered enrollment.

How to create a lead scoring model?

Start by defining which behaviors predict conversion - for SaaS companies, focus on product activation, feature adoption, and team expansion. Assign point values to each behavior based on how strongly they correlate with closed-won deals (analyze past customer data to calibrate). Create HubSpot contact properties to track these signals, then build workflows that automatically update a score property when contacts exhibit scoring behaviors. Set a threshold (typically 60-80 points) where leads become sales-ready. Test and iterate monthly based on conversion rate data.

What is the new lead scoring model in HubSpot?

HubSpot's predictive lead scoring (released in 2022, available on Professional and Enterprise tiers) uses machine learning to automatically score contacts based on historical closed-won deal data. It analyzes all contact properties to find patterns that predict conversion. The system generates a score (0-100) without manual configuration. However, it only uses data already in HubSpot - it can't score based on product usage unless you sync product events to HubSpot properties first. For PQL scoring, you'll likely still need manual workflow-based scoring that incorporates product signals.

How to automate lead scoring?

Use HubSpot workflows to automate score updates. Create contact-based workflows with enrollment triggers tied to the properties you want to score (e.g., "when has_activated changes to true"). Add workflow actions that increment your score property using the "Set property value" action with calculated values like {{pql_score}} + 20. Enable re-enrollment for repeatable behaviors (like creating reports) so the score increases each time. Build separate workflows for score decay (re-enrolling contacts who haven't been active in X days and decreasing their score). Use active lists to segment contacts by score ranges and trigger sales tasks or email sequences when they hit thresholds.

What product usage signals should I track for PQL scoring?

Track activation milestones (completed onboarding, first core action completed), feature adoption depth (how many times they used key features), team expansion signals (teammates invited, seats added), integration usage (connected third-party tools), and engagement frequency (days active in last 30 days). Also track negative signals like inactivity (last login date) for score decay. Start with 5-7 essential signals - you can always add more. Focus on behaviors that existing customers exhibited before converting. Avoid vanity metrics like total logins; track meaningful actions that demonstrate value realization and buying intent.