5 posts tagged with "lead scoring"

Quick answer: Jev is TypeSafe AI's new "System One" decision model (launched September 15, 2026). It doesn't chat — it answers structured questions (choice, score, yes/no) over JSON input at $0.042 per million input tokens with free output, in 70–500ms. For GTM teams, that means the classification work you currently route through a frontier LLM — lead scoring, intent triage, reply routing, social listening — gets 200–400x cheaper and comes back before a human could read the input. Early testers report it cutting total AI spend 50–60%.

Lead qualification isn't just another piece of sales jargon—it's the actionable process of determining which prospects are likely to become paying customers. Think of it as a critical filter that separates high-intent buyers from casual window shoppers, ensuring your sales team invests their time on deals they can actually win.

Why Lead Qualification Is the Bedrock of Your Sales Strategy​

Imagine your sales team are highly skilled chefs and leads are their ingredients. Even the best chef can't create a five-star meal (a closed deal) using rotten vegetables. Lead qualification is the art of sourcing the best ingredients—finding the fresh, high-quality produce (qualified leads) and discarding what's unusable.

Without this filtering process, your sales development reps (SDRs) are stuck chasing ghosts. They spend days calling prospects who have no budget, no authority to make a decision, or no real need for what you’re selling. This common gap between marketing's lead generation and sales' need for ready-to-buy prospects creates friction and wastes massive amounts of time and money.

The Hidden Costs of Unqualified Leads​

When sales teams are handed unfiltered lists of leads, the consequences are more than just frustration—they hit your bottom line, hard. A stunning 67% of lost sales are the direct result of sales reps not properly qualifying leads in the first place. That means companies are pouring resources into conversations that were doomed from the start.

This table breaks down just how expensive poor qualification can be compared to a well-defined process:

It’s a bleak picture. But effective qualification turns this around by creating a clear, shared definition of a "good lead" that both marketing and sales agree on. This alignment is the foundation of a healthy B2B sales funnel and is essential for predictable growth.

At its core, lead qualification is all about making sure you’re focused on getting the right leads—the ones who will actually move the needle for your business. It's the strategic discipline that separates high-growth companies from those stuck spinning their wheels.

From Wasted Effort to Winning Deals​

The whole point of asking "what is lead qualification?" is to understand how it transforms your sales operation from a reactive mess into a proactive, well-oiled machine. Instead of treating every name on a list the same, a solid qualification process lets your team prioritize their efforts based on a prospect's real potential.

This systematic approach brings several huge advantages to the table:

• Sky-High Sales Efficiency: Your reps stop wasting hours on dead-end conversations and focus their energy on prospects who have a genuine need and the intent to buy. Their productivity goes through the roof, and so does their morale.
• Better Conversion Rates: When SDRs connect with well-qualified leads, the conversations are instantly more relevant and impactful. This naturally leads to a higher lead-to-opportunity conversion rate and, you guessed it, more closed-won deals.
• Accurate Sales Forecasting: A pipeline filled with genuinely qualified leads gives you a much more reliable crystal ball for revenue forecasting. You can predict future sales with far greater confidence because you know the opportunities are real.
• Smarter Marketing ROI: By seeing which types of leads actually convert, your marketing team can double down on what works. They can refine their campaigns to attract more prospects who fit your ideal customer profile, ensuring every dollar of their budget is spent effectively.

Comparing Popular Lead Qualification Frameworks​

Once you’ve bought into why lead qualification is so important, the next question is how. You can’t just have your reps fire off random questions and hope for the best. That’s a recipe for inconsistent results. What you need is a system—a structured framework that guides the conversation.

Think of these frameworks as conversational roadmaps for your sales team. They make sure reps gather the right intel every single time to figure out if a prospect is truly a good fit.

The right framework depends entirely on what you're selling and who you're selling to. Think of it like a fishing net. You wouldn’t use a massive, deep-sea trawler net to catch trout in a stream. In the same way, the framework you choose needs to match the size and complexity of the deals you’re chasing.

At its core, the logic is simple. A qualified lead is someone who’s a good fit for what you sell and is actually ready to buy. This little decision tree sums it up perfectly.

Qualification is really a two-part test that separates real opportunities from all the noise. Let’s dive into the most common frameworks that help your team run this test effectively.

BANT: The Classic Approach​

You’ve probably heard of BANT. It's one of the oldest frameworks in the book and has stuck around for a reason: it's simple and direct.

BANT stands for:

• Budget: Can they actually afford what you're selling?
• Authority: Are you talking to the person who can sign the check?
• Need: Do they have a real problem that your product solves?
• Timeline: Are they looking to buy now, or sometime next year?

BANT is all about efficiency. It’s fantastic for high-volume sales teams with shorter, more straightforward sales cycles. It quickly weeds out leads who simply can't buy.

But its biggest strength is also its biggest weakness. In today's world of consultative selling, leading with "What's your budget?" can feel abrasive. It can shut down a good conversation before it even starts and often misses the deeper "why" behind a potential purchase.

CHAMP: The Modern, Problem-First Alternative​

Enter CHAMP, which flips the BANT model on its head to be more customer-friendly. Instead of leading with the wallet, it starts with the problem.

CHAMP stands for:

• CHallenges: What specific issues are they trying to solve?
• Authority: Who's involved in making this decision?
• Money: What’s the financial impact of doing nothing, and what have they set aside to fix it?
• Prioritization: How big of a fire is this, really?

By starting with Challenges, reps immediately position themselves as helpful problem-solvers, not just quota-crushing vendors. This is a much better fit for modern B2B buyers who are looking for a partner, not just a product. CHAMP shines in any sales process where understanding the customer's pain is the key to unlocking the deal.

MEDDIC: For the Big, Hairy Enterprise Deals​

Then there’s MEDDIC. This isn't for your average SMB deal. This is the heavy-duty framework for navigating complex, high-stakes enterprise sales with long cycles and a dozen people on the buying committee.

MEDDIC is less of a checklist and more of an operating system for winning massive deals. It stands for:

• Metrics: What are the measurable results the prospect expects to see? Think ROI.
• Economic Buyer: Who holds the ultimate P&L responsibility and can give the final "yes"?
• Decision Criteria: What specific, formal criteria will they use to judge your solution?
• Decision Process: What are the exact, step-by-step stages they follow to sign a contract?
• Identify Pain: What business pain is so acute it’s forcing them to act now?
• Champion: Who is your inside person, the one selling your solution for you when you’re not in the room?

MEDDIC forces your reps to dig incredibly deep, giving them a 360-degree view of the entire opportunity. It's total overkill for a $5k deal but absolutely essential if you're trying to land a $500k one.

Actionable Step: Choosing the Right Qualification Framework​

A comparative overview of BANT, CHAMP, and MEDDIC to help your team select the best model for your sales process. Using MEDDIC for a simple sale is like using a sledgehammer to crack a nut, while using BANT for a complex enterprise deal is like bringing a knife to a gunfight.

To make this actionable:

1. Analyze your average deal size and sales cycle length. Are they small and fast, or large and complex?
2. Review your last 10 closed-won deals. What information was critical to closing them? Was it budget, understanding pain points, or navigating a complex buying committee?
3. Choose one framework that best aligns with your findings and train your entire sales team on it to ensure consistency.

Combining Firmographics with Behavioral Signals​

While frameworks like BANT are great for structuring conversations, truly modern qualification is all about the data. To figure out who your SDRs should call right now, you have to answer two simple but critical questions:

1. Do they look like our best customers?
2. Are they acting like they're ready to buy?

Getting this right means blending two very different types of information. The first is all about who the company is—the static, foundational stuff. The second is about what they’re doing—the dynamic, real-time actions that signal intent. The secret to separating the tire-kickers from the truly sales-ready leads lies in mastering this combo.

Building Your Ideal Customer Profile with Firmographics​

The first layer is defining your Ideal Customer Profile (ICP). This isn't just a vague notion of who you sell to; it's a laser-focused, data-driven description of the perfect company for your solution.

This profile is built on hard data points, often called firmographics. Think of them like demographics, but for businesses. Key attributes usually include:

• Industry: Which verticals see the biggest wins with your product? (e.g., SaaS, Manufacturing, Financial Services)
• Company Size: How many employees do they have? (e.g., 50-250, 1,000+)
• Annual Revenue: What's the sweet spot for revenue? (e.g., $10M-$50M)
• Geography: Where are they based? (e.g., North America, EMEA)

But you can get even more specific. Smart teams add technographics to the mix—data on the tech stack a company uses. For a SaaS business, this is pure gold. Knowing a prospect uses a complementary tool like Salesforce, or even a direct competitor, tells you a ton about their needs and potential budget.

For a great example of this in action, see how the HS code filter converts customs data into qualified leads by targeting companies based on hyper-specific import/export data.

Identifying Intent with Behavioral Signals​

Here’s the thing: an ICP only tells you if a prospect looks good on paper. It doesn't tell you if they have a burning problem they’re trying to solve today.

That's where behavioral signals come in. These are the digital breadcrumbs a prospect leaves behind that scream "I'm interested!" and hint at buying intent. These actions show a prospect is moving out of passive research into active consideration.

Key Takeaway: An ICP identifies the companies you should be talking to. Behavioral signals identify the companies you should be talking to right now. The magic happens when these two data sets overlap.

Just look at the difference between a lead who only fits your ICP versus one who's also lighting up the activity feed.

Lead A is a solid prospect for a long-term marketing sequence. But Lead B is a different story. They're showing clear buying signals and need to be at the very top of an SDR's list for a call or personalized email, today. This blend of "fit" and "intent" is the engine of efficient, modern sales.

Building Your First Lead Scoring Model​

Alright, so you’ve mapped out your ideal customer and you know what buying signals to look for. Now what? The next move is to operationalize that knowledge so you can sort through hundreds or thousands of leads without losing your mind. This is exactly where lead scoring comes into play.

Think of it like a video game. As a lead interacts with your brand, they collect points for certain actions and attributes. The higher their score, the closer they are to being “sales-ready.” A solid lead scoring system automatically tallies these points, giving your reps a crystal-clear leaderboard of who to engage right now.

It’s a powerful concept, but surprisingly, only 44% of companies are actually doing it. That’s a huge miss, especially when you consider how effective it is. For example, Product-Qualified Leads (PQLs)—which are identified almost purely by their behavior—often see 20-30% conversion rates. This just proves that intent is a game-changer, which you can read more about in our guide on how B2B lead generation is evolving.

Actionable Step: Crafting Your Scoring Rules​

A good lead scoring model isn't complex. It just needs to balance who the lead is (explicit data) and what they're doing (implicit data). You assign points to each piece of information based on how well it predicts that a lead will become a customer.

1. Score for Fit (Explicit Data): Does the lead match your ICP?

• Job Title: A C-level exec is a great sign (+15 points). An intern is not a buyer (-10 points).
• Industry: If you exclusively sell to fintech, a lead from that industry deserves a boost (+10 points).
• Company Size: If your product shines in companies with 100-500 employees, a lead from a company that size gets +10 points.

2. Score for Intent (Implicit Data): Are they actively researching a solution?

• High-Intent Actions: Requesting a demo is a direct ask for a sales conversation (+25 points). Visiting your pricing page shows commercial intent (+15 points).
• Medium-Intent Actions: Attending a webinar (+10 points) or downloading a detailed case study (+5 points) shows they're actively researching.
• Negative Actions: Visiting your careers page suggests they are a job seeker, not a buyer (-20 points).

Example B2B SaaS Lead Scoring Model​

Let's make this tangible. Here's a quick-and-dirty model for a B2B SaaS company that targets mid-sized tech companies.

Actionable Step: Setting Your Qualification Thresholds​

With your scoring system ready, the final piece is deciding what to do with the scores. This is where sales and marketing need to be completely in sync. You’ll want to set at least two thresholds.

1. Marketing Qualified Lead (MQL): This is the "getting warm" stage. The lead is interesting, but not quite ready for a sales call. Actionable Step: Set an MQL threshold (e.g., 50 points) and automatically enroll these leads into a targeted nurture campaign.
2. Sales Qualified Lead (SQL): This is the green light. The moment a lead hits this score, they are officially sales-ready. Actionable Step: Set an SQL threshold (e.g., 75+ points) and create an automated workflow that immediately assigns the lead to an SDR and creates a high-priority task for follow-up.

This system removes the guesswork. The data tells your team who to call next, creating a clean, automated handoff from marketing to sales.

How AI Is Automating Lead Qualification​

While building a manual lead scoring model is a massive step forward, the next frontier is handing the most repetitive work over to artificial intelligence. AI isn't just a buzzword here; it’s the engine that transforms qualification from a time-sucking manual chore into a slick, automated workflow.

Think of it this way: a manual process is like a lone miner panning for gold, hoping to find a nugget. An AI-powered process is like a modern mining operation using advanced sensors to pinpoint exactly where the richest veins are. This shift helps sales teams move faster and with far more precision, ensuring no high-intent lead slips through the cracks. The AI acts as a tireless digital assistant, constantly watching for the signals that matter most.

From Data Analysis to Actionable Tasks​

The real magic of AI in lead qualification isn't just spotting top prospects—it's turning that insight into action. Modern tools don’t just serve up a list of "hot leads"; they translate those signals into a clear next best action for your SDRs. This is where strategy finally meets execution.

Imagine an AI that not only flags a prospect who fits your ICP and just hit your pricing page, but also immediately creates a prioritized task in the SDR's queue. And this task isn't empty; it's loaded with context.

• Who is this person? The AI pulls their title, company details, and relevant social media activity.
• Why now? It highlights the exact behavioral signals, like "viewed pricing page 3 times" or "downloaded case study on X."
• What should I say? It can even provide contextual talking points or draft a personalized email based on the prospect's industry and known pain points.

This makes the entire workflow—from signal detection to outreach—incredibly efficient. It bridges the gap between knowing what to do and actually doing it, fast.

Comparing Manual vs. AI-Powered Qualification​

The difference between a manual approach and an AI-driven one is night and day. While both aim for the same goal—finding qualified leads—their methods and outcomes couldn't be more different.

This comparison makes it obvious: AI doesn't replace the salesperson. It kills the administrative grunt work, freeing them up to do what humans do best—build relationships and have strategic conversations.

Platforms like MarketBetter.ai are built for this exact purpose, turning buyer signals into prioritized tasks and helping reps execute with an AI-powered dialer and email writer directly inside their CRM. The result is a sales team that spends less time on busywork and more time actually selling. By automating the tedious parts of qualification, you empower your reps to be more productive and, ultimately, to drive more revenue.

You can learn more about how this works by exploring our deep dive into the AI Lead Scoring Codex.

How to Measure the Success of Your Qualification Process​

You can't fix what you don't measure. That’s especially true for lead qualification. To make sure all your hard work is actually paying off, you need to track specific Key Performance Indicators (KPIs) that tie directly back to revenue.

Think of these metrics as a report card for your qualification strategy. They tell you exactly what’s working and what’s falling flat, turning a vague process into a predictable engine for growth.

Actionable Step: Build Your Qualification Dashboard​

To get a clear picture, start with a few core funnel metrics. These KPIs are the lifeblood of your process, showing how smoothly you’re turning initial interest into real business opportunities.

• Lead-to-SQL Rate: What percentage of all your incoming leads actually get qualified by your team? A low number here is a flashing red light. It could mean your lead sources are off the mark, or maybe your initial filtering isn't tight enough.
• SQL-to-Opportunity Rate: Of all the leads your SDRs qualify (SQLs), how many do your Account Executives accept and turn into a real, pipeline-worthy opportunity? This metric is the ultimate test of lead quality. A low rate here means your definition of "qualified" is misaligned with sales reality.
• Lead-to-Customer Conversion Rate: This one’s the bottom line. It tracks the full journey from the very first touchpoint all the way to a signed contract. Seeing this number tick up over time is the best proof that your entire system is getting smarter and more efficient.

As a ballpark, many B2B SaaS companies find that around 13% of leads become SQLs, and of those, about 22% convert into opportunities. But don't treat these as gospel—your industry, market, and price point can change everything. The real goal is to set your own baseline and improve it month over month.

Don't Just Look at the Numbers—Listen to Your Reps​

Data is crucial, but it only tells half the story. The most valuable, ground-truth insights will always come from your sales team. They're in the trenches every single day.

Actionable Step: Schedule a bi-weekly "Lead Quality Huddle" with your marketing and sales teams. Ask them straight up:

• Are the leads I’m sending you actually ready to talk?
• What are the most common pushbacks you're getting from supposedly "qualified" leads?
• Which lead sources are producing the best conversations? Which are duds?

A low SQL-to-Opportunity rate is just a statistic. A rep telling you, "Leads from the last webinar were amazing, but the ones from that ebook download are wasting my time," is pure gold. That’s an insight you can act on immediately.

Combining the hard data with this on-the-ground feedback is how you truly master what is lead qualification and build a system that works in the real world.

Quick Answers to Common Lead Qualification Questions​

Even the best-laid plans hit a few bumps in the road. As you start putting your lead qualification process into action, questions are bound to pop up. Here are some straightforward answers to the most common ones we hear from sales teams.

What’s the Real Difference Between an MQL and an SQL?​

An MQL (Marketing Qualified Lead) has shown interest (e.g., downloaded an ebook) and fits basic criteria, making them a good fit for marketing nurture. An SQL (Sales Qualified Lead) is an MQL that a sales rep has vetted and confirmed has a real, near-term need, budget, and authority, making them ready for a sales conversation.

The Comparison: Think of it like a relay race. Marketing (MQL) runs the first leg and hands the baton to sales (SQL) only when the runner is in a strong position to finish the race. The handoff is a critical quality check.

How Often Should We Revisit Our Lead Scoring Model?​

You should be giving your lead scoring model a tune-up at least once a quarter. Your business goals shift, your ideal customer evolves, and what worked last quarter might be totally off base today.

Actionable Step: Review your last quarter's closed-won and closed-lost deals. Do the winners consistently have high scores? Do the losers have low scores? If not, adjust the point values on the attributes and behaviors that correlate most strongly with winning deals.

Can a Small Team Actually Qualify Leads Without Fancy, Expensive Tools?​

Yes, absolutely. At the end of the day, qualification is a strategy, not a software subscription. A small team can get started with a clearly defined Ideal Customer Profile (ICP) and a straightforward framework like CHAMP.

Actionable Step: Create a shared Google Sheet or document with your ICP and your chosen qualification framework's questions. Have reps manually research prospects on LinkedIn and use the sheet to guide their calls. While tools add scale, getting the fundamentals right is the one step no team can afford to skip.

Ready to stop guessing and start executing? marketbetter.ai turns buyer signals into a prioritized task list for your SDRs, helping them execute with AI-written emails and a CRM-native dialer. Learn more about how we help sales teams build consistent outbound motion without the busywork.

🟡 Series Difficulty: MEDIUM (Part 6 of 10) — Uses research skills from Part 2 and connects to MarketBetter's signal data. The most analytical post so far.

Every SDR knows the frustration: you've got 200 leads in your queue, and they all look the same. Same priority level. Same generic tags. No clear signal about who to call first.

So you do what every SDR does — you start at the top of the list and work your way down. Or you sort alphabetically. Or you go with gut instinct. None of these are strategies. They're survival mechanisms.

Meanwhile, the enterprise sales teams down the hall have sophisticated lead scoring models built by data teams, powered by Marketo or HubSpot, with algorithms that predict which leads are most likely to convert. You don't have that. You don't have a data team. You don't have a marketing ops person who can build predictive models. You have a CRM, a list of leads, and a quota.

Here's the good news: you can build a lead scoring model in 30 minutes using Claude Code. It won't be as sophisticated as a machine-learning-powered enterprise system. But it'll be 10x better than alphabetical sorting. And when you pair it with MarketBetter's daily playbook, you'll have a complete system for knowing exactly who to call first, every morning.

This is Part 6 of our Claude Code + MarketBetter series — the last of the Medium-level posts. In the Basic posts (Parts 1-3), you learned to research and write. In Parts 4 and 5, you built multi-step workflows for LinkedIn and competitive intel. Now you're going to do something more analytical: use Claude Code to build a system that makes decisions for you. You'll define scoring rules, apply them to data, and create a repeatable process that gets smarter over time.

If that sounds complex, don't worry. The Claude Code prompts are just as straightforward as the ones you've been using. You're just asking slightly more structured questions.

Let's build your scoring model.

What Is Lead Scoring (and Why Do You Need It)?​

Lead scoring assigns a numerical value to each lead based on how likely they are to buy. Higher score = more likely to convert = call them first.

Simple concept. But most scoring models fail because they're either:

• Too complex — Built by data teams with 47 variables that nobody understands
• Too simple — "Enterprise = high priority" doesn't tell you anything useful
• Too static — Set once and never updated, even as your market changes
• Disconnected from action — Great model, but nobody uses it in their daily workflow

The model we're going to build avoids all of these traps. It uses three categories of signals, is easy to understand, and plugs directly into your MarketBetter daily playbook.

For a deeper dive on scoring best practices, check out our lead scoring best practices guide.

The Three Pillars of SDR Lead Scoring​

Your scoring model is built on three pillars:

Pillar 1: Firmographic Fit (Does this company match our ICP?)​

This is the "who are they?" question. It includes:

• Company size (employee count or revenue)
• Industry
• Geography
• Technology used
• Funding stage

Pillar 2: Behavioral Signals (Are they actively interested?)​

This is the "what are they doing?" question:

• Website visits (especially high-intent pages like pricing)
• Email engagement (opens, clicks, replies)
• Content downloads
• Social media interactions
• Event attendance

Pillar 3: Timing Signals (Is now the right moment?)​

This is the "when is the right time?" question:

• Recent funding rounds
• Leadership changes
• Job postings in relevant departments
• Competitor contract renewals
• Seasonal buying patterns

Each pillar contributes to a total score. The leads with the highest combined score get your attention first.

Step-by-Step: Building Your Model with Claude Code​

Step 1: Define Your Ideal Customer Profile​

Before you can score leads, you need to know what a great lead looks like. Ask Claude Code:

"Help me define my Ideal Customer Profile (ICP). I sell [your product] to [your market]. My best customers tend to be:

• Company size: [range]
• Industry: [industries]
• Typical buyer title: [titles]
• Common pain points: [pains]

Based on this, create a firmographic scoring rubric with a 0-30 point scale. Give me the exact criteria for each score level."

Claude Code returns something like:

Firmographic Scoring (0-30 points)

Notice how the scoring reflects YOUR specific ICP. A 200-person SaaS company in the US scores higher than a 5,000-person manufacturer in Asia — because that's who buys from you.

Step 2: Build the Behavioral Scoring Component​

Now add the engagement signals. This is where MarketBetter's data becomes critical:

"Now create a behavioral scoring rubric (0-40 points) based on these engagement signals I can track:

• Website visits (from MarketBetter visitor identification)
• Pages visited (pricing page, case studies, product pages)
• Visit frequency (one-time vs. return visitor)
• Email engagement (opens, clicks, replies)
• LinkedIn engagement (profile views, connection accepts, post interactions)

Weight the signals by purchase intent. A pricing page visit is more valuable than a blog page visit."

Claude Code returns:

Behavioral Scoring (0-40 points)

Step 3: Build the Timing Scoring Component​

Finally, add signals that indicate the timing is right:

"Create a timing/trigger scoring rubric (0-30 points) based on these signals:

• Recent funding announcement
• Executive leadership changes
• Job postings in relevant departments
• Company expansion/new office
• Technology changes or migrations
• Contract renewal season (if known)

Weight by urgency of the buying window."

Claude Code returns:

Timing Scoring (0-30 points)

Step 4: Score Your Existing Leads​

Now apply the model. Export your lead list from your CRM and feed it to Claude Code:

"I have a list of 100 leads. Apply this scoring model to each one:

[paste your scoring rubrics]

For each lead, I have:

• Company name, size, industry, geography
• Website visit data from MarketBetter (pages visited, frequency)
• Email engagement data (opens, clicks, replies)
• Any known trigger events

Score each lead across all three pillars, calculate the total, and rank them from highest to lowest. Group them into tiers:

• Hot (70-100): Call immediately
• Warm (40-69): Prioritize this week
• Cool (20-39): Nurture sequence
• Cold (0-19): Low priority

Here's the data: [paste your lead list with available data]"

In 2-3 minutes, you have a fully scored, prioritized lead list. No data team required.

Using MarketBetter's Daily Playbook as the Execution Layer​

A scoring model is useless if it doesn't change your daily behavior. Here's how to connect your Claude Code scoring model to your MarketBetter workflow:

The Morning Ritual (10 minutes)​

1. Check MarketBetter's daily playbook — New website visitors, return visitors, engaged prospects
2. Apply your scoring model — New behavioral signals from overnight activity change scores
3. Identify your Hot tier — These are your first calls of the day
4. Identify new entrants to Warm tier — Prospects who were Cool but just visited your pricing page. They jumped tiers overnight.
5. Execute — Start with the highest-scored leads and work down

Signal-Triggered Score Updates​

MarketBetter sends you real-time signals throughout the day. Each signal should update your mental scoring:

• Prospect visited pricing page → +10 points. If they were Warm, they're now Hot. Call them.
• Prospect opened your email 3 times → +5 points. They're interested. Send a follow-up.
• Prospect visited your site from a new device → +3 points. They might be sharing your site with colleagues. Multi-stakeholder interest.
• Cold lead returned to your site → Re-score them entirely. They might have jumped from Cold to Warm in one visit. (More on re-engagement in Part 9.)

Automated Scoring with MarketBetter​

MarketBetter's built-in engagement tracking does much of the behavioral scoring automatically. Your Claude Code model handles the firmographic and timing scoring that MarketBetter doesn't cover. Together, they give you a complete picture.

For more on how intent data drives this process, read our guide to what intent data is and how it drives growth.

Refining Your Model Over Time​

Your first scoring model won't be perfect. That's fine. Here's how to improve it:

Monthly Review (15 minutes)​

"Here are my last month's results:

• 15 leads scored Hot → 8 converted to meetings (53%)
• 30 leads scored Warm → 6 converted to meetings (20%)
• 45 leads scored Cool → 2 converted to meetings (4%)
• 10 leads scored Cold → 0 converted to meetings (0%)

Also, 3 meetings came from leads scored Cool or Cold. Here's what those leads had in common: [details]

Based on this data, what adjustments should I make to my scoring model? Are any signals over- or under-weighted?"

Claude Code will analyze the conversion data and suggest specific adjustments. Maybe pricing page visits should be worth 15 points instead of 10. Maybe industry scoring needs recalibration. Make the adjustments and run the updated model.

The Feedback Loop​

Over 3-6 months, your scoring model gets increasingly accurate because you're refining it based on actual conversion data. This is essentially what data teams do with machine learning — just simpler and driven by your domain expertise instead of algorithms.

Advanced: Multi-Persona Scoring​

If you sell to multiple buyer personas, you might need different scoring models for each:

"I sell to two different personas:

Persona 1: VP of Sales (cares about pipeline and team productivity) Persona 2: RevOps Leader (cares about data quality and tech stack efficiency)

Create separate behavioral scoring rubrics for each persona. A VP of Sales visiting a case study page is different from a RevOps leader visiting an integration page — weight them differently."

This gives you nuanced prioritization. A RevOps leader on your integrations page might score higher than a VP of Sales on your blog — even though the VP is the more senior title — because the RevOps behavior signals active evaluation.

Common Scoring Mistakes to Avoid​

1. Over-weighting title/seniority — A Director who's actively researching is more valuable than a VP who isn't
2. Ignoring negative signals — Unsubscribes, bounced emails, and "not interested" replies should decrease scores
3. Scoring once and forgetting — Scores should be dynamic, updated with every new signal
4. Too many tiers — Hot/Warm/Cool/Cold is enough. Don't create 10 tiers that nobody can remember
5. Ignoring the denominator — If your Hot leads aren't converting at a higher rate than Warm leads, your model isn't working

Try This Today​

Here's your concrete action item:

1. Open Claude Code and use the prompts from Steps 1-3 above to build your scoring rubrics
2. Pick 20 leads from your current queue
3. Score them manually using your new model (estimate where you can)
4. Sort them by score and compare the order to how you would have prioritized them with gut instinct
5. Work the list in score order for one week and track your results

Most SDRs find that their intuition was right about 60-70% of the time. A scoring model gets you to 80-90%. That 20-30% improvement in prioritization translates directly to more meetings with less effort.

This is Part 6 (🟡 Medium) of our 10-part series. You've completed the Medium tier! Next up: Part 7: CRM Cleanup in Minutes → — your first Advanced-level post.

MarketBetter's daily playbook surfaces the behavioral signals that power your lead scores. Book a demo to see how it works.

Ask any sales rep: "How do you decide who to call first?" You'll get answers like:

• "I work alphabetically through my list"
• "Whatever came in most recently"
• "Gut feeling based on company size"
• "Whoever my manager tells me to"

None of these are strategies. They're coping mechanisms for a broken system.

The best accounts—the ones with the highest likelihood to close and the highest deal value—are often buried in a spreadsheet, never contacted. Meanwhile, reps waste hours on accounts that were never going to buy.

This guide shows you how to build an AI-powered account scoring system with Claude Code that identifies your highest-potential accounts automatically. Stop guessing. Start knowing.

The Real Cost of Poor Prioritization​

Here's what happens when sales teams prioritize badly:

Time Waste:

• Average SDR spends 2+ hours daily deciding who to contact
• 67% of time is spent on accounts that will never convert
• Best accounts get the same attention as worst accounts

Revenue Loss:

• 35-50% of deals go to the vendor that responds first
• High-fit accounts that go uncontacted convert at competitor sites
• Reps hit quota on volume, miss it on value

Burnout:

• Calling dead accounts kills morale
• "Spray and pray" feels pointless (because it is)
• Top performers leave for companies with better systems

The data is clear: teams that score and prioritize accounts effectively see 30% higher conversion rates and 20% shorter sales cycles.

Why Traditional Lead Scoring Fails​

Most lead scoring systems are built on two flawed premises:

Flaw 1: Static Rules​

"Companies with 500+ employees get 10 points."

This ignores:

• Industry context (500 at a tech startup vs. 500 at a hospital = totally different)
• Current buying signals
• Relationship history
• Market timing

Flaw 2: Incomplete Data​

You score what you can measure, but the most predictive signals are often qualitative:

• "They mentioned they're evaluating competitors"
• "Their CTO attended our webinar AND read our pricing page"
• "They just raised a Series B and need to scale sales"

Claude Code can synthesize both structured and unstructured data to create scoring that actually predicts conversions.

The Architecture of AI Account Scoring​

Here's how an intelligent prioritization system works:

1. Data Aggregation​

Pull from every source: CRM, enrichment tools, website behavior, email engagement, social signals.

2. ICP Matching​

Score firmographic fit against your ideal customer profile.

3. Intent Detection​

Identify behavioral signals that indicate active buying.

4. Relationship Mapping​

Account for existing touchpoints and engagement history.

5. Timing Analysis​

Factor in buying cycles, budget periods, and urgency signals.

6. Composite Scoring​

Combine all factors into a single prioritization score.

Building the System with Claude Code​

Step 1: Define Your ICP Criteria​

First, codify what makes an account "ideal":

const ICP_CRITERIA = {
  firmographic: {
    employeeRange: { min: 50, max: 1000, weight: 0.2 },
    revenueRange: { min: 5000000, max: 100000000, weight: 0.15 },
    industries: {
      include: ['SaaS', 'Technology', 'Financial Services', 'Healthcare'],
      exclude: ['Government', 'Education'],
      weight: 0.15
    },
    geographies: {
      include: ['US', 'Canada', 'UK', 'Germany'],
      weight: 0.05
    }
  },
  
  technographic: {
    required: ['Salesforce', 'HubSpot'],
    positive: ['Outreach', 'SalesLoft', 'Gong'],
    negative: ['Competitor X', 'Legacy CRM'],
    weight: 0.15
  },
  
  departmentSignals: {
    hasSalesTeam: { minSize: 5, weight: 0.1 },
    hasMarketingTeam: { minSize: 2, weight: 0.05 },
    hasRevOps: { weight: 0.1 }
  }
};

Step 2: Aggregate Data Sources​

Pull everything you know about each account:

async function aggregateAccountData(companyId) {
  // CRM data
  const crmData = await crm.getCompany(companyId);
  const contacts = await crm.getContacts({ companyId });
  const deals = await crm.getDeals({ companyId });
  const activities = await crm.getActivities({ companyId });
  
  // Enrichment data
  const enrichment = await clearbit.enrich(crmData.domain);
  const techStack = await builtwith.getTechStack(crmData.domain);
  
  // Website behavior
  const webActivity = await analytics.getCompanyActivity(companyId, {
    days: 30
  });
  
  // Email engagement
  const emailEngagement = await emailPlatform.getEngagement(companyId);
  
  // Social signals
  const linkedInActivity = await linkedin.getCompanySignals(crmData.domain);
  
  // News and events
  const recentNews = await newsApi.getCompanyNews(crmData.name, { days: 90 });
  
  // Competitor mentions
  const competitorSignals = await detectCompetitorActivity(companyId);
  
  return {
    company: crmData,
    contacts,
    deals,
    activities,
    enrichment,
    techStack,
    webActivity,
    emailEngagement,
    linkedInActivity,
    recentNews,
    competitorSignals
  };
}

Step 3: Score with Claude Code​

Now use Claude to synthesize all signals into a comprehensive score:

async function scoreAccount(accountData) {
  // Calculate structured scores
  const icpScore = calculateICPScore(accountData, ICP_CRITERIA);
  const engagementScore = calculateEngagementScore(accountData);
  const intentScore = calculateIntentScore(accountData);
  
  // Use Claude for qualitative analysis
  const qualitativeAnalysis = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1000,
    system: `You are a B2B sales strategist analyzing accounts for 
prioritization. You excel at identifying hidden buying signals and 
assessing account quality beyond basic metrics.

Provide:
1. OPPORTUNITY_SCORE (0-100): Likelihood to close
2. VALUE_SCORE (0-100): Potential deal size relative to effort
3. TIMING_SCORE (0-100): Urgency/readiness to buy
4. KEY_INSIGHTS: 2-3 critical observations
5. RECOMMENDED_APPROACH: Best first touch strategy`,
    messages: [{
      role: 'user',
      content: `Analyze this account for prioritization:

COMPANY: ${accountData.company.name}
INDUSTRY: ${accountData.enrichment.industry}
SIZE: ${accountData.enrichment.employeeCount} employees
REVENUE: $${accountData.enrichment.annualRevenue}
TECH STACK: ${accountData.techStack.join(', ')}

RECENT ACTIVITY:
- Website visits: ${accountData.webActivity.pageviews} (${accountData.webActivity.uniqueVisitors} unique)
- Pages viewed: ${accountData.webActivity.topPages.join(', ')}
- Email engagement: ${accountData.emailEngagement.openRate}% open, ${accountData.emailEngagement.clickRate}% click
- Last activity: ${accountData.webActivity.lastActivity}

CONTACTS:
${accountData.contacts.map(c => `- ${c.name} (${c.title}): ${c.engagementScore} engagement`).join('\n')}

RECENT NEWS:
${accountData.recentNews.map(n => `- ${n.headline}`).join('\n')}

COMPETITOR SIGNALS:
${accountData.competitorSignals.length > 0 ? accountData.competitorSignals.join('\n') : 'None detected'}

RELATIONSHIP HISTORY:
- Previous deals: ${accountData.deals.length}
- Total activities: ${accountData.activities.length}
- Last touch: ${accountData.activities[0]?.date || 'Never'}

Provide your analysis as JSON.`
    }],
    response_format: { type: 'json_object' }
  });
  
  const aiAnalysis = JSON.parse(qualitativeAnalysis.content[0].text);
  
  // Combine all scores
  return {
    companyId: accountData.company.id,
    companyName: accountData.company.name,
    scores: {
      icp: icpScore,
      engagement: engagementScore,
      intent: intentScore,
      opportunity: aiAnalysis.OPPORTUNITY_SCORE,
      value: aiAnalysis.VALUE_SCORE,
      timing: aiAnalysis.TIMING_SCORE
    },
    composite: calculateComposite({
      icp: icpScore,
      engagement: engagementScore,
      intent: intentScore,
      ...aiAnalysis
    }),
    insights: aiAnalysis.KEY_INSIGHTS,
    recommendedApproach: aiAnalysis.RECOMMENDED_APPROACH,
    tier: determineTier(/* composite score */)
  };
}

function calculateComposite(scores) {
  // Weighted combination
  return (
    scores.icp * 0.2 +
    scores.engagement * 0.15 +
    scores.intent * 0.25 +
    scores.OPPORTUNITY_SCORE * 0.2 +
    scores.VALUE_SCORE * 0.1 +
    scores.TIMING_SCORE * 0.1
  );
}

Step 4: Create the Daily Prioritized List​

Generate a ranked list for each rep every morning:

async function generateDailyPrioritization(repId) {
  // Get rep's assigned accounts
  const accounts = await crm.getAccountsByRep(repId);
  
  // Score all accounts (parallelize for speed)
  const scoredAccounts = await Promise.all(
    accounts.map(async account => {
      const data = await aggregateAccountData(account.id);
      return scoreAccount(data);
    })
  );
  
  // Sort by composite score
  const ranked = scoredAccounts.sort((a, b) => b.composite - a.composite);
  
  // Assign daily tiers
  const dailyList = {
    mustTouch: ranked.slice(0, 5).map(addContactReason),
    highPriority: ranked.slice(5, 15).map(addContactReason),
    standard: ranked.slice(15, 50).map(addContactReason),
    nurture: ranked.slice(50).map(addContactReason)
  };
  
  // Push to CRM and Slack
  await crm.updateDailyPriorities(repId, dailyList);
  await slack.sendDM(repId, formatPriorityList(dailyList));
  
  return dailyList;
}

function addContactReason(account) {
  return {
    ...account,
    whyNow: generateWhyNow(account),
    suggestedAction: getSuggestedAction(account),
    talkingPoints: getTalkingPoints(account)
  };
}

Real-World Example: Tech Company Prioritization​

Input: 500 accounts assigned to an SDR

AI Analysis Output (top 3):

[
  {
    "companyName": "CloudScale Inc",
    "composite": 94,
    "scores": {
      "icp": 92,
      "engagement": 88,
      "intent": 96,
      "timing": 98
    },
    "insights": [
      "CEO visited pricing page 3x this week",
      "Currently using Competitor X (known pain: data accuracy)",
      "Just closed Series B—scaling sales team is top priority"
    ],
    "recommendedApproach": "Reference Series B news, position as infrastructure for scaling sales team. CEO is actively evaluating—this is hot.",
    "whyNow": "Series B + active pricing page visits = buying now"
  },
  {
    "companyName": "DataFlow Systems",
    "composite": 87,
    "scores": {
      "icp": 95,
      "engagement": 75,
      "intent": 89,
      "timing": 82
    },
    "insights": [
      "VP Sales attended our webinar last week",
      "Hiring 5 SDRs according to LinkedIn",
      "No current solution in place"
    ],
    "recommendedApproach": "Reference webinar attendance, offer to help structure their new SDR team. Timing is good with their hiring push.",
    "whyNow": "Building SDR team from scratch = greenfield opportunity"
  },
  {
    "companyName": "NextGen Analytics",
    "composite": 84,
    "scores": {
      "icp": 88,
      "engagement": 91,
      "intent": 78,
      "timing": 75
    },
    "insights": [
      "3 different people from the company have downloaded content",
      "Tech stack includes Salesforce + Outreach",
      "Last contacted 6 months ago—went dark after demo"
    ],
    "recommendedApproach": "Re-engage with new angle. Multiple stakeholders engaged now vs. single contact before. Ask what's changed.",
    "whyNow": "Re-engagement opportunity with broader buying committee"
  }
]

Continuous Learning: The Feedback Loop​

The system improves by tracking outcomes:

async function logPrioritizationOutcome(accountId, outcome) {
  const originalScore = await getHistoricalScore(accountId);
  
  await analyticsDb.log({
    accountId,
    scoredAt: originalScore.timestamp,
    composite: originalScore.composite,
    outcome: outcome, // 'converted', 'stalled', 'lost', 'disqualified'
    daysToOutcome: daysBetween(originalScore.timestamp, new Date()),
    dealValue: outcome === 'converted' ? await getDealValue(accountId) : null
  });
  
  // Quarterly: Retrain weights based on what actually converted
  if (isQuarterEnd()) {
    await retrainScoringWeights();
  }
}

async function retrainScoringWeights() {
  const outcomes = await analyticsDb.getOutcomes({ months: 6 });
  
  // Analyze which factors actually predicted conversions
  const analysis = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    messages: [{
      role: 'user',
      content: `Analyze these prioritization outcomes and recommend 
weight adjustments:

CONVERSIONS:
${outcomes.filter(o => o.outcome === 'converted').map(summarize).join('\n')}

LOSSES:
${outcomes.filter(o => o.outcome === 'lost').map(summarize).join('\n')}

Current weights: ${JSON.stringify(currentWeights)}

What factors were most predictive? Recommend new weights.`
    }]
  });
  
  // Update scoring algorithm
  await updateScoringWeights(analysis);
}

Integration with Daily Workflow​

Make prioritization seamless:

Morning Slack Notification​

// 7am daily
cron.schedule('0 7 * * *', async () => {
  const reps = await crm.getActiveReps();
  
  for (const rep of reps) {
    const priorities = await generateDailyPrioritization(rep.id);
    
    await slack.sendDM(rep.slackId, {
      blocks: [
        {
          type: 'header',
          text: `🎯 Your Priority Accounts for Today`
        },
        {
          type: 'section',
          text: `*Must Touch (5 accounts)*\n${priorities.mustTouch.map(a => 
            `• *${a.companyName}* (Score: ${a.composite}) — ${a.whyNow}`
          ).join('\n')}`
        },
        {
          type: 'actions',
          elements: [
            {
              type: 'button',
              text: 'View Full List',
              url: `https://crm.com/priorities/${rep.id}`
            }
          ]
        }
      ]
    });
  }
});

CRM Priority Field Updates​

async function syncToCRM(priorities) {
  for (const account of [...priorities.mustTouch, ...priorities.highPriority]) {
    await crm.updateCompany(account.companyId, {
      priority_tier: account.tier,
      ai_score: account.composite,
      last_scored: new Date(),
      recommended_action: account.suggestedAction,
      score_reasoning: account.insights.join(' | ')
    });
    
    // Create task if high priority
    if (account.tier === 'mustTouch') {
      await crm.createTask({
        companyId: account.companyId,
        subject: `Priority Touch: ${account.companyName}`,
        notes: account.whyNow,
        dueDate: new Date()
      });
    }
  }
}

Measuring Prioritization ROI​

Track these metrics:

The compound effect: If better prioritization increases conversions by 64% and deal size by 29%, and you're running 1,000 qualified accounts/quarter at a $30K baseline ACV, that's an additional $620K in ARR quarterly.

Advanced: Dynamic Reprioritization​

Don't just score once—reprioritize throughout the day:

// Real-time triggers
async function handleSignificantEvent(event) {
  const { accountId, eventType, data } = event;
  
  const significantEvents = [
    'pricing_page_visit',
    'competitor_search',
    'demo_request',
    'executive_engagement',
    'funding_announcement'
  ];
  
  if (significantEvents.includes(eventType)) {
    // Immediately rescore
    const newScore = await scoreAccount(await aggregateAccountData(accountId));
    
    // If jumped to Tier 1, alert immediately
    if (newScore.tier === 'mustTouch' && (await getPreviousTier(accountId)) !== 'mustTouch') {
      await sendUrgentAlert(accountId, newScore, event);
    }
  }
}

async function sendUrgentAlert(accountId, score, triggerEvent) {
  const rep = await crm.getAccountOwner(accountId);
  
  await slack.sendDM(rep.slackId, {
    text: `🚨 *HOT ACCOUNT ALERT*\n\n*${score.companyName}* just jumped to Tier 1!\n\nTrigger: ${triggerEvent.eventType}\n${score.whyNow}\n\nDrop what you're doing. This one's live.`
  });
}

Getting Started with MarketBetter​

Building AI account prioritization from scratch is powerful but complex. MarketBetter provides the complete solution:

• Daily SDR Playbook — Every rep gets their prioritized list each morning
• Real-time scoring — Accounts reprioritize based on live signals
• AI-powered reasoning — Not just a score, but why and what to do
• CRM integration — HubSpot, Salesforce out of the box
• Learning loop — Improves automatically based on your conversion data

Stop letting your best accounts go unworked. Stop wasting time on accounts that were never going to buy. Let AI tell you exactly where to focus.

Book a Demo →

Key Takeaways​

1. Poor prioritization costs deals — 67% of rep time goes to accounts that won't convert
2. Static lead scoring fails — Rules can't capture qualitative buying signals
3. Claude Code enables intelligent scoring — Synthesize structured + unstructured data
4. Make it actionable — Daily ranked lists with clear reasoning and suggested actions
5. Continuous learning — Track outcomes and retrain weights quarterly

Your CRM is full of gold. The problem is it's mixed in with thousands of accounts that look the same on the surface. AI-powered prioritization separates signal from noise—so your team spends 100% of their time on accounts that can actually close.

Your lead scoring model is lying to you.

That VP of Sales with a score of 85? Turns out they were researching for a competitor. The contact who scored 12? Just booked a demo after visiting your pricing page yesterday.

Traditional lead scoring was built for a buying journey that no longer exists. And yet, most sales teams are still using models from 2015 to prioritize 2026 leads.

Here's why it's broken — and what actually works.