Lead Qualification and Processing - Complete AI-Powered with Smart Routing

Advanced lead qualification workflow combining data enrichment with AI-powered scoring and automated sales assignment

Back

Workflow Information

ID: lead_qualification_complete_ai

Namespace: sales

Version: 2.0

Created: 2025-07-01

Updated: 2025-07-01

Tasks: 11

Quick Actions

Manage Secrets

Inputs

Name	Type	Required	Default
`timezone`	string	Optional	`UTC`
`time_format`	string	Optional	`iso`
`lead_id`	string	Required	`LEAD_001`
`lead_name`	string	Required	`John Smith`
`lead_email`	string	Required	`john.smith@company.com`
`company_name`	string	Required	`Acme Corporation`
`industry`	string	Optional	`Technology`
`annual_revenue`	integer	Optional	`50000`

Outputs

Name	Type	Source
`lead_score`	object	AI-calculated lead scoring results
`similar_leads`	object	Similar leads analysis from Dynamics
`final_processing`	object	Final lead processing results and notifications
`workload_analysis`	object	Sales officer workload assessment
`historical_analysis`	object	Historical data analysis from BigQuery
`initialization_data`	object	System initialization and lead data extraction
`qualification_results`	object	Lead qualification determination and routing results

Tasks

get_lead_data_from_crm

script

Extract and initialize lead data from CRM webhook trigger

Python Script:

import os
import json
from datetime import datetime

print("💼 LEAD DATA EXTRACTION FROM CRM")
print("=" * 60)
print("🔄 Processing new lead webhook trigger...")
print("")

# Get input parameters
execution_id = os.environ.get('EXECUTION_ID', 'unknown')
lead_id = "${lead_id}"
lead_name = "${lead_name}"
lead_email = "${lead_email}"
company_name = "${company_name}"
industry = "${industry}" or "Unknown"
annual_revenue = "${annual_revenue}" or 0
timezone = "${timezone}"
time_format = "${time_format}"

# Process annual revenue
try:
    annual_revenue = int(annual_revenue) if annual_revenue else 0
except ValueError:
    annual_revenue = 0
    print(f"⚠️ Invalid annual revenue value: ${annual_revenue}")

print("📋 Lead Details:")
print(f"   Execution ID: {execution_id}")
print(f"   Lead ID: {lead_id}")
print(f"   Name: {lead_name}")
print(f"   Email: {lead_email}")
print(f"   Company: {company_name}")
print(f"   Industry: {industry}")
print(f"   Annual Revenue: ${annual_revenue:,}")
print(f"   Timezone: {timezone}")
print(f"   Time Format: {time_format}")
print("")

# Extract domain from email for company matching
email_domain = lead_email.split('@')[1] if '@' in lead_email else 'unknown.com'

# Simulate CRM data enrichment
crm_data = {
    "lead_source": "Website Form",
    "campaign_id": "CAMP_2024_Q1",
    "utm_source": "google",
    "utm_medium": "cpc",
    "lead_status": "New",
    "created_date": datetime.now().isoformat(),
    "last_activity": "Form Submission",
    "phone": "+1-555-0123",
    "job_title": "VP of Sales",
    "company_size": "51-200 employees",
    "website": f"https://www.{email_domain}"
}

print("📊 Additional CRM Data:")
print(f"   Source: {crm_data['lead_source']}")
print(f"   Campaign: {crm_data['campaign_id']}")
print(f"   Job Title: {crm_data['job_title']}")
print(f"   Company Size: {crm_data['company_size']}")
print(f"   Website: {crm_data['website']}")
print("")

print("✅ Lead data extracted successfully")
print("➡️ Proceeding to historical data analysis...")

# Output structured lead data
result = {
    "status": "completed",
    "execution_id": execution_id,
    "lead_data": {
        "lead_id": lead_id,
        "name": lead_name,
        "email": lead_email,
        "company": company_name,
        "industry": industry,
        "annual_revenue": annual_revenue,
        "email_domain": email_domain
    },
    "crm_enrichment": crm_data,
    "timezone": timezone,
    "time_format": time_format,
    "timestamp": datetime.now().isoformat()
}

print(f"__OUTPUTS__ {json.dumps(result)}")

get_historical_data_from_bigquery

script

Retrieve and analyze historical data from BigQuery for lead scoring

Python Script:

import json
import time
from datetime import datetime, timedelta
import random

print("📊 HISTORICAL DATA ANALYSIS FROM BIGQUERY")
print("=" * 60)
print("")

# Get lead data from previous step
lead_email = "${get_lead_data_from_crm.lead_data.email}"
company_name = "${get_lead_data_from_crm.lead_data.company}"
industry = "${get_lead_data_from_crm.lead_data.industry}"
email_domain = "${get_lead_data_from_crm.lead_data.email_domain}"

print(f"🔍 Analyzing historical data for: {company_name}")
print(f"   Industry: {industry}")
print(f"   Domain: {email_domain}")
print("")

try:
    print("🌐 Connecting to BigQuery...")
    time.sleep(2)  # Simulate BigQuery connection
    
    # Simulate historical data analysis
    print("✓ Connected to BigQuery successfully")
    print("✓ Querying historical lead data...")
    print("✓ Analyzing conversion patterns...")
    print("✓ Calculating industry benchmarks...")
    
    # Generate mock historical insights
    historical_insights = {
        "total_leads_analyzed": random.randint(5000, 15000),
        "industry_conversion_rate": round(random.uniform(0.12, 0.28), 3),
        "average_deal_size": random.randint(25000, 150000),
        "average_sales_cycle_days": random.randint(45, 120),
        "similar_companies_converted": random.randint(15, 45),
        "domain_previous_leads": random.randint(0, 5),
        "seasonal_trends": {
            "current_quarter_performance": "Above Average",
            "best_conversion_month": "March",
            "industry_peak_season": "Q1-Q2"
        },
        "engagement_patterns": {
            "email_open_rate": round(random.uniform(0.25, 0.45), 3),
            "content_download_rate": round(random.uniform(0.15, 0.35), 3),
            "demo_request_rate": round(random.uniform(0.08, 0.18), 3)
        }
    }
    
    # Calculate historical score based on patterns
    historical_score = 0
    
    # Industry performance factor
    if historical_insights["industry_conversion_rate"] > 0.20:
        historical_score += 25
    elif historical_insights["industry_conversion_rate"] > 0.15:
        historical_score += 15
    else:
        historical_score += 5
    
    # Deal size factor
    if historical_insights["average_deal_size"] > 100000:
        historical_score += 20
    elif historical_insights["average_deal_size"] > 50000:
        historical_score += 15
    else:
        historical_score += 10
    
    # Domain history factor
    if historical_insights["domain_previous_leads"] > 0:
        historical_score += 15
        domain_status = "Returning Domain"
    else:
        historical_score += 5
        domain_status = "New Domain"
    
    # Seasonal trends factor
    if historical_insights["seasonal_trends"]["current_quarter_performance"] == "Above Average":
        historical_score += 10
    
    print("")
    print("📊 Historical Analysis Results:")
    print(f"   Industry Conversion Rate: {historical_insights['industry_conversion_rate']*100:.1f}%")
    print(f"   Average Deal Size: ${historical_insights['average_deal_size']:,}")
    print(f"   Sales Cycle: {historical_insights['average_sales_cycle_days']} days")
    print(f"   Domain Status: {domain_status}")
    print(f"   Historical Score: {historical_score}/70")
    
    result = {
        "status": "completed",
        "historical_insights": historical_insights,
        "historical_score": historical_score,
        "domain_status": domain_status,
        "analysis_timestamp": datetime.now().isoformat(),
        "data_source": "BigQuery Historical Analysis"
    }
    
    print("")
    print("✅ Historical analysis completed")
    
except Exception as e:
    result = {
        "status": "error",
        "error": str(e),
        "historical_score": 0,
        "analysis_timestamp": datetime.now().isoformat()
    }
    print(f"❌ Historical analysis failed: {e}")

print(f"__OUTPUTS__ {json.dumps(result)}")

get_similar_leads_from_dynamics

script

Find and analyze similar leads from Dynamics for pattern matching

Python Script:

import json
import time
import random
from datetime import datetime

print("🔍 SIMILAR LEADS ANALYSIS FROM DYNAMICS")
print("=" * 60)
print("")

# Get data from previous steps
company_name = "${get_lead_data_from_crm.lead_data.company}"
industry = "${get_lead_data_from_crm.lead_data.industry}"
annual_revenue = "${get_lead_data_from_crm.lead_data.annual_revenue}"
job_title = "${get_lead_data_from_crm.crm_enrichment.job_title}"
company_size = "${get_lead_data_from_crm.crm_enrichment.company_size}"

print(f"🎯 Searching for similar leads to: {company_name}")
print(f"   Industry: {industry}")
print(f"   Revenue: ${annual_revenue:,}" if annual_revenue else "   Revenue: Unknown")
print(f"   Job Title: {job_title}")
print(f"   Company Size: {company_size}")
print("")

try:
    print("🌐 Connecting to Dynamics CRM...")
    time.sleep(2)  # Simulate Dynamics connection
    
    print("✓ Connected to Dynamics successfully")
    print("✓ Searching for similar industry leads...")
    print("✓ Analyzing job title patterns...")
    print("✓ Matching company size criteria...")
    print("✓ Evaluating revenue segments...")
    
    # Generate mock similar leads data
    similar_leads_count = random.randint(8, 25)
    converted_leads = random.randint(2, 8)
    conversion_rate = round(converted_leads / similar_leads_count, 3)
    
    similar_leads_data = {
        "total_similar_leads": similar_leads_count,
        "converted_leads": converted_leads,
        "conversion_rate": conversion_rate,
        "average_time_to_conversion": random.randint(30, 90),
        "common_objections": [
            "Budget constraints",
            "Timeline concerns",
            "Feature requirements"
        ],
        "successful_tactics": [
            "Product demo",
            "ROI calculator",
            "Case study presentation"
        ],
        "similar_lead_profiles": [
            {
                "company": "TechCorp Inc",
                "industry": industry,
                "status": "Converted",
                "deal_value": random.randint(45000, 120000),
                "conversion_time_days": random.randint(25, 85)
            },
            {
                "company": "InnoSoft Ltd",
                "industry": industry,
                "status": "Converted",
                "deal_value": random.randint(35000, 95000),
                "conversion_time_days": random.randint(40, 75)
            },
            {
                "company": "DataFlow Systems",
                "industry": industry,
                "status": "Lost",
                "reason": "Budget constraints",
                "engagement_duration": random.randint(15, 45)
            }
        ]
    }
    
    # Calculate similarity score
    similarity_score = 0
    
    # Conversion rate factor
    if conversion_rate > 0.30:
        similarity_score += 25
    elif conversion_rate > 0.20:
        similarity_score += 20
    elif conversion_rate > 0.15:
        similarity_score += 15
    else:
        similarity_score += 10
    
    # Sample size factor
    if similar_leads_count > 20:
        similarity_score += 15
    elif similar_leads_count > 10:
        similarity_score += 10
    else:
        similarity_score += 5
    
    # Time to conversion factor
    if similar_leads_data["average_time_to_conversion"] < 60:
        similarity_score += 10
    else:
        similarity_score += 5
    
    print("")
    print("📊 Similar Leads Analysis:")
    print(f"   Similar Leads Found: {similar_leads_count}")
    print(f"   Conversion Rate: {conversion_rate*100:.1f}%")
    print(f"   Average Conversion Time: {similar_leads_data['average_time_to_conversion']} days")
    print(f"   Similarity Score: {similarity_score}/50")
    
    result = {
        "status": "completed",
        "similar_leads_data": similar_leads_data,
        "similarity_score": similarity_score,
        "pattern_confidence": "High" if similarity_score > 35 else "Medium" if similarity_score > 25 else "Low",
        "analysis_timestamp": datetime.now().isoformat(),
        "data_source": "Dynamics CRM Similar Leads Analysis"
    }
    
    print("")
    print("✅ Similar leads analysis completed")
    
except Exception as e:
    result = {
        "status": "error",
        "error": str(e),
        "similarity_score": 0,
        "pattern_confidence": "Low",
        "analysis_timestamp": datetime.now().isoformat()
    }
    print(f"❌ Similar leads analysis failed: {e}")

print(f"__OUTPUTS__ {json.dumps(result)}")

get_sales_officer_workload

script

Analyze current sales officer workload for optimal assignment

Python Script:

import json
import random
from datetime import datetime

print("👤 SALES OFFICER WORKLOAD ANALYSIS")
print("=" * 60)
print("")

# Get industry from previous steps for specialization matching
industry = "${get_lead_data_from_crm.lead_data.industry}"
annual_revenue = "${get_lead_data_from_crm.lead_data.annual_revenue}"

print(f"🔍 Analyzing workload for {industry} industry lead")
print(f"   Deal Size Category: {'Enterprise' if annual_revenue and int(annual_revenue) > 100000 else 'Mid-Market' if annual_revenue and int(annual_revenue) > 25000 else 'SMB'}")
print("")

try:
    print("🌐 Connecting to Sales Team Management System...")
    print("✓ Retrieving active sales officers...")
    print("✓ Analyzing current workloads...")
    print("✓ Checking specializations...")
    print("✓ Evaluating performance metrics...")
    
    # Generate mock sales officer data
    sales_officers = [
        {
            "officer_id": "SO001",
            "name": "Sarah Johnson",
            "specialization": [industry, "Enterprise Sales"],
            "current_leads": random.randint(8, 15),
            "active_deals": random.randint(3, 8),
            "capacity_utilization": round(random.uniform(0.65, 0.85), 2),
            "conversion_rate": round(random.uniform(0.22, 0.35), 3),
            "average_deal_size": random.randint(75000, 150000),
            "response_time_hours": round(random.uniform(2, 8), 1),
            "availability_score": random.randint(75, 95)
        },
        {
            "officer_id": "SO002",
            "name": "Michael Chen",
            "specialization": ["Technology", "Mid-Market"],
            "current_leads": random.randint(12, 20),
            "active_deals": random.randint(5, 12),
            "capacity_utilization": round(random.uniform(0.75, 0.95), 2),
            "conversion_rate": round(random.uniform(0.18, 0.28), 3),
            "average_deal_size": random.randint(35000, 85000),
            "response_time_hours": round(random.uniform(3, 12), 1),
            "availability_score": random.randint(60, 80)
        },
        {
            "officer_id": "SO003",
            "name": "Emily Rodriguez",
            "specialization": [industry, "SMB Sales"],
            "current_leads": random.randint(15, 25),
            "active_deals": random.randint(8, 15),
            "capacity_utilization": round(random.uniform(0.70, 0.90), 2),
            "conversion_rate": round(random.uniform(0.25, 0.38), 3),
            "average_deal_size": random.randint(15000, 45000),
            "response_time_hours": round(random.uniform(1, 6), 1),
            "availability_score": random.randint(80, 95)
        }
    ]
    
    # Calculate recommendation scores for each officer
    for officer in sales_officers:
        score = 0
        
        # Specialization match
        if industry in officer["specialization"]:
            score += 30
        else:
            score += 10
        
        # Capacity availability (lower utilization = higher score)
        if officer["capacity_utilization"] < 0.75:
            score += 25
        elif officer["capacity_utilization"] < 0.85:
            score += 15
        else:
            score += 5
        
        # Conversion rate performance
        if officer["conversion_rate"] > 0.30:
            score += 20
        elif officer["conversion_rate"] > 0.25:
            score += 15
        else:
            score += 10
        
        # Response time
        if officer["response_time_hours"] < 4:
            score += 15
        elif officer["response_time_hours"] < 8:
            score += 10
        else:
            score += 5
        
        # Availability score
        if officer["availability_score"] > 85:
            score += 10
        elif officer["availability_score"] > 75:
            score += 5
        
        officer["recommendation_score"] = score
    
    # Sort by recommendation score
    sales_officers.sort(key=lambda x: x["recommendation_score"], reverse=True)
    recommended_officer = sales_officers[0]
    
    print("")
    print("📊 Sales Officer Analysis Results:")
    print(f"   Total Officers Analyzed: {len(sales_officers)}")
    print(f"   Recommended Officer: {recommended_officer['name']}")
    print(f"   Specialization Match: {'✓' if industry in recommended_officer['specialization'] else '✗'}")
    print(f"   Capacity Utilization: {recommended_officer['capacity_utilization']*100:.0f}%")
    print(f"   Recommendation Score: {recommended_officer['recommendation_score']}/100")
    
    result = {
        "status": "completed",
        "sales_officers": sales_officers,
        "recommended_officer": recommended_officer,
        "team_capacity": {
            "total_officers": len(sales_officers),
            "average_utilization": round(sum(o["capacity_utilization"] for o in sales_officers) / len(sales_officers), 2),
            "specialization_coverage": industry in [spec for officer in sales_officers for spec in officer["specialization"]]
        },
        "analysis_timestamp": datetime.now().isoformat(),
        "data_source": "Sales Team Management System"
    }
    
    print("")
    print("✅ Sales officer workload analysis completed")
    
except Exception as e:
    result = {
        "status": "error",
        "error": str(e),
        "recommended_officer": None,
        "analysis_timestamp": datetime.now().isoformat()
    }
    print(f"❌ Sales officer analysis failed: {e}")

print(f"__OUTPUTS__ {json.dumps(result)}")

calculate_lead_score

ai_agent

AI-powered lead scoring combining all data sources

AI Agent Configuration:

Model Configuration

Model Client ID: lead_scorer
Agent Type: assistant

Input Format: text
Output Format: text

determine_qualification_status

script

Determine qualification status and route based on lead score

Python Script:

import json
from datetime import datetime

print("📊 LEAD QUALIFICATION DETERMINATION")
print("=" * 60)
print("")

# Get lead score from AI analysis
lead_score_data = '''${calculate_lead_score}'''

try:
    # Parse the AI scoring results
    scoring_results = json.loads(lead_score_data)
    overall_lead_score = scoring_results.get('overall_lead_score', 0)
    confidence_level = scoring_results.get('confidence_level', 'Low')
    conversion_probability = scoring_results.get('predicted_conversion_probability', 0.0)
    
    print(f"📊 Lead Scoring Results:")
    print(f"   Overall Score: {overall_lead_score}/100")
    print(f"   Confidence Level: {confidence_level}")
    print(f"   Conversion Probability: {conversion_probability*100:.1f}%")
    print("")
    
    # Qualification threshold is 70
    qualification_threshold = 70
    
    print(f"🎯 Qualification Threshold: {qualification_threshold}")
    print(f"   Lead Score: {overall_lead_score}")
    print(f"   Status: {'ABOVE' if overall_lead_score >= qualification_threshold else 'BELOW'} threshold")
    print("")
    
    # Determine routing based on score
    if overall_lead_score >= qualification_threshold:
        qualification_status = "QUALIFIED"
        next_action = "route_to_sales"
        priority_level = "High" if overall_lead_score >= 85 else "Medium"
        print("✅ QUALIFICATION DECISION: QUALIFIED")
        print(f"   Priority Level: {priority_level}")
        print("   Next Action: Route to Sales Officer")
    else:
        qualification_status = "UNQUALIFIED"
        next_action = "schedule_followup"
        priority_level = "Low"
        print("❌ QUALIFICATION DECISION: UNQUALIFIED")
        print("   Priority Level: Low")
        print("   Next Action: Schedule Follow-up")
    
    print("")
    print("➡️ Proceeding to conditional routing...")
    
    result = {
        "status": "completed",
        "qualification_status": qualification_status,
        "lead_score": overall_lead_score,
        "qualification_threshold": qualification_threshold,
        "meets_threshold": overall_lead_score >= qualification_threshold,
        "next_action": next_action,
        "priority_level": priority_level,
        "scoring_details": scoring_results,
        "decision_timestamp": datetime.now().isoformat(),
        "routing_decision": "qualified_path" if qualification_status == "QUALIFIED" else "unqualified_path"
    }
    
except Exception as e:
    print(f"❌ Error processing lead score: {e}")
    result = {
        "status": "error",
        "qualification_status": "UNQUALIFIED",
        "lead_score": 0,
        "next_action": "manual_review",
        "error": str(e)
    }

print(f"__OUTPUTS__ {json.dumps(result)}")

qualification_router

conditional_router

Routes qualified leads to sales team or unqualified leads to follow-up

Conditional Router

Router Type: condition
Default Route: unqualified_path

process_qualified_lead

script

Process qualified leads - recommend sales officer and create deal

Python Script:

import json
import time
from datetime import datetime

print("✅ PROCESSING QUALIFIED LEAD")
print("=" * 50)
print("")

# Get data from previous steps
lead_data = '''${get_lead_data_from_crm.lead_data}'''
recommended_officer_data = '''${get_sales_officer_workload.recommended_officer}'''
scoring_data = '''${determine_qualification_status.scoring_details}'''

try:
    lead_info = json.loads(lead_data)
    officer_info = json.loads(recommended_officer_data)
    scoring_info = json.loads(scoring_data)
    
    lead_name = lead_info['name']
    company_name = lead_info['company']
    lead_score = scoring_info.get('overall_lead_score', 0)
    officer_name = officer_info['name']
    officer_id = officer_info['officer_id']
    
    print(f"👤 Recommended Sales Officer: {officer_name} ({officer_id})")
    print(f"   Lead: {lead_name} from {company_name}")
    print(f"   Lead Score: {lead_score}/100")
    print("")
    
    # Step 1: Create Deal in CRM
    print("💼 Creating deal in CRM...")
    time.sleep(2)  # Simulate CRM API call
    
    deal_data = {
        "deal_id": f"DEAL_{int(time.time())}",
        "deal_name": f"{company_name} - {lead_name}",
        "lead_id": lead_info['lead_id'],
        "assigned_officer": officer_id,
        "stage": "Qualification",
        "probability": f"{scoring_info.get('predicted_conversion_probability', 0.5)*100:.0f}%",
        "estimated_value": officer_info.get('average_deal_size', 50000),
        "created_date": datetime.now().isoformat(),
        "priority": "High" if lead_score >= 85 else "Medium"
    }
    
    print("✓ Deal created successfully")
    print(f"   Deal ID: {deal_data['deal_id']}")
    print(f"   Estimated Value: ${deal_data['estimated_value']:,}")
    print(f"   Priority: {deal_data['priority']}")
    
    # Step 2: Update CRM Lead Status
    print("")
    print("🔄 Updating CRM lead status...")
    time.sleep(1)
    
    crm_update = {
        "lead_id": lead_info['lead_id'],
        "status": "Qualified",
        "assigned_officer": officer_id,
        "qualification_date": datetime.now().isoformat(),
        "lead_score": lead_score,
        "deal_id": deal_data['deal_id']
    }
    
    print("✓ CRM lead status updated to 'Qualified'")
    
    # Step 3: Log Activity in Dynamics
    print("")
    print("📝 Logging activity in Dynamics...")
    time.sleep(1)
    
    activity_log = {
        "activity_id": f"ACT_{int(time.time())}",
        "type": "Lead Qualification",
        "lead_id": lead_info['lead_id'],
        "deal_id": deal_data['deal_id'],
        "description": f"Lead qualified with score {lead_score}/100 and assigned to {officer_name}",
        "created_by": "AI Lead Qualification System",
        "timestamp": datetime.now().isoformat()
    }
    
    print("✓ Activity logged in Dynamics")
    print(f"   Activity ID: {activity_log['activity_id']}")
    
    # Step 4: Notify Sales Officer
    print("")
    print(f"🔔 Notifying sales officer: {officer_name}...")
    time.sleep(1)
    
    notification = {
        "notification_id": f"NOTIF_{int(time.time())}",
        "recipient": officer_id,
        "subject": f"New Qualified Lead: {lead_name} from {company_name}",
        "message": f"You have been assigned a new qualified lead with a score of {lead_score}/100. Deal ID: {deal_data['deal_id']}",
        "priority": deal_data['priority'],
        "sent_timestamp": datetime.now().isoformat()
    }
    
    print("✓ Sales officer notified")
    print(f"   Notification sent to: {officer_name}")
    
    result = {
        "status": "completed",
        "processing_type": "Qualified Lead Processing",
        "deal_created": deal_data,
        "crm_updated": crm_update,
        "activity_logged": activity_log,
        "notification_sent": notification,
        "next_steps": [
            "Sales officer to contact lead within 24 hours",
            "Schedule discovery call",
            "Send welcome package"
        ],
        "processing_timestamp": datetime.now().isoformat()
    }
    
    print("")
    print("✅ Qualified lead processing completed successfully")
    
except Exception as e:
    result = {
        "status": "error",
        "error": str(e),
        "processing_type": "Qualified Lead Processing"
    }
    print(f"❌ Qualified lead processing failed: {e}")

print(f"__OUTPUTS__ {json.dumps(result)}")

process_unqualified_lead

script

Process unqualified leads - update status and schedule follow-up

Python Script:

import json
import time
from datetime import datetime, timedelta

print("⚠️ PROCESSING UNQUALIFIED LEAD")
print("=" * 50)
print("")

# Get data from previous steps
lead_data = '''${get_lead_data_from_crm.lead_data}'''
scoring_data = '''${determine_qualification_status.scoring_details}'''

try:
    lead_info = json.loads(lead_data)
    scoring_info = json.loads(scoring_data)
    
    lead_name = lead_info['name']
    company_name = lead_info['company']
    lead_score = scoring_info.get('overall_lead_score', 0)
    concerns = scoring_info.get('potential_concerns', [])
    
    print(f"👤 Lead: {lead_name} from {company_name}")
    print(f"   Lead Score: {lead_score}/100 (Below threshold of 70)")
    print(f"   Key Concerns: {', '.join(concerns[:2]) if concerns else 'General qualification criteria not met'}")
    print("")
    
    # Step 1: Update CRM Lead Status to Unqualified
    print("🔄 Updating CRM lead status...")
    time.sleep(1)
    
    crm_update = {
        "lead_id": lead_info['lead_id'],
        "status": "Unqualified",
        "unqualification_date": datetime.now().isoformat(),
        "lead_score": lead_score,
        "unqualification_reason": f"Score {lead_score}/100 below threshold. Concerns: {', '.join(concerns[:2]) if concerns else 'General criteria not met'}",
        "assigned_officer": None
    }
    
    print("✓ CRM lead status updated to 'Unqualified'")
    
    # Step 2: Schedule Follow-up
    print("")
    print("📅 Scheduling follow-up activities...")
    time.sleep(1)
    
    # Determine follow-up strategy based on score
    if lead_score >= 50:
        followup_strategy = "nurturing_campaign"
        followup_interval = 30  # days
        followup_type = "Email nurturing sequence"
    elif lead_score >= 30:
        followup_strategy = "quarterly_check"
        followup_interval = 90  # days
        followup_type = "Quarterly touchpoint"
    else:
        followup_strategy = "annual_review"
        followup_interval = 365  # days
        followup_type = "Annual market review"
    
    followup_date = (datetime.now() + timedelta(days=followup_interval)).isoformat()
    
    followup_schedule = {
        "followup_id": f"FOLLOWUP_{int(time.time())}",
        "lead_id": lead_info['lead_id'],
        "strategy": followup_strategy,
        "type": followup_type,
        "scheduled_date": followup_date,
        "interval_days": followup_interval,
        "automated": True,
        "description": f"Automated follow-up for lead with score {lead_score}/100"
    }
    
    print(f"✓ Follow-up scheduled: {followup_type}")
    print(f"   Next Contact: {followup_date[:10]}")
    print(f"   Strategy: {followup_strategy}")
    
    # Step 3: Add to appropriate nurturing list
    print("")
    print("📧 Adding to nurturing campaign...")
    time.sleep(1)
    
    nurturing_assignment = {
        "campaign_id": f"NURTURE_{followup_strategy.upper()}",
        "lead_id": lead_info['lead_id'],
        "campaign_type": followup_strategy,
        "enrolled_date": datetime.now().isoformat(),
        "email_sequence": True,
        "content_personalization": {
            "industry": lead_info.get('industry', 'General'),
            "company_size": "SMB" if lead_score < 40 else "Mid-Market"
        }
    }
    
    print(f"✓ Added to nurturing campaign: {nurturing_assignment['campaign_id']}")
    
    result = {
        "status": "completed",
        "processing_type": "Unqualified Lead Processing",
        "crm_updated": crm_update,
        "followup_scheduled": followup_schedule,
        "nurturing_assigned": nurturing_assignment,
        "recommendations": [
            "Monitor for company growth/changes",
            "Track engagement with nurturing content",
            "Re-evaluate qualification criteria periodically"
        ],
        "processing_timestamp": datetime.now().isoformat()
    }
    
    print("")
    print("✅ Unqualified lead processing completed")
    print("   Lead will be nurtured and re-evaluated based on engagement")
    
except Exception as e:
    result = {
        "status": "error",
        "error": str(e),
        "processing_type": "Unqualified Lead Processing"
    }
    print(f"❌ Unqualified lead processing failed: {e}")

print(f"__OUTPUTS__ {json.dumps(result)}")

qualification_summary

script

Summarize qualification results and generate final status report

Python Script:

import json
from datetime import datetime

print("")
print("=" * 70)
print("📊 LEAD QUALIFICATION SUMMARY REPORT")
print("=" * 70)
print("")

# Get basic lead information
lead_info = json.loads('''${get_lead_data_from_crm.lead_data}''')
qualification_result = json.loads('''${determine_qualification_status}''')

lead_name = lead_info['name']
company_name = lead_info['company']
lead_id = lead_info['lead_id']
qualification_status = qualification_result['qualification_status']
lead_score = qualification_result['lead_score']

print(f"Lead ID: {lead_id}")
print(f"Contact: {lead_name}")
print(f"Company: {company_name}")
print(f"Final Score: {lead_score}/100")
print(f"Status: {qualification_status}")
print(f"Report Generated: {datetime.now().isoformat()}")
print("")

# Determine which processing path was taken and get results
processing_result = None
processing_type = None

if qualification_status == "QUALIFIED":
    try:
        processing_data = '''${process_qualified_lead}'''
        processing_result = json.loads(processing_data)
        processing_type = "Qualified Lead Processing"
    except:
        processing_result = {"status": "error", "error": "Failed to parse qualified processing data"}
else:
    try:
        processing_data = '''${process_unqualified_lead}'''
        processing_result = json.loads(processing_data)
        processing_type = "Unqualified Lead Processing"
    except:
        processing_result = {"status": "error", "error": "Failed to parse unqualified processing data"}

print("PROCESSING RESULTS:")
print("-" * 50)
print(f"Processing Type: {processing_type}")
print(f"Processing Status: {processing_result.get('status', 'Unknown')}")

if qualification_status == "QUALIFIED" and processing_result.get('status') == 'completed':
    deal_info = processing_result.get('deal_created', {})
    officer_notification = processing_result.get('notification_sent', {})
    
    print(f"Deal Created: {deal_info.get('deal_id', 'N/A')}")
    print(f"Estimated Value: ${deal_info.get('estimated_value', 0):,}")
    print(f"Assigned Officer: {officer_notification.get('recipient', 'N/A')}")
    print(f"Priority: {deal_info.get('priority', 'N/A')}")
    
elif qualification_status == "UNQUALIFIED" and processing_result.get('status') == 'completed':
    followup_info = processing_result.get('followup_scheduled', {})
    nurturing_info = processing_result.get('nurturing_assigned', {})
    
    print(f"Follow-up Strategy: {followup_info.get('strategy', 'N/A')}")
    print(f"Next Contact: {followup_info.get('scheduled_date', 'N/A')[:10]}")
    print(f"Nurturing Campaign: {nurturing_info.get('campaign_id', 'N/A')}")

print("")

# Final status determination
if qualification_status == "QUALIFIED" and processing_result.get('status') == 'completed':
    final_status = "SUCCESSFULLY_QUALIFIED"
    next_action = "Sales officer will contact lead within 24 hours"
    print("✅ FINAL STATUS: Lead Successfully Qualified and Assigned")
elif qualification_status == "UNQUALIFIED" and processing_result.get('status') == 'completed':
    final_status = "PROPERLY_UNQUALIFIED"
    next_action = "Lead entered into nurturing campaign for future qualification"
    print("⚠️ FINAL STATUS: Lead Properly Unqualified and Nurtured")
else:
    final_status = "PROCESSING_ERROR"
    next_action = "Manual review required due to processing errors"
    print("❌ FINAL STATUS: Processing Error - Manual Review Required")

print(f"Next Action: {next_action}")
print("")
print("=== LEAD PROCESSING COMPLETED ===")

# Create comprehensive summary
summary_report = {
    "lead_summary": {
        "lead_id": lead_id,
        "contact_name": lead_name,
        "company": company_name,
        "final_score": lead_score,
        "qualification_status": qualification_status,
        "processing_timestamp": datetime.now().isoformat()
    },
    "qualification_details": qualification_result,
    "processing_results": processing_result,
    "final_status": final_status,
    "next_action": next_action,
    "processing_complete": True
}

print(f"__OUTPUTS__ {json.dumps(summary_report)}")

end_lead_processed

script

Final step marking lead processing as complete

YAML Source

id: lead_qualification_complete_ai
name: Lead Qualification and Processing - Complete AI-Powered with Smart Routing
tasks:
- id: get_lead_data_from_crm
  name: Get Lead Data from CRM
  type: script
  script: "import os\nimport json\nfrom datetime import datetime\n\nprint(\"\U0001F4BC\
    \ LEAD DATA EXTRACTION FROM CRM\")\nprint(\"=\" * 60)\nprint(\"\U0001F504 Processing\
    \ new lead webhook trigger...\")\nprint(\"\")\n\n# Get input parameters\nexecution_id\
    \ = os.environ.get('EXECUTION_ID', 'unknown')\nlead_id = \"${lead_id}\"\nlead_name\
    \ = \"${lead_name}\"\nlead_email = \"${lead_email}\"\ncompany_name = \"${company_name}\"\
    \nindustry = \"${industry}\" or \"Unknown\"\nannual_revenue = \"${annual_revenue}\"\
    \ or 0\ntimezone = \"${timezone}\"\ntime_format = \"${time_format}\"\n\n# Process\
    \ annual revenue\ntry:\n    annual_revenue = int(annual_revenue) if annual_revenue\
    \ else 0\nexcept ValueError:\n    annual_revenue = 0\n    print(f\"\u26A0\uFE0F\
    \ Invalid annual revenue value: ${annual_revenue}\")\n\nprint(\"\U0001F4CB Lead\
    \ Details:\")\nprint(f\"   Execution ID: {execution_id}\")\nprint(f\"   Lead ID:\
    \ {lead_id}\")\nprint(f\"   Name: {lead_name}\")\nprint(f\"   Email: {lead_email}\"\
    )\nprint(f\"   Company: {company_name}\")\nprint(f\"   Industry: {industry}\"\
    )\nprint(f\"   Annual Revenue: ${annual_revenue:,}\")\nprint(f\"   Timezone: {timezone}\"\
    )\nprint(f\"   Time Format: {time_format}\")\nprint(\"\")\n\n# Extract domain\
    \ from email for company matching\nemail_domain = lead_email.split('@')[1] if\
    \ '@' in lead_email else 'unknown.com'\n\n# Simulate CRM data enrichment\ncrm_data\
    \ = {\n    \"lead_source\": \"Website Form\",\n    \"campaign_id\": \"CAMP_2024_Q1\"\
    ,\n    \"utm_source\": \"google\",\n    \"utm_medium\": \"cpc\",\n    \"lead_status\"\
    : \"New\",\n    \"created_date\": datetime.now().isoformat(),\n    \"last_activity\"\
    : \"Form Submission\",\n    \"phone\": \"+1-555-0123\",\n    \"job_title\": \"\
    VP of Sales\",\n    \"company_size\": \"51-200 employees\",\n    \"website\":\
    \ f\"https://www.{email_domain}\"\n}\n\nprint(\"\U0001F4CA Additional CRM Data:\"\
    )\nprint(f\"   Source: {crm_data['lead_source']}\")\nprint(f\"   Campaign: {crm_data['campaign_id']}\"\
    )\nprint(f\"   Job Title: {crm_data['job_title']}\")\nprint(f\"   Company Size:\
    \ {crm_data['company_size']}\")\nprint(f\"   Website: {crm_data['website']}\"\
    )\nprint(\"\")\n\nprint(\"\u2705 Lead data extracted successfully\")\nprint(\"\
    \u27A1\uFE0F Proceeding to historical data analysis...\")\n\n# Output structured\
    \ lead data\nresult = {\n    \"status\": \"completed\",\n    \"execution_id\"\
    : execution_id,\n    \"lead_data\": {\n        \"lead_id\": lead_id,\n       \
    \ \"name\": lead_name,\n        \"email\": lead_email,\n        \"company\": company_name,\n\
    \        \"industry\": industry,\n        \"annual_revenue\": annual_revenue,\n\
    \        \"email_domain\": email_domain\n    },\n    \"crm_enrichment\": crm_data,\n\
    \    \"timezone\": timezone,\n    \"time_format\": time_format,\n    \"timestamp\"\
    : datetime.now().isoformat()\n}\n\nprint(f\"__OUTPUTS__ {json.dumps(result)}\"\
    )\n"
  description: Extract and initialize lead data from CRM webhook trigger
  timeout_seconds: 30
- id: get_historical_data_from_bigquery
  name: Get Historical Data from BigQuery
  type: script
  script: "import json\nimport time\nfrom datetime import datetime, timedelta\nimport\
    \ random\n\nprint(\"\U0001F4CA HISTORICAL DATA ANALYSIS FROM BIGQUERY\")\nprint(\"\
    =\" * 60)\nprint(\"\")\n\n# Get lead data from previous step\nlead_email = \"\
    ${get_lead_data_from_crm.lead_data.email}\"\ncompany_name = \"${get_lead_data_from_crm.lead_data.company}\"\
    \nindustry = \"${get_lead_data_from_crm.lead_data.industry}\"\nemail_domain =\
    \ \"${get_lead_data_from_crm.lead_data.email_domain}\"\n\nprint(f\"\U0001F50D\
    \ Analyzing historical data for: {company_name}\")\nprint(f\"   Industry: {industry}\"\
    )\nprint(f\"   Domain: {email_domain}\")\nprint(\"\")\n\ntry:\n    print(\"\U0001F310\
    \ Connecting to BigQuery...\")\n    time.sleep(2)  # Simulate BigQuery connection\n\
    \    \n    # Simulate historical data analysis\n    print(\"\u2713 Connected to\
    \ BigQuery successfully\")\n    print(\"\u2713 Querying historical lead data...\"\
    )\n    print(\"\u2713 Analyzing conversion patterns...\")\n    print(\"\u2713\
    \ Calculating industry benchmarks...\")\n    \n    # Generate mock historical\
    \ insights\n    historical_insights = {\n        \"total_leads_analyzed\": random.randint(5000,\
    \ 15000),\n        \"industry_conversion_rate\": round(random.uniform(0.12, 0.28),\
    \ 3),\n        \"average_deal_size\": random.randint(25000, 150000),\n       \
    \ \"average_sales_cycle_days\": random.randint(45, 120),\n        \"similar_companies_converted\"\
    : random.randint(15, 45),\n        \"domain_previous_leads\": random.randint(0,\
    \ 5),\n        \"seasonal_trends\": {\n            \"current_quarter_performance\"\
    : \"Above Average\",\n            \"best_conversion_month\": \"March\",\n    \
    \        \"industry_peak_season\": \"Q1-Q2\"\n        },\n        \"engagement_patterns\"\
    : {\n            \"email_open_rate\": round(random.uniform(0.25, 0.45), 3),\n\
    \            \"content_download_rate\": round(random.uniform(0.15, 0.35), 3),\n\
    \            \"demo_request_rate\": round(random.uniform(0.08, 0.18), 3)\n   \
    \     }\n    }\n    \n    # Calculate historical score based on patterns\n   \
    \ historical_score = 0\n    \n    # Industry performance factor\n    if historical_insights[\"\
    industry_conversion_rate\"] > 0.20:\n        historical_score += 25\n    elif\
    \ historical_insights[\"industry_conversion_rate\"] > 0.15:\n        historical_score\
    \ += 15\n    else:\n        historical_score += 5\n    \n    # Deal size factor\n\
    \    if historical_insights[\"average_deal_size\"] > 100000:\n        historical_score\
    \ += 20\n    elif historical_insights[\"average_deal_size\"] > 50000:\n      \
    \  historical_score += 15\n    else:\n        historical_score += 10\n    \n \
    \   # Domain history factor\n    if historical_insights[\"domain_previous_leads\"\
    ] > 0:\n        historical_score += 15\n        domain_status = \"Returning Domain\"\
    \n    else:\n        historical_score += 5\n        domain_status = \"New Domain\"\
    \n    \n    # Seasonal trends factor\n    if historical_insights[\"seasonal_trends\"\
    ][\"current_quarter_performance\"] == \"Above Average\":\n        historical_score\
    \ += 10\n    \n    print(\"\")\n    print(\"\U0001F4CA Historical Analysis Results:\"\
    )\n    print(f\"   Industry Conversion Rate: {historical_insights['industry_conversion_rate']*100:.1f}%\"\
    )\n    print(f\"   Average Deal Size: ${historical_insights['average_deal_size']:,}\"\
    )\n    print(f\"   Sales Cycle: {historical_insights['average_sales_cycle_days']}\
    \ days\")\n    print(f\"   Domain Status: {domain_status}\")\n    print(f\"  \
    \ Historical Score: {historical_score}/70\")\n    \n    result = {\n        \"\
    status\": \"completed\",\n        \"historical_insights\": historical_insights,\n\
    \        \"historical_score\": historical_score,\n        \"domain_status\": domain_status,\n\
    \        \"analysis_timestamp\": datetime.now().isoformat(),\n        \"data_source\"\
    : \"BigQuery Historical Analysis\"\n    }\n    \n    print(\"\")\n    print(\"\
    \u2705 Historical analysis completed\")\n    \nexcept Exception as e:\n    result\
    \ = {\n        \"status\": \"error\",\n        \"error\": str(e),\n        \"\
    historical_score\": 0,\n        \"analysis_timestamp\": datetime.now().isoformat()\n\
    \    }\n    print(f\"\u274C Historical analysis failed: {e}\")\n\nprint(f\"__OUTPUTS__\
    \ {json.dumps(result)}\")\n"
  depends_on:
  - get_lead_data_from_crm
  description: Retrieve and analyze historical data from BigQuery for lead scoring
  previous_node: get_lead_data_from_crm
  timeout_seconds: 45
- id: get_similar_leads_from_dynamics
  name: Get Similar Leads from Dynamics
  type: script
  script: "import json\nimport time\nimport random\nfrom datetime import datetime\n\
    \nprint(\"\U0001F50D SIMILAR LEADS ANALYSIS FROM DYNAMICS\")\nprint(\"=\" * 60)\n\
    print(\"\")\n\n# Get data from previous steps\ncompany_name = \"${get_lead_data_from_crm.lead_data.company}\"\
    \nindustry = \"${get_lead_data_from_crm.lead_data.industry}\"\nannual_revenue\
    \ = \"${get_lead_data_from_crm.lead_data.annual_revenue}\"\njob_title = \"${get_lead_data_from_crm.crm_enrichment.job_title}\"\
    \ncompany_size = \"${get_lead_data_from_crm.crm_enrichment.company_size}\"\n\n\
    print(f\"\U0001F3AF Searching for similar leads to: {company_name}\")\nprint(f\"\
    \   Industry: {industry}\")\nprint(f\"   Revenue: ${annual_revenue:,}\" if annual_revenue\
    \ else \"   Revenue: Unknown\")\nprint(f\"   Job Title: {job_title}\")\nprint(f\"\
    \   Company Size: {company_size}\")\nprint(\"\")\n\ntry:\n    print(\"\U0001F310\
    \ Connecting to Dynamics CRM...\")\n    time.sleep(2)  # Simulate Dynamics connection\n\
    \    \n    print(\"\u2713 Connected to Dynamics successfully\")\n    print(\"\u2713\
    \ Searching for similar industry leads...\")\n    print(\"\u2713 Analyzing job\
    \ title patterns...\")\n    print(\"\u2713 Matching company size criteria...\"\
    )\n    print(\"\u2713 Evaluating revenue segments...\")\n    \n    # Generate\
    \ mock similar leads data\n    similar_leads_count = random.randint(8, 25)\n \
    \   converted_leads = random.randint(2, 8)\n    conversion_rate = round(converted_leads\
    \ / similar_leads_count, 3)\n    \n    similar_leads_data = {\n        \"total_similar_leads\"\
    : similar_leads_count,\n        \"converted_leads\": converted_leads,\n      \
    \  \"conversion_rate\": conversion_rate,\n        \"average_time_to_conversion\"\
    : random.randint(30, 90),\n        \"common_objections\": [\n            \"Budget\
    \ constraints\",\n            \"Timeline concerns\",\n            \"Feature requirements\"\
    \n        ],\n        \"successful_tactics\": [\n            \"Product demo\"\
    ,\n            \"ROI calculator\",\n            \"Case study presentation\"\n\
    \        ],\n        \"similar_lead_profiles\": [\n            {\n           \
    \     \"company\": \"TechCorp Inc\",\n                \"industry\": industry,\n\
    \                \"status\": \"Converted\",\n                \"deal_value\": random.randint(45000,\
    \ 120000),\n                \"conversion_time_days\": random.randint(25, 85)\n\
    \            },\n            {\n                \"company\": \"InnoSoft Ltd\"\
    ,\n                \"industry\": industry,\n                \"status\": \"Converted\"\
    ,\n                \"deal_value\": random.randint(35000, 95000),\n           \
    \     \"conversion_time_days\": random.randint(40, 75)\n            },\n     \
    \       {\n                \"company\": \"DataFlow Systems\",\n              \
    \  \"industry\": industry,\n                \"status\": \"Lost\",\n          \
    \      \"reason\": \"Budget constraints\",\n                \"engagement_duration\"\
    : random.randint(15, 45)\n            }\n        ]\n    }\n    \n    # Calculate\
    \ similarity score\n    similarity_score = 0\n    \n    # Conversion rate factor\n\
    \    if conversion_rate > 0.30:\n        similarity_score += 25\n    elif conversion_rate\
    \ > 0.20:\n        similarity_score += 20\n    elif conversion_rate > 0.15:\n\
    \        similarity_score += 15\n    else:\n        similarity_score += 10\n \
    \   \n    # Sample size factor\n    if similar_leads_count > 20:\n        similarity_score\
    \ += 15\n    elif similar_leads_count > 10:\n        similarity_score += 10\n\
    \    else:\n        similarity_score += 5\n    \n    # Time to conversion factor\n\
    \    if similar_leads_data[\"average_time_to_conversion\"] < 60:\n        similarity_score\
    \ += 10\n    else:\n        similarity_score += 5\n    \n    print(\"\")\n   \
    \ print(\"\U0001F4CA Similar Leads Analysis:\")\n    print(f\"   Similar Leads\
    \ Found: {similar_leads_count}\")\n    print(f\"   Conversion Rate: {conversion_rate*100:.1f}%\"\
    )\n    print(f\"   Average Conversion Time: {similar_leads_data['average_time_to_conversion']}\
    \ days\")\n    print(f\"   Similarity Score: {similarity_score}/50\")\n    \n\
    \    result = {\n        \"status\": \"completed\",\n        \"similar_leads_data\"\
    : similar_leads_data,\n        \"similarity_score\": similarity_score,\n     \
    \   \"pattern_confidence\": \"High\" if similarity_score > 35 else \"Medium\"\
    \ if similarity_score > 25 else \"Low\",\n        \"analysis_timestamp\": datetime.now().isoformat(),\n\
    \        \"data_source\": \"Dynamics CRM Similar Leads Analysis\"\n    }\n   \
    \ \n    print(\"\")\n    print(\"\u2705 Similar leads analysis completed\")\n\
    \    \nexcept Exception as e:\n    result = {\n        \"status\": \"error\",\n\
    \        \"error\": str(e),\n        \"similarity_score\": 0,\n        \"pattern_confidence\"\
    : \"Low\",\n        \"analysis_timestamp\": datetime.now().isoformat()\n    }\n\
    \    print(f\"\u274C Similar leads analysis failed: {e}\")\n\nprint(f\"__OUTPUTS__\
    \ {json.dumps(result)}\")\n"
  depends_on:
  - get_historical_data_from_bigquery
  description: Find and analyze similar leads from Dynamics for pattern matching
  previous_node: get_historical_data_from_bigquery
  timeout_seconds: 45
- id: get_sales_officer_workload
  name: Get Sales Officer Workload
  type: script
  script: "import json\nimport random\nfrom datetime import datetime\n\nprint(\"\U0001F464\
    \ SALES OFFICER WORKLOAD ANALYSIS\")\nprint(\"=\" * 60)\nprint(\"\")\n\n# Get\
    \ industry from previous steps for specialization matching\nindustry = \"${get_lead_data_from_crm.lead_data.industry}\"\
    \nannual_revenue = \"${get_lead_data_from_crm.lead_data.annual_revenue}\"\n\n\
    print(f\"\U0001F50D Analyzing workload for {industry} industry lead\")\nprint(f\"\
    \   Deal Size Category: {'Enterprise' if annual_revenue and int(annual_revenue)\
    \ > 100000 else 'Mid-Market' if annual_revenue and int(annual_revenue) > 25000\
    \ else 'SMB'}\")\nprint(\"\")\n\ntry:\n    print(\"\U0001F310 Connecting to Sales\
    \ Team Management System...\")\n    print(\"\u2713 Retrieving active sales officers...\"\
    )\n    print(\"\u2713 Analyzing current workloads...\")\n    print(\"\u2713 Checking\
    \ specializations...\")\n    print(\"\u2713 Evaluating performance metrics...\"\
    )\n    \n    # Generate mock sales officer data\n    sales_officers = [\n    \
    \    {\n            \"officer_id\": \"SO001\",\n            \"name\": \"Sarah\
    \ Johnson\",\n            \"specialization\": [industry, \"Enterprise Sales\"\
    ],\n            \"current_leads\": random.randint(8, 15),\n            \"active_deals\"\
    : random.randint(3, 8),\n            \"capacity_utilization\": round(random.uniform(0.65,\
    \ 0.85), 2),\n            \"conversion_rate\": round(random.uniform(0.22, 0.35),\
    \ 3),\n            \"average_deal_size\": random.randint(75000, 150000),\n   \
    \         \"response_time_hours\": round(random.uniform(2, 8), 1),\n         \
    \   \"availability_score\": random.randint(75, 95)\n        },\n        {\n  \
    \          \"officer_id\": \"SO002\",\n            \"name\": \"Michael Chen\"\
    ,\n            \"specialization\": [\"Technology\", \"Mid-Market\"],\n       \
    \     \"current_leads\": random.randint(12, 20),\n            \"active_deals\"\
    : random.randint(5, 12),\n            \"capacity_utilization\": round(random.uniform(0.75,\
    \ 0.95), 2),\n            \"conversion_rate\": round(random.uniform(0.18, 0.28),\
    \ 3),\n            \"average_deal_size\": random.randint(35000, 85000),\n    \
    \        \"response_time_hours\": round(random.uniform(3, 12), 1),\n         \
    \   \"availability_score\": random.randint(60, 80)\n        },\n        {\n  \
    \          \"officer_id\": \"SO003\",\n            \"name\": \"Emily Rodriguez\"\
    ,\n            \"specialization\": [industry, \"SMB Sales\"],\n            \"\
    current_leads\": random.randint(15, 25),\n            \"active_deals\": random.randint(8,\
    \ 15),\n            \"capacity_utilization\": round(random.uniform(0.70, 0.90),\
    \ 2),\n            \"conversion_rate\": round(random.uniform(0.25, 0.38), 3),\n\
    \            \"average_deal_size\": random.randint(15000, 45000),\n          \
    \  \"response_time_hours\": round(random.uniform(1, 6), 1),\n            \"availability_score\"\
    : random.randint(80, 95)\n        }\n    ]\n    \n    # Calculate recommendation\
    \ scores for each officer\n    for officer in sales_officers:\n        score =\
    \ 0\n        \n        # Specialization match\n        if industry in officer[\"\
    specialization\"]:\n            score += 30\n        else:\n            score\
    \ += 10\n        \n        # Capacity availability (lower utilization = higher\
    \ score)\n        if officer[\"capacity_utilization\"] < 0.75:\n            score\
    \ += 25\n        elif officer[\"capacity_utilization\"] < 0.85:\n            score\
    \ += 15\n        else:\n            score += 5\n        \n        # Conversion\
    \ rate performance\n        if officer[\"conversion_rate\"] > 0.30:\n        \
    \    score += 20\n        elif officer[\"conversion_rate\"] > 0.25:\n        \
    \    score += 15\n        else:\n            score += 10\n        \n        #\
    \ Response time\n        if officer[\"response_time_hours\"] < 4:\n          \
    \  score += 15\n        elif officer[\"response_time_hours\"] < 8:\n         \
    \   score += 10\n        else:\n            score += 5\n        \n        # Availability\
    \ score\n        if officer[\"availability_score\"] > 85:\n            score +=\
    \ 10\n        elif officer[\"availability_score\"] > 75:\n            score +=\
    \ 5\n        \n        officer[\"recommendation_score\"] = score\n    \n    #\
    \ Sort by recommendation score\n    sales_officers.sort(key=lambda x: x[\"recommendation_score\"\
    ], reverse=True)\n    recommended_officer = sales_officers[0]\n    \n    print(\"\
    \")\n    print(\"\U0001F4CA Sales Officer Analysis Results:\")\n    print(f\"\
    \   Total Officers Analyzed: {len(sales_officers)}\")\n    print(f\"   Recommended\
    \ Officer: {recommended_officer['name']}\")\n    print(f\"   Specialization Match:\
    \ {'\u2713' if industry in recommended_officer['specialization'] else '\u2717\
    '}\")\n    print(f\"   Capacity Utilization: {recommended_officer['capacity_utilization']*100:.0f}%\"\
    )\n    print(f\"   Recommendation Score: {recommended_officer['recommendation_score']}/100\"\
    )\n    \n    result = {\n        \"status\": \"completed\",\n        \"sales_officers\"\
    : sales_officers,\n        \"recommended_officer\": recommended_officer,\n   \
    \     \"team_capacity\": {\n            \"total_officers\": len(sales_officers),\n\
    \            \"average_utilization\": round(sum(o[\"capacity_utilization\"] for\
    \ o in sales_officers) / len(sales_officers), 2),\n            \"specialization_coverage\"\
    : industry in [spec for officer in sales_officers for spec in officer[\"specialization\"\
    ]]\n        },\n        \"analysis_timestamp\": datetime.now().isoformat(),\n\
    \        \"data_source\": \"Sales Team Management System\"\n    }\n    \n    print(\"\
    \")\n    print(\"\u2705 Sales officer workload analysis completed\")\n    \nexcept\
    \ Exception as e:\n    result = {\n        \"status\": \"error\",\n        \"\
    error\": str(e),\n        \"recommended_officer\": None,\n        \"analysis_timestamp\"\
    : datetime.now().isoformat()\n    }\n    print(f\"\u274C Sales officer analysis\
    \ failed: {e}\")\n\nprint(f\"__OUTPUTS__ {json.dumps(result)}\")\n"
  depends_on:
  - get_similar_leads_from_dynamics
  description: Analyze current sales officer workload for optimal assignment
  previous_node: get_similar_leads_from_dynamics
  timeout_seconds: 30
- id: calculate_lead_score
  name: Calculate Lead Score
  type: ai_agent
  config:
    model_client_id: lead_scorer
  depends_on:
  - get_sales_officer_workload
  description: AI-powered lead scoring combining all data sources
  user_message: 'Calculate comprehensive lead score for:

    Lead Data: ${get_lead_data_from_crm.lead_data} CRM Enrichment: ${get_lead_data_from_crm.crm_enrichment}

    Historical Analysis: ${get_historical_data_from_bigquery.historical_insights}
    Historical Score: ${get_historical_data_from_bigquery.historical_score}

    Similar Leads: ${get_similar_leads_from_dynamics.similar_leads_data} Similarity
    Score: ${get_similar_leads_from_dynamics.similarity_score}

    Sales Team Analysis: ${get_sales_officer_workload.team_capacity} Recommended Officer:
    ${get_sales_officer_workload.recommended_officer}

    '
  previous_node: get_sales_officer_workload
  system_message: "You are an expert lead scoring analyst specializing in B2B sales\
    \ qualification.\n\nAnalyze all available data and calculate a comprehensive lead\
    \ score from 0-100 based on:\n- Lead demographic data (company, industry, revenue)\n\
    - Historical conversion patterns\n- Similar lead performance\n- Sales team capacity\
    \ and specialization\n\nProvide your analysis in JSON format:\n{\n  \"overall_lead_score\"\
    : 0-100,\n  \"score_breakdown\": {\n    \"demographic_score\": 0-30,\n    \"historical_score\"\
    : 0-25,\n    \"similarity_score\": 0-25,\n    \"timing_score\": 0-20\n  },\n \
    \ \"scoring_rationale\": \"Detailed explanation of scoring factors\",\n  \"confidence_level\"\
    : \"High|Medium|Low\",\n  \"key_strengths\": [\"strength1\", \"strength2\"],\n\
    \  \"potential_concerns\": [\"concern1\", \"concern2\"],\n  \"predicted_conversion_probability\"\
    : 0.0-1.0\n}\n"
- id: determine_qualification_status
  name: Determine Qualification Status
  type: script
  script: "import json\nfrom datetime import datetime\n\nprint(\"\U0001F4CA LEAD QUALIFICATION\
    \ DETERMINATION\")\nprint(\"=\" * 60)\nprint(\"\")\n\n# Get lead score from AI\
    \ analysis\nlead_score_data = '''${calculate_lead_score}'''\n\ntry:\n    # Parse\
    \ the AI scoring results\n    scoring_results = json.loads(lead_score_data)\n\
    \    overall_lead_score = scoring_results.get('overall_lead_score', 0)\n    confidence_level\
    \ = scoring_results.get('confidence_level', 'Low')\n    conversion_probability\
    \ = scoring_results.get('predicted_conversion_probability', 0.0)\n    \n    print(f\"\
    \U0001F4CA Lead Scoring Results:\")\n    print(f\"   Overall Score: {overall_lead_score}/100\"\
    )\n    print(f\"   Confidence Level: {confidence_level}\")\n    print(f\"   Conversion\
    \ Probability: {conversion_probability*100:.1f}%\")\n    print(\"\")\n    \n \
    \   # Qualification threshold is 70\n    qualification_threshold = 70\n    \n\
    \    print(f\"\U0001F3AF Qualification Threshold: {qualification_threshold}\"\
    )\n    print(f\"   Lead Score: {overall_lead_score}\")\n    print(f\"   Status:\
    \ {'ABOVE' if overall_lead_score >= qualification_threshold else 'BELOW'} threshold\"\
    )\n    print(\"\")\n    \n    # Determine routing based on score\n    if overall_lead_score\
    \ >= qualification_threshold:\n        qualification_status = \"QUALIFIED\"\n\
    \        next_action = \"route_to_sales\"\n        priority_level = \"High\" if\
    \ overall_lead_score >= 85 else \"Medium\"\n        print(\"\u2705 QUALIFICATION\
    \ DECISION: QUALIFIED\")\n        print(f\"   Priority Level: {priority_level}\"\
    )\n        print(\"   Next Action: Route to Sales Officer\")\n    else:\n    \
    \    qualification_status = \"UNQUALIFIED\"\n        next_action = \"schedule_followup\"\
    \n        priority_level = \"Low\"\n        print(\"\u274C QUALIFICATION DECISION:\
    \ UNQUALIFIED\")\n        print(\"   Priority Level: Low\")\n        print(\"\
    \   Next Action: Schedule Follow-up\")\n    \n    print(\"\")\n    print(\"\u27A1\
    \uFE0F Proceeding to conditional routing...\")\n    \n    result = {\n       \
    \ \"status\": \"completed\",\n        \"qualification_status\": qualification_status,\n\
    \        \"lead_score\": overall_lead_score,\n        \"qualification_threshold\"\
    : qualification_threshold,\n        \"meets_threshold\": overall_lead_score >=\
    \ qualification_threshold,\n        \"next_action\": next_action,\n        \"\
    priority_level\": priority_level,\n        \"scoring_details\": scoring_results,\n\
    \        \"decision_timestamp\": datetime.now().isoformat(),\n        \"routing_decision\"\
    : \"qualified_path\" if qualification_status == \"QUALIFIED\" else \"unqualified_path\"\
    \n    }\n    \nexcept Exception as e:\n    print(f\"\u274C Error processing lead\
    \ score: {e}\")\n    result = {\n        \"status\": \"error\",\n        \"qualification_status\"\
    : \"UNQUALIFIED\",\n        \"lead_score\": 0,\n        \"next_action\": \"manual_review\"\
    ,\n        \"error\": str(e)\n    }\n\nprint(f\"__OUTPUTS__ {json.dumps(result)}\"\
    )\n"
  depends_on:
  - calculate_lead_score
  description: Determine qualification status and route based on lead score
  previous_node: calculate_lead_score
  timeout_seconds: 30
- id: qualification_router
  name: Lead Qualification Router
  type: conditional_router
  conditions:
  - name: qualified_lead
    route: qualified_path
    condition: ${determine_qualification_status.qualification_status} == 'QUALIFIED'
  depends_on:
  - determine_qualification_status
  description: Routes qualified leads to sales team or unqualified leads to follow-up
  default_route: unqualified_path
  previous_node: determine_qualification_status
- id: process_qualified_lead
  name: Process Qualified Lead
  type: script
  script: "import json\nimport time\nfrom datetime import datetime\n\nprint(\"\u2705\
    \ PROCESSING QUALIFIED LEAD\")\nprint(\"=\" * 50)\nprint(\"\")\n\n# Get data from\
    \ previous steps\nlead_data = '''${get_lead_data_from_crm.lead_data}'''\nrecommended_officer_data\
    \ = '''${get_sales_officer_workload.recommended_officer}'''\nscoring_data = '''${determine_qualification_status.scoring_details}'''\n\
    \ntry:\n    lead_info = json.loads(lead_data)\n    officer_info = json.loads(recommended_officer_data)\n\
    \    scoring_info = json.loads(scoring_data)\n    \n    lead_name = lead_info['name']\n\
    \    company_name = lead_info['company']\n    lead_score = scoring_info.get('overall_lead_score',\
    \ 0)\n    officer_name = officer_info['name']\n    officer_id = officer_info['officer_id']\n\
    \    \n    print(f\"\U0001F464 Recommended Sales Officer: {officer_name} ({officer_id})\"\
    )\n    print(f\"   Lead: {lead_name} from {company_name}\")\n    print(f\"   Lead\
    \ Score: {lead_score}/100\")\n    print(\"\")\n    \n    # Step 1: Create Deal\
    \ in CRM\n    print(\"\U0001F4BC Creating deal in CRM...\")\n    time.sleep(2)\
    \  # Simulate CRM API call\n    \n    deal_data = {\n        \"deal_id\": f\"\
    DEAL_{int(time.time())}\",\n        \"deal_name\": f\"{company_name} - {lead_name}\"\
    ,\n        \"lead_id\": lead_info['lead_id'],\n        \"assigned_officer\": officer_id,\n\
    \        \"stage\": \"Qualification\",\n        \"probability\": f\"{scoring_info.get('predicted_conversion_probability',\
    \ 0.5)*100:.0f}%\",\n        \"estimated_value\": officer_info.get('average_deal_size',\
    \ 50000),\n        \"created_date\": datetime.now().isoformat(),\n        \"priority\"\
    : \"High\" if lead_score >= 85 else \"Medium\"\n    }\n    \n    print(\"\u2713\
    \ Deal created successfully\")\n    print(f\"   Deal ID: {deal_data['deal_id']}\"\
    )\n    print(f\"   Estimated Value: ${deal_data['estimated_value']:,}\")\n   \
    \ print(f\"   Priority: {deal_data['priority']}\")\n    \n    # Step 2: Update\
    \ CRM Lead Status\n    print(\"\")\n    print(\"\U0001F504 Updating CRM lead status...\"\
    )\n    time.sleep(1)\n    \n    crm_update = {\n        \"lead_id\": lead_info['lead_id'],\n\
    \        \"status\": \"Qualified\",\n        \"assigned_officer\": officer_id,\n\
    \        \"qualification_date\": datetime.now().isoformat(),\n        \"lead_score\"\
    : lead_score,\n        \"deal_id\": deal_data['deal_id']\n    }\n    \n    print(\"\
    \u2713 CRM lead status updated to 'Qualified'\")\n    \n    # Step 3: Log Activity\
    \ in Dynamics\n    print(\"\")\n    print(\"\U0001F4DD Logging activity in Dynamics...\"\
    )\n    time.sleep(1)\n    \n    activity_log = {\n        \"activity_id\": f\"\
    ACT_{int(time.time())}\",\n        \"type\": \"Lead Qualification\",\n       \
    \ \"lead_id\": lead_info['lead_id'],\n        \"deal_id\": deal_data['deal_id'],\n\
    \        \"description\": f\"Lead qualified with score {lead_score}/100 and assigned\
    \ to {officer_name}\",\n        \"created_by\": \"AI Lead Qualification System\"\
    ,\n        \"timestamp\": datetime.now().isoformat()\n    }\n    \n    print(\"\
    \u2713 Activity logged in Dynamics\")\n    print(f\"   Activity ID: {activity_log['activity_id']}\"\
    )\n    \n    # Step 4: Notify Sales Officer\n    print(\"\")\n    print(f\"\U0001F514\
    \ Notifying sales officer: {officer_name}...\")\n    time.sleep(1)\n    \n   \
    \ notification = {\n        \"notification_id\": f\"NOTIF_{int(time.time())}\"\
    ,\n        \"recipient\": officer_id,\n        \"subject\": f\"New Qualified Lead:\
    \ {lead_name} from {company_name}\",\n        \"message\": f\"You have been assigned\
    \ a new qualified lead with a score of {lead_score}/100. Deal ID: {deal_data['deal_id']}\"\
    ,\n        \"priority\": deal_data['priority'],\n        \"sent_timestamp\": datetime.now().isoformat()\n\
    \    }\n    \n    print(\"\u2713 Sales officer notified\")\n    print(f\"   Notification\
    \ sent to: {officer_name}\")\n    \n    result = {\n        \"status\": \"completed\"\
    ,\n        \"processing_type\": \"Qualified Lead Processing\",\n        \"deal_created\"\
    : deal_data,\n        \"crm_updated\": crm_update,\n        \"activity_logged\"\
    : activity_log,\n        \"notification_sent\": notification,\n        \"next_steps\"\
    : [\n            \"Sales officer to contact lead within 24 hours\",\n        \
    \    \"Schedule discovery call\",\n            \"Send welcome package\"\n    \
    \    ],\n        \"processing_timestamp\": datetime.now().isoformat()\n    }\n\
    \    \n    print(\"\")\n    print(\"\u2705 Qualified lead processing completed\
    \ successfully\")\n    \nexcept Exception as e:\n    result = {\n        \"status\"\
    : \"error\",\n        \"error\": str(e),\n        \"processing_type\": \"Qualified\
    \ Lead Processing\"\n    }\n    print(f\"\u274C Qualified lead processing failed:\
    \ {e}\")\n\nprint(f\"__OUTPUTS__ {json.dumps(result)}\")\n"
  depends_on:
  - determine_qualification_status
  - qualification_router
  description: Process qualified leads - recommend sales officer and create deal
  previous_node: qualification_router
  timeout_seconds: 45
  execute_on_routes:
  - qualified_path
- id: process_unqualified_lead
  name: Process Unqualified Lead
  type: script
  script: "import json\nimport time\nfrom datetime import datetime, timedelta\n\n\
    print(\"\u26A0\uFE0F PROCESSING UNQUALIFIED LEAD\")\nprint(\"=\" * 50)\nprint(\"\
    \")\n\n# Get data from previous steps\nlead_data = '''${get_lead_data_from_crm.lead_data}'''\n\
    scoring_data = '''${determine_qualification_status.scoring_details}'''\n\ntry:\n\
    \    lead_info = json.loads(lead_data)\n    scoring_info = json.loads(scoring_data)\n\
    \    \n    lead_name = lead_info['name']\n    company_name = lead_info['company']\n\
    \    lead_score = scoring_info.get('overall_lead_score', 0)\n    concerns = scoring_info.get('potential_concerns',\
    \ [])\n    \n    print(f\"\U0001F464 Lead: {lead_name} from {company_name}\")\n\
    \    print(f\"   Lead Score: {lead_score}/100 (Below threshold of 70)\")\n   \
    \ print(f\"   Key Concerns: {', '.join(concerns[:2]) if concerns else 'General\
    \ qualification criteria not met'}\")\n    print(\"\")\n    \n    # Step 1: Update\
    \ CRM Lead Status to Unqualified\n    print(\"\U0001F504 Updating CRM lead status...\"\
    )\n    time.sleep(1)\n    \n    crm_update = {\n        \"lead_id\": lead_info['lead_id'],\n\
    \        \"status\": \"Unqualified\",\n        \"unqualification_date\": datetime.now().isoformat(),\n\
    \        \"lead_score\": lead_score,\n        \"unqualification_reason\": f\"\
    Score {lead_score}/100 below threshold. Concerns: {', '.join(concerns[:2]) if\
    \ concerns else 'General criteria not met'}\",\n        \"assigned_officer\":\
    \ None\n    }\n    \n    print(\"\u2713 CRM lead status updated to 'Unqualified'\"\
    )\n    \n    # Step 2: Schedule Follow-up\n    print(\"\")\n    print(\"\U0001F4C5\
    \ Scheduling follow-up activities...\")\n    time.sleep(1)\n    \n    # Determine\
    \ follow-up strategy based on score\n    if lead_score >= 50:\n        followup_strategy\
    \ = \"nurturing_campaign\"\n        followup_interval = 30  # days\n        followup_type\
    \ = \"Email nurturing sequence\"\n    elif lead_score >= 30:\n        followup_strategy\
    \ = \"quarterly_check\"\n        followup_interval = 90  # days\n        followup_type\
    \ = \"Quarterly touchpoint\"\n    else:\n        followup_strategy = \"annual_review\"\
    \n        followup_interval = 365  # days\n        followup_type = \"Annual market\
    \ review\"\n    \n    followup_date = (datetime.now() + timedelta(days=followup_interval)).isoformat()\n\
    \    \n    followup_schedule = {\n        \"followup_id\": f\"FOLLOWUP_{int(time.time())}\"\
    ,\n        \"lead_id\": lead_info['lead_id'],\n        \"strategy\": followup_strategy,\n\
    \        \"type\": followup_type,\n        \"scheduled_date\": followup_date,\n\
    \        \"interval_days\": followup_interval,\n        \"automated\": True,\n\
    \        \"description\": f\"Automated follow-up for lead with score {lead_score}/100\"\
    \n    }\n    \n    print(f\"\u2713 Follow-up scheduled: {followup_type}\")\n \
    \   print(f\"   Next Contact: {followup_date[:10]}\")\n    print(f\"   Strategy:\
    \ {followup_strategy}\")\n    \n    # Step 3: Add to appropriate nurturing list\n\
    \    print(\"\")\n    print(\"\U0001F4E7 Adding to nurturing campaign...\")\n\
    \    time.sleep(1)\n    \n    nurturing_assignment = {\n        \"campaign_id\"\
    : f\"NURTURE_{followup_strategy.upper()}\",\n        \"lead_id\": lead_info['lead_id'],\n\
    \        \"campaign_type\": followup_strategy,\n        \"enrolled_date\": datetime.now().isoformat(),\n\
    \        \"email_sequence\": True,\n        \"content_personalization\": {\n \
    \           \"industry\": lead_info.get('industry', 'General'),\n            \"\
    company_size\": \"SMB\" if lead_score < 40 else \"Mid-Market\"\n        }\n  \
    \  }\n    \n    print(f\"\u2713 Added to nurturing campaign: {nurturing_assignment['campaign_id']}\"\
    )\n    \n    result = {\n        \"status\": \"completed\",\n        \"processing_type\"\
    : \"Unqualified Lead Processing\",\n        \"crm_updated\": crm_update,\n   \
    \     \"followup_scheduled\": followup_schedule,\n        \"nurturing_assigned\"\
    : nurturing_assignment,\n        \"recommendations\": [\n            \"Monitor\
    \ for company growth/changes\",\n            \"Track engagement with nurturing\
    \ content\",\n            \"Re-evaluate qualification criteria periodically\"\n\
    \        ],\n        \"processing_timestamp\": datetime.now().isoformat()\n  \
    \  }\n    \n    print(\"\")\n    print(\"\u2705 Unqualified lead processing completed\"\
    )\n    print(\"   Lead will be nurtured and re-evaluated based on engagement\"\
    )\n    \nexcept Exception as e:\n    result = {\n        \"status\": \"error\"\
    ,\n        \"error\": str(e),\n        \"processing_type\": \"Unqualified Lead\
    \ Processing\"\n    }\n    print(f\"\u274C Unqualified lead processing failed:\
    \ {e}\")\n\nprint(f\"__OUTPUTS__ {json.dumps(result)}\")\n"
  depends_on:
  - determine_qualification_status
  - qualification_router
  description: Process unqualified leads - update status and schedule follow-up
  previous_node: qualification_router
  timeout_seconds: 30
  execute_on_routes:
  - unqualified_path
- id: qualification_summary
  name: Qualification Summary Report
  type: script
  script: "import json\nfrom datetime import datetime\n\nprint(\"\")\nprint(\"=\"\
    \ * 70)\nprint(\"\U0001F4CA LEAD QUALIFICATION SUMMARY REPORT\")\nprint(\"=\"\
    \ * 70)\nprint(\"\")\n\n# Get basic lead information\nlead_info = json.loads('''${get_lead_data_from_crm.lead_data}''')\n\
    qualification_result = json.loads('''${determine_qualification_status}''')\n\n\
    lead_name = lead_info['name']\ncompany_name = lead_info['company']\nlead_id =\
    \ lead_info['lead_id']\nqualification_status = qualification_result['qualification_status']\n\
    lead_score = qualification_result['lead_score']\n\nprint(f\"Lead ID: {lead_id}\"\
    )\nprint(f\"Contact: {lead_name}\")\nprint(f\"Company: {company_name}\")\nprint(f\"\
    Final Score: {lead_score}/100\")\nprint(f\"Status: {qualification_status}\")\n\
    print(f\"Report Generated: {datetime.now().isoformat()}\")\nprint(\"\")\n\n# Determine\
    \ which processing path was taken and get results\nprocessing_result = None\n\
    processing_type = None\n\nif qualification_status == \"QUALIFIED\":\n    try:\n\
    \        processing_data = '''${process_qualified_lead}'''\n        processing_result\
    \ = json.loads(processing_data)\n        processing_type = \"Qualified Lead Processing\"\
    \n    except:\n        processing_result = {\"status\": \"error\", \"error\":\
    \ \"Failed to parse qualified processing data\"}\nelse:\n    try:\n        processing_data\
    \ = '''${process_unqualified_lead}'''\n        processing_result = json.loads(processing_data)\n\
    \        processing_type = \"Unqualified Lead Processing\"\n    except:\n    \
    \    processing_result = {\"status\": \"error\", \"error\": \"Failed to parse\
    \ unqualified processing data\"}\n\nprint(\"PROCESSING RESULTS:\")\nprint(\"-\"\
    \ * 50)\nprint(f\"Processing Type: {processing_type}\")\nprint(f\"Processing Status:\
    \ {processing_result.get('status', 'Unknown')}\")\n\nif qualification_status ==\
    \ \"QUALIFIED\" and processing_result.get('status') == 'completed':\n    deal_info\
    \ = processing_result.get('deal_created', {})\n    officer_notification = processing_result.get('notification_sent',\
    \ {})\n    \n    print(f\"Deal Created: {deal_info.get('deal_id', 'N/A')}\")\n\
    \    print(f\"Estimated Value: ${deal_info.get('estimated_value', 0):,}\")\n \
    \   print(f\"Assigned Officer: {officer_notification.get('recipient', 'N/A')}\"\
    )\n    print(f\"Priority: {deal_info.get('priority', 'N/A')}\")\n    \nelif qualification_status\
    \ == \"UNQUALIFIED\" and processing_result.get('status') == 'completed':\n   \
    \ followup_info = processing_result.get('followup_scheduled', {})\n    nurturing_info\
    \ = processing_result.get('nurturing_assigned', {})\n    \n    print(f\"Follow-up\
    \ Strategy: {followup_info.get('strategy', 'N/A')}\")\n    print(f\"Next Contact:\
    \ {followup_info.get('scheduled_date', 'N/A')[:10]}\")\n    print(f\"Nurturing\
    \ Campaign: {nurturing_info.get('campaign_id', 'N/A')}\")\n\nprint(\"\")\n\n#\
    \ Final status determination\nif qualification_status == \"QUALIFIED\" and processing_result.get('status')\
    \ == 'completed':\n    final_status = \"SUCCESSFULLY_QUALIFIED\"\n    next_action\
    \ = \"Sales officer will contact lead within 24 hours\"\n    print(\"\u2705 FINAL\
    \ STATUS: Lead Successfully Qualified and Assigned\")\nelif qualification_status\
    \ == \"UNQUALIFIED\" and processing_result.get('status') == 'completed':\n   \
    \ final_status = \"PROPERLY_UNQUALIFIED\"\n    next_action = \"Lead entered into\
    \ nurturing campaign for future qualification\"\n    print(\"\u26A0\uFE0F FINAL\
    \ STATUS: Lead Properly Unqualified and Nurtured\")\nelse:\n    final_status =\
    \ \"PROCESSING_ERROR\"\n    next_action = \"Manual review required due to processing\
    \ errors\"\n    print(\"\u274C FINAL STATUS: Processing Error - Manual Review\
    \ Required\")\n\nprint(f\"Next Action: {next_action}\")\nprint(\"\")\nprint(\"\
    === LEAD PROCESSING COMPLETED ===\")\n\n# Create comprehensive summary\nsummary_report\
    \ = {\n    \"lead_summary\": {\n        \"lead_id\": lead_id,\n        \"contact_name\"\
    : lead_name,\n        \"company\": company_name,\n        \"final_score\": lead_score,\n\
    \        \"qualification_status\": qualification_status,\n        \"processing_timestamp\"\
    : datetime.now().isoformat()\n    },\n    \"qualification_details\": qualification_result,\n\
    \    \"processing_results\": processing_result,\n    \"final_status\": final_status,\n\
    \    \"next_action\": next_action,\n    \"processing_complete\": True\n}\n\nprint(f\"\
    __OUTPUTS__ {json.dumps(summary_report)}\")\n"
  depends_on:
  - process_qualified_lead
  - process_unqualified_lead
  description: Summarize qualification results and generate final status report
  previous_node:
  - process_qualified_lead
  - process_unqualified_lead
  timeout_seconds: 30
- id: end_lead_processed
  name: End - Lead Processed
  type: script
  script: "import json\nfrom datetime import datetime\n\nprint(\"\u2713 LEAD PROCESSING\
    \ WORKFLOW COMPLETED\")\nprint(\"=\" * 60)\nprint(\"\")\n\n# Get final summary\n\
    summary_data = json.loads('''${qualification_summary}''')\nlead_summary = summary_data['lead_summary']\n\
    final_status = summary_data['final_status']\n\nprint(f\"Lead: {lead_summary['contact_name']}\
    \ from {lead_summary['company']}\")\nprint(f\"Final Status: {final_status}\")\n\
    print(f\"Score: {lead_summary['final_score']}/100\")\nprint(f\"Completed: {datetime.now().isoformat()}\"\
    )\nprint(\"\")\n\n# Log completion\ncompletion_log = {\n    \"workflow_completed\"\
    : True,\n    \"completion_timestamp\": datetime.now().isoformat(),\n    \"lead_id\"\
    : lead_summary['lead_id'],\n    \"final_status\": final_status,\n    \"processing_summary\"\
    : summary_data,\n    \"workflow_duration\": \"Approximately 3-5 minutes\",\n \
    \   \"success\": final_status in [\"SUCCESSFULLY_QUALIFIED\", \"PROPERLY_UNQUALIFIED\"\
    ]\n}\n\nif completion_log['success']:\n    print(\"\u2705 Workflow completed successfully\"\
    )\nelse:\n    print(\"\u26A0\uFE0F Workflow completed with issues - manual review\
    \ recommended\")\n\nprint(\"\")\nprint(\"Thank you for using the Lead Qualification\
    \ System!\")\n\nprint(f\"__OUTPUTS__ {json.dumps(completion_log)}\")\n"
  depends_on:
  - qualification_summary
  description: Final step marking lead processing as complete
  previous_node: qualification_summary
  timeout_seconds: 15
inputs:
- name: timezone
  type: string
  default: UTC
  description: Timezone for timestamps (e.g., UTC, America/New_York, Europe/London)
- name: time_format
  type: string
  default: iso
  description: How to display time (iso, human, unix)
- name: lead_id
  type: string
  default: LEAD_001
  required: true
  description: Your reference ID for this lead
- name: lead_name
  type: string
  default: John Smith
  required: true
  description: Lead's full name
- name: lead_email
  type: string
  default: john.smith@company.com
  required: true
  description: Lead's email address
- name: company_name
  type: string
  default: Acme Corporation
  required: true
  description: Company name of the lead
- name: industry
  type: string
  default: Technology
  required: false
  description: Industry sector of the lead's company
- name: annual_revenue
  type: integer
  default: 50000
  required: false
  description: Annual revenue of the lead's company
outputs:
  lead_score:
    type: object
    source: calculate_lead_score
    description: AI-calculated lead scoring results
  similar_leads:
    type: object
    source: get_similar_leads_from_dynamics
    description: Similar leads analysis from Dynamics
  final_processing:
    type: object
    source: end_lead_processed
    description: Final lead processing results and notifications
  workload_analysis:
    type: object
    source: get_sales_officer_workload
    description: Sales officer workload assessment
  historical_analysis:
    type: object
    source: get_historical_data_from_bigquery
    description: Historical data analysis from BigQuery
  initialization_data:
    type: object
    source: get_lead_data_from_crm
    description: System initialization and lead data extraction
  qualification_results:
    type: object
    source: qualification_summary
    description: Lead qualification determination and routing results
version: 2.0
namespace: sales
description: Advanced lead qualification workflow combining data enrichment with AI-powered
  scoring and automated sales assignment
model_clients:
- id: lead_analyst
  config:
    model: gpt-4o-mini
    api_key: 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
    max_tokens: 3000
    temperature: 0.1
  provider: openai
- id: lead_scorer
  config:
    model: gpt-4o-mini
    api_key: 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
    max_tokens: 2000
    temperature: 0.05
  provider: openai
- id: sales_optimizer
  config:
    model: gpt-4o-mini
    api_key: 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
    max_tokens: 4000
    temperature: 0.0
  provider: openai
- id: activity_logger
  config:
    model: gpt-4o-mini
    api_key: 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
    max_tokens: 5000
    temperature: 0.2
  provider: openai
timeout_seconds: 900

Execution ID	Status	Started	Duration	Actions
`b22ae429...`	COMPLETED	2025-07-01 17:13:47	N/A	View
`762905c5...`	COMPLETED	2025-07-01 13:03:22	N/A	View