Designing Lead Prioritization Scoring Models for Intelligent Outbound Contact Selection

How-To-Articles
1

Designing Lead Prioritization Scoring Models for Intelligent Outbound Contact Selection

What This Guide Covers

You are building a deterministic lead scoring engine within Genesys Cloud CX to drive outbound campaign prioritization. The end result is a system where high-propensity leads are routed to top-tier agents with minimal wait time, while low-propensity leads are held or assigned to lower-cost channels based on a composite score derived from CRM data, historical interaction metadata, and real-time agent availability.

Prerequisites, Roles & Licensing

  • Licensing: Genesys Cloud CX 2 or CX 3 (required for Advanced Routing and Scripting features).
  • Roles:
    • Admin > Contact Center > Edit
    • Admin > Integrations > Edit (for CRM Connector configuration)
    • Telephony > Trunk > Edit (if configuring outbound trunks)
  • Permissions:
    • Routing > Queue > Edit
    • Routing > Outbound Campaign > Edit
    • Integrations > CRM > Edit
  • External Dependencies:
    • A configured CRM Connector (Salesforce, Microsoft Dynamics, or custom REST API) that exposes lead attributes.
    • A defined Outbound Campaign with dialer settings (Predictive, Power, or Progress).

The Implementation Deep-Dive

1. Defining the Scoring Schema and Data Ingestion

The foundation of intelligent outbound selection is not the dialer; it is the data model. Most implementations fail because they treat “Lead Score” as a single static field pushed from the CRM. This approach lacks granularity and fails to account for real-time context. You must design a composite scoring model that ingests multiple attributes and calculates a priority weight dynamically.

Architectural Reasoning

Static scores decay rapidly. A lead scored “Hot” yesterday may be “Cold” today if they interacted with your website or if a competitor contacted them. By leveraging Genesys Cloud’s Attributes and User-Defined Fields (UDFs), you can maintain a live view of lead intent. The architecture requires two data layers:

  1. Static Attributes: Demographics, tenure, contract value (pushed from CRM via Connector).
  2. Dynamic Attributes: Last contact date, number of previous attempts, sentiment from previous interactions (calculated via Genesys APIs or Webhooks).

The Trap: The “Black Box” Score

The most common misconfiguration is accepting a pre-calculated score from the CRM without validation. If the CRM logic breaks, your entire outbound operation halts or misprioritizes. You must never trust a single external source for routing decisions. Instead, ingest the raw components (e.g., lead_value, days_since_last_contact, engagement_level) and calculate the final priority score within Genesys using Architect or Outbound Campaign Rules.

Implementation Steps

  1. Configure CRM Connector Attributes:
    Ensure your CRM Connector maps the following fields to Genesys Contact Attributes:

    • crm.lead_value (Number)
    • crm.lead_source (String)
    • crm.last_activity_date (Date)

  2. Define Custom Attributes in Genesys:
    Navigate to Admin > Contact Center > Attributes. Create the following attributes:

    • outbound.priority_score (Number): The final calculated score.
    • outbound.segment (String): High/Medium/Low tier.

  3. Build the Scoring Logic in Architect:
    You will use a Set Contact Attributes block to calculate the score before the contact enters the Outbound Campaign queue.

    Expression Logic:

    // Calculate days since last contact
var daysSinceContact = (now() - contact.attributes.crm.last_activity_date) / 86400000;

// Base Score Calculation
var score = 0;

// Factor 1: Recency (Exponential decay)
if (daysSinceContact < 7) {
    score += 50;
} else if (daysSinceContact < 30) {
    score += 30;
} else {
    score += 10;
}

// Factor 2: Value (Linear scaling)
var value = contact.attributes.crm.lead_value;
if (value > 10000) {
    score += 30;
} else if (value > 5000) {
    score += 20;
} else {
    score += 10;
}

// Factor 3: Engagement (Binary from CRM)
if (contact.attributes.crm.engagement_level == "High") {
    score += 20;
}

contact.attributes.outbound.priority_score = score;

  4. Map Attributes to Outbound Campaign:
    In the Outbound Campaign settings, ensure these attributes are selected for import. This ensures the data is available for routing rules.

2. Configuring Outbound Campaign Routing Rules

Once the score is calculated, you must configure the Outbound Campaign to use this score for prioritization. Genesys Cloud Outbound Campaigns support Priority Routing and Skill-Based Routing.

Architectural Reasoning

Using a single queue for all leads creates contention. High-value leads should not compete with low-value leads for the same agent pool. The optimal architecture uses Segmented Queues. You create three queues: Outbound_High_Priority, Outbound_Medium_Priority, and Outbound_Low_Priority. Each queue has different service level objectives (SLOs) and agent skills.

The Trap: Priority Inversion

If you use a single queue with priority weights, you risk priority inversion. This occurs when a high-priority lead is stuck behind a large batch of low-priority leads that were dialed slightly earlier. The dialer processes contacts in the order they are added to the dial list, not necessarily by priority. To mitigate this, you must use Campaign Pauses or Dynamic Weighting to ensure high-priority contacts are injected into the dialer first.

Implementation Steps

  1. Create Segmented Queues:

    • Create Outbound_High_Priority with Skill Outbound_Senior.
    • Create Outbound_Medium_Priority with Skill Outbound_Standard.
    • Create Outbound_Low_Priority with Skill Outbound_Junior.

  2. Configure Outbound Campaign Rules:
    In the Outbound Campaign settings, navigate to Rules.

    • Rule 1: contact.attributes.outbound.priority_score >= 70 → Route to Outbound_High_Priority.
    • Rule 2: contact.attributes.outbound.priority_score >= 40 → Route to Outbound_Medium_Priority.
    • Rule 3: Else → Route to Outbound_Low_Priority.

  3. Set Dialer Strategy:
    For Outbound_High_Priority, use Predictive Dialing with a higher Answer Rate target (e.g., 0.85) to maximize agent utilization. For Outbound_Low_Priority, use Progress Dialing to reduce burn rate and cost.

3. Integrating Real-Time Agent Availability

A lead score is meaningless if the right agent is not available. You must integrate real-time agent state into the scoring model.

Architectural Reasoning

Genesys Cloud’s Advanced Routing allows you to route based on agent attributes. You can tag agents with specialization_finance, specialization_tech, etc. The scoring model should include a Fit Score that compares the lead’s attributes to the agent’s skills.

The Trap: Over-Specialization

If you over-specialize agents, you reduce the pool of available agents for each lead, increasing wait times and causing dropped calls. The trap is creating too many skills. Limit specializations to 3-5 key categories. Use Generic Skills for fallback routing.

Implementation Steps

  1. Tag Agents with Skills:
    Assign skills to agents based on their expertise.

  2. Update Scoring Logic:
    Modify the Architect flow to calculate a Fit Score.

    // Pseudocode for Fit Score
var fitScore = 0;
if (contact.attributes.lead_type == "Finance" && agent.skills.contains("specialization_finance")) {
    fitScore = 100;
} else if (contact.attributes.lead_type == "Tech" && agent.skills.contains("specialization_tech")) {
    fitScore = 100;
} else {
    fitScore = 50;
}
contact.attributes.outbound.fit_score = fitScore;

  3. Configure Routing Strategy:
    In the Queue settings, set the Routing Strategy to Longest Idle Agent for high-priority queues to ensure fresh agents handle complex leads. Use Least Recently Assigned Agent for low-priority queues to distribute load evenly.

Validation, Edge Cases & Troubleshooting

Edge Case 1: The “Cold Start” Problem

The Failure Condition:
New leads from a recent marketing campaign have no historical data. The scoring model assigns them a default low score, causing them to be routed to junior agents or held in a low-priority queue. This results in missed opportunities for high-intent new leads.

The Root Cause:
The scoring logic relies on historical attributes (e.g., last_activity_date, previous_calls) that are null for new records. The expression evaluates null values as zero or zero-weight.

The Solution:
Implement a Default High Score for new leads from specific sources.

if (contact.attributes.crm.lead_source == "Webinar_High_Value") {
    contact.attributes.outbound.priority_score = 80; // Force high priority
} else if (contact.attributes.outbound.priority_score == null) {
    contact.attributes.outbound.priority_score = 50; // Default medium
}

Additionally, use Webhooks to update the lead score in real-time as the lead interacts with your website during the dialing process.

Edge Case 2: Score Drift and Stale Data

The Failure Condition:
Leads sit in the Outbound Campaign list for days without being called. Their score remains high, but their intent has likely decayed. When they are finally called, they are no longer interested, leading to high rejection rates and agent burnout.

The Root Cause:
The Outbound Campaign does not re-evaluate scores dynamically. The score is calculated once at import time and never updated.

The Solution:
Implement a Re-scoring Loop.

  1. Use a Scheduled Task in Architect to run every 4 hours.
  2. The task queries all contacts in the Outbound Campaign list.
  3. It recalculates the priority_score based on current time and any new CRM updates.
  4. It updates the contact attributes.
  5. The Outbound Campaign rules re-evaluate the updated scores and move contacts between queues if necessary.

API Endpoint for Re-scoring:

PUT /api/v2/outbound/contacts/{contactId}
Authorization: Bearer <token>
Content-Type: application/json

{
  "attributes": {
    "outbound.priority_score": 45
  }
}

Edge Case 3: Agent Burnout from High-Volume High-Priority

The Failure Condition:
Senior agents are overwhelmed with high-priority leads. The system routes all high-score leads to the Outbound_Senior skill queue. This queue fills up, causing high-priority leads to wait longer than low-priority leads in the Outbound_Junior queue.

The Root Cause:
Lack of Capacity Management. The scoring model does not account for queue depth.

The Solution:
Implement Dynamic Queue Assignment.

  1. Monitor the Occupancy of the Outbound_Senior queue.
  2. If occupancy exceeds 80%, route new high-priority leads to a Hybrid Queue that includes both Senior and Standard agents.
  3. Use Architect to check queue stats before routing.
var seniorQueueOccupancy = getQueueStats("Outbound_High_Priority").occupancy;
if (seniorQueueOccupancy > 0.8) {
    contact.attributes.outbound.target_queue = "Outbound_Hybrid";
} else {
    contact.attributes.outbound.target_queue = "Outbound_High_Priority";
}

Official References