Olmec Dynamics
H
·7 min read

How to Build AI Lead Scoring Using Pipedrive, OpenAI and Make.com

Automate AI lead scoring with Pipedrive, OpenAI and Make.com. Score incoming leads, write scores to Pipedrive, and notify sales for high-priority follow up.

Introduction

You get lots of new leads but prioritisation is manual. Reps scan notes, check job titles, guess company fit, and some promising leads slip through. That costs time and wastes outreach capacity.

This guide shows how to build an advanced Make.com scenario that automatically scores new or updated leads in Pipedrive using OpenAI. By the end you will have a production-ready pattern that pulls relevant signals from Pipedrive, calls OpenAI with a structured prompt, parses a numeric score and rationale, writes the score back to Pipedrive, and routes high-priority leads into Slack and task systems.

What you will know by the end: trigger selection, prompt design, exact Make.com modules to use, parsing and validation logic, idempotency and logging, and routing thresholds.

What You'll Need

  • Pipedrive account, admin access to create custom numeric field for lead_score and text fields for score_rationale and prompt_version
  • OpenAI API key (access to gpt-3.5-turbo or gpt-4o recommended) and a billing plan that suits your volume
  • Make.com account capable of Pipedrive, HTTP/OpenAI, Slack and Google Sheets integrations; paid tier recommended for execution volume and error-handling features
  • Slack workspace and a bot token that can post into channels
  • Google Sheets used as a lightweight audit log (optional but recommended)
  • Basic ops permissions to create API credentials and Pipedrive custom fields

Note: if you plan to score every update in a busy instance, check OpenAI and Pipedrive rate limits and budget for API calls.

How It Works (The Logic)

Trigger: Pipedrive watch event (New Person or Deal created, or Deal updated). Make.com collects a defined set of signals from the record: name, title, email domain, organisation size, deal value, stage, recent activity, and notes. Make.com builds a compact structured prompt asking OpenAI for a numeric score from 0 to 100 and a one-line rationale. The response is parsed, validated, and written back into Pipedrive custom fields. If the score crosses a configured threshold, Make.com tags the record, creates a task for the sales owner, and posts a Slack alert. All runs append an audit row to Google Sheets for observability.

In short: Pipedrive (new or updated lead) → Make.com gathers fields → OpenAI scores → Make.com validates and writes score to Pipedrive → conditional routing to Slack/tasks → audit log in Google Sheets.

Step-by-Step Setup

  1. Create Pipedrive custom fields
  • lead_score (number)
  • score_rationale (text)
  • prompt_version (text)

Create these on the entity you will update, typically Deal or Person. Note their field keys for mapping in Make.com.

  1. Design the scoring prompt and versioning
  • Keep the prompt strict and structured. Example pattern:

You are a sales ranking assistant. Given the lead data below, return a numeric score between 0 and 100 (higher means higher likelihood to close within 60 days). Then return a one-sentence rationale.

Data: Name: {{name}} Title: {{title}} Company: {{company}} Company size: {{employees}} Industry: {{industry}} Lead source: {{source}} Deal value: {{value}} Stage: {{stage}} Recent activity summary: {{activity_summary}} Notes: {{notes}}

Respond in this exact format: Score: <number 0-100> Rationale:

  • Store a small prompt_version string such as v1.0 and keep prompt text in your internal repo. Increment prompt_version whenever you change wording.
  1. Make.com scenario layout, modules and mapping

  • Module A: Pipedrive, "Watch Deals" or "Watch Persons". Configure to trigger on creation and on significant updates (stage or value changes).

  • Module B: Pipedrive, "Get Deal/Person" (retrieve full record). Map these fields into variables: name, title, company, employees, industry, source, value, stage.

  • Module C: Formatter/Set variable, "Build activity summary". Pull recent notes or activities via Pipedrive API if you need a concise activity_summary. Limit to 300-600 characters to control token usage.

  • Module D: OpenAI (Make.com OpenAI module or HTTP request to OpenAI API). Use the prompt from step 2. Settings: model gpt-3.5-turbo or gpt-4o, temperature 0.2, max_tokens ~200. Pass only the necessary fields to avoid exposing sensitive data.

  • Module E: JSON/text parser. Extract the Score and Rationale. Implement regex or simple parsing looking for "Score: (\d{1,3})" and "Rationale: (.+)".

Common gotcha: model output can vary. Use strict formatting in the prompt and add a short example in the prompt to improve consistency.

  • Module F: Validation and fallback. If parsed score is missing or outside 0-100, set score=40 (or your chosen fallback), set score_rationale to "parsing or model error" and add a note for ops. Log the raw response to Google Sheets for diagnosis.

  • Module G: Pipedrive, "Update Deal/Person". Map lead_score, score_rationale, prompt_version. Use conditional mapping so you never overwrite non-empty human-entered fields with blanks.

  • Module H: Router with branches for thresholds. Example:

    • Branch 1: score >= 80: add tag "High Priority", create a Pipedrive task assigned to owner with title "Contact: High Score {{lead_score}}", post Slack message to #sales-high-priority.
    • Branch 2: 50 <= score < 80: add tag "Warm", optional Slack digest channel.
    • Branch 3: score < 50: no immediate action.

  • Module I: Slack, "Post message". Build concise Block-style messages with name, company, score, rationale, and a link to the Pipedrive record. Map the Pipedrive record URL using your portal pattern.

  • Module J: Google Sheets, "Add a row". Append run data: timestamp, object_id, email, score, rationale, prompt_version, raw_model_response, run_status. This audit is essential for drift monitoring.

  1. Error handling and idempotency
  • Use Make.com built-in error handlers: on transient OpenAI or Pipedrive 5xx errors, retry with backoff. Log permanent errors and mark the Pipedrive record with a lightweight note so ops can retry.
  • To avoid duplicate scoring when the same update triggers multiple webhooks, include run_id or last_scored_at field in Pipedrive and skip runs when a recent score exists (for example, last_scored_at within the past 10 minutes).
  1. Testing and evaluation
  • Create test records with known signals: enterprise, startup, senior title, low-value, and empty fields. Run through the flow and inspect Google Sheets logs.
  • Track distribution of scores and sample 50 scored records weekly to verify model alignment. Adjust prompts or thresholds based on false positives/negatives.
  1. Governance and monitoring
  • Keep prompt_version in Pipedrive for every scored record so you can audit which prompt generated which score.
  • Monitor OpenAI usage and errors in a weekly report. If score drift appears, roll back to a previous prompt_version and investigate.

Real-World Business Scenario

A SaaS vendor used this exact architecture. They watched new deals in Pipedrive, scored them with OpenAI, and routed scores >= 80 to a dedicated SDR queue. Within two months the SDRs contacted top prospects faster and conversion on high-score leads rose by 18 percent. The team kept an audit sheet for each run to catch prompt drift and tuned the prompt twice in the first quarter.

Common Variations

Keeping this maintainable

You built an advanced Make.com workflow that adds context-aware AI scoring to Pipedrive leads and routes high-priority items for immediate action. Start with a conservative threshold, store prompt_version, and use the Google Sheets audit to catch drift early.

If you want help implementing scoring across your Pipedrive instance, Olmec Dynamics builds and maintains these exact automations and tunes prompts and thresholds for production. See what we build at Olmec Dynamics and how we help teams deploy reliable automation: https://olmecdynamics.com.