Skip to content

Lead Scoring with AcelleMail Automation — Score, Tag, and Route

Add points when a subscriber opens a campaign, clicks a key link, or fills a form. Route high-score subscribers to a sales-handoff tag automatically. This guide walks the AcelleMail automation builder + custom-field scoring, with API-driven scoring patterns for ecommerce + CRM integrations in the collapsible section.

What lead scoring is (and isn't)

Lead scoring is a number on each subscriber that tracks how engaged they are with you. It starts at 0; you bump it up when they do something positive (opened, clicked a buy-link, submitted a form), down when they go quiet (no opens for 60 days, unsubscribed from a list).

When the score crosses a threshold, you route them — to a sales tag for a CSM to call, into a higher-frequency cadence for prospect nurture, into a re-engagement automation for a "we miss you" win-back.

The model is simple. The setup in AcelleMail is straightforward. The discipline part — picking the right point values and the right thresholds — that's the marketing call.

Setup in three pieces

Piece 1: Add a lead_score field to your list

Audience → [your list] → Fields → New field. Configure:

  • Tag (key): lead_score
  • Type: Number
  • Default value: 0
  • Required at signup: No

This adds a {{ subscriber.lead_score }} merge tag and a per-subscriber numeric value AcelleMail will track + update via automation.

Piece 2: Build automations that bump the score

Open the visual automation builder

In AcelleMail's left sidebar, click AutomationAutomations. The index lists every automation in this account with its current state:

Automations index

Click New automation in the top-right toolbar. The trigger picker opens:

Trigger picker — pick what starts the automation

This first automation tracks "opened a campaign":

  1. Trigger: pick Email opened from the trigger picker
  2. Condition (optional): scope to a specific campaign or "any campaign"
  3. Action: Update subscriber fieldlead_score = lead_score + 5

Save. The flow now runs every time an open is recorded:

Automation flow — open → +5 score

Repeat the pattern for higher-value events. Common point values:

Event Point bump Trigger to use
Email opened +5 Email opened
Clicked any link +10 Link clicked (no specific link)
Clicked a buy/upgrade link +25 Link clicked with URL filter on /pricing or /upgrade
Submitted a form +30 Subscribed to list (form's target list)
Visited pricing page (via tracker pixel) +15 Custom event from your site
Opened from sequential campaigns 3+ times in 7 days +10 bonus Compound conditional (see Advanced)

Piece 3: Build the routing automation

Once score is being tracked, add a routing automation that watches for threshold crossings.

  1. Trigger: Field value change on lead_score
  2. Condition: lead_score >= 100
  3. Action: Add tagsales-ready

When you add sales-ready to someone, you can either:

  • Email your sales team via a separate automation triggered on tag addition
  • Webhook the lead into your CRM via the Send webhook action
  • Add to a high-touch nurture list

Verify in the automation index

The Automations index lists all running flows + their last-run timestamp + total runs:

Automation list — see all flows

Click any automation to see its run history + per-subscriber path:

Per-flow run details

The settings tab shows the configuration + per-run debugging:

Automation settings

Score values that actually mean something

Don't over-engineer the point values. Start coarse:

Tier Score Action
Cold 0-25 Default cadence, low frequency
Warming 26-75 Bumped to standard cadence + nurture sequence
Hot 76-150 Sales-ready tag + CRM handoff
Champion 150+ High-touch / CSM outreach

Adjust quarterly based on what actually correlates with conversion in your funnel. The most useful question to ask each quarter: "of last quarter's converted customers, what was their score 30 days before they converted?" That's your real threshold; ignore the round numbers.

Common pitfalls + fixes

Symptom Likely cause UI fix
Scores all stuck at 0 The "field update" automation step uses = not lead_score + 5 Open the automation step → use "Increment field" mode, not "Set field"
Same subscriber scored 50 times for same open Open-tracking + automation re-fires per pixel-load (some clients fetch the pixel repeatedly) Add a per-day rate limit in the automation conditions: "only run if last_score_update > 24h ago"
Score keeps growing forever even for unengaged No decay logic Add a daily-run scheduled automation that subtracts 1 from everyone's score
sales-ready tag never gets added despite high scores The routing automation uses an old threshold (>= 50) Edit the routing automation's condition, re-save
Customer-success team complains about wrong-stage leads Threshold mis-calibrated Audit converted customers' pre-conversion scores; adjust threshold
Advanced: API-driven scoring from ecommerce, CRM, and product analytics

The AcelleMail automation builder handles the email-side events (open, click, form submit) natively. For non-email events (purchases, app logins, support tickets), you push score updates via the API.

Increment a subscriber's score via API:

ACELLE_TOKEN="..."
ACELLE_LIST_UID="..."

# Get current score
current=$(curl -s -H "Authorization: Bearer $ACELLE_TOKEN" \
  "https://acellemail.com/api/v1/[email protected]&list_uid=$ACELLE_LIST_UID" \
  | jq -r '.data[0].fields.lead_score')

new=$((current + 25))

# Update
curl -X PATCH "https://acellemail.com/api/v1/subscribers/{subscriber_uid}" \
  -H "Authorization: Bearer $ACELLE_TOKEN" \
  -H "Content-Type: application/json" \
  -d "{\"fields\": {\"lead_score\": $new}}"

A simpler pattern: use AcelleMail's Custom event trigger + an automation step "Increment field":

# Fire a custom event with the score delta in payload
curl -X POST "https://acellemail.com/api/v1/events" \
  -H "Authorization: Bearer $ACELLE_TOKEN" \
  -d '{
    "subscriber_email": "[email protected]",
    "event": "purchase_completed",
    "value": 25
  }'

Then build an automation triggered by event = purchase_completed → step "Increment lead_score by event.value". One API call, score bumped, all logic in the automation flow.

Shopify integration pattern:

Shopify → Webhook → your bridge service → AcelleMail API. Common point values from Shopify webhooks:

cart_started:       +15
cart_abandoned:     +5  (after timeout — still engaged)
checkout_completed: +50
order_refunded:     -25

The bridge service can be a Cloudflare Worker, an AWS Lambda, a Vercel Edge function — anywhere that maps Shopify's webhook signature to AcelleMail's auth.

Salesforce integration pattern:

Use Salesforce Flow to call AcelleMail's API on Lead status changes:

Lead status → Marketing Qualified: AcelleMail tag "mql" + score +30
Lead status → Sales Qualified: AcelleMail tag "sql" + score +60
Lead converted to Opportunity: AcelleMail tag "opportunity" + score +100

When AcelleMail sees the sales-ready threshold crossing, it can webhook back to Salesforce to create a Task. Two-way sync, both systems agree on the score and the stage.

HubSpot integration pattern:

HubSpot's "contact property" sync via webhook to AcelleMail mirror — when HubSpot's native scoring changes, push the new value to AcelleMail's lead_score field. Single source of truth (HubSpot), AcelleMail just reads the value.

Decay automation (daily-run cron):

# Run via php artisan scheduler or external cron
php artisan tinker --execute='
  $subscribers = \App\Model\Subscriber::where("fields->lead_score", ">", 0)->get();
  foreach ($subscribers as $s) {
    $current = (int) ($s->fields["lead_score"] ?? 0);
    $newValue = max(0, $current - 1);
    $s->update(["fields" => array_merge($s->fields ?? [], ["lead_score" => $newValue])]);
  }
'

OR use AcelleMail's built-in scheduled automation: trigger "Date relative" = "every day at 03:00", action "Decrement field by 1".

Multi-signal scoring — score from multiple sources stays meaningful only if you can debug it. Log every score change with the reason. Store it in a custom field lead_score_log (JSON-encoded array) so a sales rep looking at a hot lead can see why they're hot:

{
  "lead_score": 85,
  "lead_score_log": [
    {"delta": 25, "reason": "shopify.cart_started", "at": "2026-05-10"},
    {"delta": 50, "reason": "shopify.checkout_completed", "at": "2026-05-12"},
    {"delta": 10, "reason": "email.click", "at": "2026-05-15"}
  ]
}

This becomes invaluable when investigating "why did this lead score 85?" — without the log, you're guessing.

Related articles

12 comments

7 comments

  1. Linh
    The visual flow diagram is exactly what I needed. Our welcome series has been a mess of forgotten branches — going to redo it tonight using this as the template.
  2. Aditi
    We do almost exactly this but with one tweak — we use the 'goal' node to exit subscribers from the sequence early when they complete a target action. Saves us sending to people who already did the thing.
  3. Olufemi
    Solid walkthrough. The conditional-branching example especially — most automation guides skip that and you end up rebuilding from scratch
    1. Admin
      Branching was the part we went back and forth on the most. It's easy to write a scoring guide where every lead walks one straight line, but real lists don't behave, and the moment you need "score over 50 AND opened the last two" you either have branches or you have three duplicate automations drifting apart. The one thing that section doesn't cover well enough yet is what happens to a contact sitting mid-branch when you edit the automation. Worth its own section, I'll add it on the next pass.
  4. Isabella
    What's the max number of steps in a sequence before performance becomes a concern? Asking because we have a 14-step nurture and I'm wondering if it's overkill.
    1. Admin
      There's no hard cap, and 14 steps is not where things fall over. Step count barely matters on its own because each subscriber only sits at one node at a time. What actually costs you is how many subscribers are parked in the sequence at once and how many of your steps do conditional work like score checks or tag lookups, since those get evaluated per subscriber per run. If a 14-step nurture is slow, it's usually one step doing the damage, not the length. Look for short wait intervals stacked back to back, that's what turns one sequence into a lot of scheduler churn. I don't have a published number for "steps before it hurts" and I'd rather not make one up. If you tell me roughly how many contacts are in that nurture I can give you a more useful answer, and honestly we should put real guidance on this in the article because you're not the first to ask.
  5. Carlos
    How do you handle subscribers who join mid-sequence (e.g. via API)? Do they start at step 1 or pick up at a current point?
    1. Admin
      Step 1 always, each subscriber has their own position, there's no shared clock to join. To skip the intro block, put a condition right after entry checking a tag you set on the API call.
  6. Emma
    Always test the END of the sequence first, not the start. Most testing focuses on email 1 but the longest-tenure subscribers are at the end and that's where bugs surface.
    1. Admin
      This is true and it bites hardest in scoring flows specifically, because the later steps are the ones reading score values that only exist after several earlier actions have fired. Email 1 fires against a fresh subscriber with a clean state, so it passes even when the branch conditions downstream are wrong. The way we test it internally: put a test subscriber in the list, then manually set the score and tags to whatever the end of the sequence expects, and drop them straight into the automation at that step. You skip the waits and see the branch decision immediately. Shortening the delays to a minute works too but you end up re-running the whole thing every time you change one condition. I'll add a testing section to the article covering this. It's a real gap right now, the piece walks through building the flow and then says nothing about validating it.
  7. Ravi
    Built a 9-email welcome series las quarter using this pattern. Took 4 days end-to-end. Open rate on email 1 is 62%, drops to 28% by email 9 — which is actually higher engagement than our broadcast list. Highly recommend the format.
    1. Admin
      62% to 28% across nine emails is a healthy curve. The drop matters less than the shape, and a welcome series beating your broadcast list is normal because those people opted in days ago rather than months ago. One thing worth doing with that data: if you're scoring opens in this series, the late emails are the useful signal. Someone still opening email 9 at week three is a different lead from someone who opened email 1 and vanished. Weight them differently instead of giving every open the same points, otherwise the whole list bunches up at the top of the score range. If you're willing to share the tag/score setup you ended up with, I'd like to work a real example into the article. The current one is synthetic.

More in Automation