Step‑by‑Step Lead Scoring and Follow‑Up Pipeline with the OpenClaw Full‑Stack Template

1. Introduction: AI‑Agents Meet Sales Automation

AI‑agents are the newest buzzword in enterprise tech, promising to replace repetitive manual tasks with intelligent, self‑learning bots. In sales, this hype translates into faster lead qualification, higher conversion rates, and a one‑click‑deploy solution that lets developers focus on business logic instead of infrastructure.

The UBOS platform hosts the OpenClaw full‑stack template, a pre‑wired collection of agents for lead enrichment, scoring, and follow‑up. This tutorial walks you through every step—from provisioning the environment to testing a live pipeline—so you can start automating revenue generation today.

2. Prerequisites

• A registered UBOS account with access to the UBOS partner program.
• Git installed (git --version).
• Node.js ≥ 18 (node -v) and npm.
• Basic knowledge of JavaScript/TypeScript and REST APIs.

Once you have these tools, you’re ready to spin up the OpenClaw environment with a single click.

3. Setting up the OpenClaw Environment

3.1 Deploy the Template

Navigate to the OpenClaw hosting page on UBOS and click Deploy. UBOS automatically provisions:

1. A Docker‑based runtime for the agents.
2. Managed PostgreSQL for lead storage.
3. Secure API gateways for external data sources.

3.2 Configure Environment Variables

After deployment, open the Settings tab and add the following variables (replace placeholders with your keys):

# .env
OPENCLAW_API_KEY=your_openclaw_key
CHATGPT_API_KEY=your_openai_key
TWILIO_SID=your_twilio_sid
TWILIO_TOKEN=your_twilio_token
SMTP_HOST=smtp.yourmail.com
SMTP_USER=your_smtp_user
SMTP_PASS=your_smtp_pass

These variables enable the agents to call OpenAI, Twilio, and your email server without hard‑coding secrets.

4. Lead Enrichment Agent

The enrichment agent pulls public data (LinkedIn, Crunchbase, etc.) to fill missing fields such as company size, industry, and recent news.

4.1 Purpose and Workflow

• Receive a raw lead payload (name, email, company).
• Query external APIs in parallel.
• Merge results into a unified LeadProfile object.
• Store the enriched profile in PostgreSQL.

4.2 Code Snippet: Fetching External Data

// enrichmentAgent.js
import axios from 'axios';

export async function enrichLead(lead) {
  const [linkedin, crunchbase] = await Promise.all([
    axios.get(`https://api.linkedin.com/v2/people/(email:${lead.email})`, {
      headers: { Authorization: `Bearer ${process.env.LINKEDIN_TOKEN}` }
    }),
    axios.get(`https://api.crunchbase.com/v3.1/organizations/${lead.company}`, {
      params: { user_key: process.env.CRUNCHBASE_KEY }
    })
  ]);

  return {
    ...lead,
    industry: crunchbase.data.industry,
    employeeCount: crunchbase.data.employee_count,
    linkedinProfile: linkedin.data.profile_url,
    recentNews: await fetchNews(lead.company)
  };
}

async function fetchNews(company) {
  const resp = await axios.get('https://newsapi.org/v2/everything', {
    params: { q: company, apiKey: process.env.NEWSAPI_KEY }
  });
  return resp.data.articles.slice(0, 3);
}

This modular design lets you swap data sources without touching the scoring logic.

5. Lead Scoring Agent

Scoring translates enriched attributes into a numeric value (0‑100) that predicts conversion likelihood.

5.1 Scoring Model Explanation

The model combines rule‑based weights with a lightweight OpenAI ChatGPT integration for sentiment analysis of recent news. The formula is:

Score = (IndustryWeight * industryScore) +
        (SizeWeight * sizeScore) +
        (NewsSentimentWeight * sentimentScore) +
        (EngagementWeight * emailOpenRate)

5.2 Code Snippet: Scoring Algorithm

// scoringAgent.js
import { getSentiment } from './sentimentService.js';

export async function scoreLead(profile) {
  const industryScore = profile.industry === 'SaaS' ? 30 : 10;
  const sizeScore = profile.employeeCount > 200 ? 25 : 15;
  const sentimentScore = await getSentiment(profile.recentNews);
  const emailOpenRate = profile.emailOpenRate || 0;

  const weights = {
    industry: 0.3,
    size: 0.25,
    sentiment: 0.35,
    engagement: 0.1
  };

  const rawScore =
    weights.industry * industryScore +
    weights.size * sizeScore +
    weights.sentiment * sentimentScore +
    weights.engagement * emailOpenRate * 100;

  return Math.min(100, Math.round(rawScore));
}

The getSentiment function calls the ChatGPT API to evaluate the tone of the three latest news headlines, returning a value between 0 and 30.

6. Automated Follow‑Up Agent

When a lead’s score crosses a threshold, the follow‑up agent sends a personalized email or SMS.

6.1 Trigger Conditions

• Score ≥ 80 → Immediate email with a demo link.
• 70 ≤ Score < 80 → SMS reminder after 24 h.
• Score < 70 → No action (await manual review).

6.2 Code Snippet: Email/SMS Automation

// followUpAgent.js
import nodemailer from 'nodemailer';
import twilio from 'twilio';

const mailer = nodemailer.createTransport({
  host: process.env.SMTP_HOST,
  port: 587,
  auth: { user: process.env.SMTP_USER, pass: process.env.SMTP_PASS }
});

const smsClient = twilio(process.env.TWILIO_SID, process.env.TWILIO_TOKEN);

export async function triggerFollowUp(lead, score) {
  if (score >= 80) {
    await mailer.sendMail({
      from: '"Sales Bot" ',
      to: lead.email,
      subject: 'Your Personalized Demo is Ready',
      html: `
Hi ${lead.firstName},
             
Based on your profile, we think you’ll love our solution. Book a live demo now!
`
    });
  } else if (score >= 70) {
    await smsClient.messages.create({
      body: `Hi ${lead.firstName}, check out our demo at https://yourdemo.link`,
      from: '+1234567890',
      to: lead.phone
    });
  }
}

Both transports are configured via environment variables, keeping credentials out of source control.

7. Connecting the Agents into a Pipeline

OpenClaw’s Workflow Automation Studio lets you orchestrate the three agents with a declarative YAML file.

7.1 Orchestration Logic

# pipeline.yaml
steps:
  - name: EnrichLead
    action: node enrichmentAgent.enrichLead
    input: ${incomingLead}
    output: enrichedLead

  - name: ScoreLead
    action: node scoringAgent.scoreLead
    input: ${enrichedLead}
    output: leadScore

  - name: FollowUp
    action: node followUpAgent.triggerFollowUp
    input:
      lead: ${enrichedLead}
      score: ${leadScore}
    condition: ${leadScore} >= 70

The condition field ensures the follow‑up step runs only for qualified leads.

7.2 Sample Configuration File

Save pipeline.yaml in the /workflows directory of your OpenClaw project, then run:

openclaw deploy --workflow pipeline.yaml

OpenClaw will spin up the three micro‑services, link them via its internal message bus, and expose a single HTTP endpoint (/api/lead) for inbound leads.

8. Testing the Pipeline

Use curl or Postman to send a test payload:

curl -X POST https://your-openclaw-instance.com/api/lead \
  -H "Content-Type: application/json" \
  -d '{
    "firstName": "Alice",
    "lastName": "Doe",
    "email": "alice@example.com",
    "company": "Acme SaaS",
    "phone": "+15551234567"
}'

8.1 Sample Lead Data

8.2 Expected Outcomes

• The enrichment agent adds industry = “SaaS”, employeeCount = 350, and three news headlines.
• The scoring agent returns a score of ~85 (high conversion probability).
• The follow‑up agent sends an email with a demo link to alice@example.com.

Check your email inbox and the OpenClaw logs (openclaw logs) to verify each step executed as expected.

9. Publishing the Article on UBOS

When you share this tutorial on the UBOS blog, embed the internal link to the OpenClaw hosting page exactly once (as done above). This signals relevance to both search engines and the UBOS knowledge graph, boosting discoverability for developers searching “OpenClaw lead scoring template”.

10. Conclusion: One‑Click Deploy, Unlimited Scale

By leveraging the OpenClaw full‑stack template, you transform a raw lead list into a qualified pipeline with zero manual coding of infrastructure. The three AI agents—enrichment, scoring, and follow‑up—are fully configurable, extensible, and run on the secure, scalable Enterprise AI platform by UBOS.

Looking ahead, you can replace the rule‑based scoring model with a custom TensorFlow model, add a Telegram integration on UBOS for real‑time alerts, or plug in the Chroma DB integration for vector‑search‑based similarity scoring.

Start today, watch your conversion rates climb, and let AI agents handle the grunt work while you focus on strategy.