Building ICP Scoring with Tech Stack Data: A Technical Guide

Why Tech Stack Data Matters for ICP Scoring

Ideal Customer Profile (ICP) scoring traditionally relies on firmographic data: company size, industry, revenue range, location. These dimensions are useful but incomplete. Two companies with identical firmographics can have radically different technology needs and buying behaviors.

A 200-person B2B SaaS company using Salesforce, Stripe, and Snowflake is fundamentally different from a 200-person services firm using spreadsheets and QuickBooks. The first is a qualified buyer for your dev tools product. The second is not.

Tech stack data—what vendors a company actually uses—provides direct evidence of technical sophistication, budget allocation, and architectural decisions. This guide shows you how to integrate vendor detection into your ICP scoring system programmatically.

The Components of Tech Stack-Based Scoring

A tech stack scoring model has three parts:

1. Positive signals: vendors that indicate a good fit
2. Negative signals: vendors that indicate a poor fit or wrong segment
3. Absence signals: missing vendors that suggest timing or maturity gaps

For a horizontal dev tools product, positive signals might include cloud infrastructure (AWS, Google Cloud, Azure), modern data stacks (Snowflake, Databricks), and engineering productivity tools (Slack, GitHub). Negative signals might include legacy on-premise systems or consumer-focused platforms.

For a vertical sales tool targeting AI companies, positive signals are AI/ML vendors (OpenAI, Anthropic, Hugging Face), while absence of a CRM might indicate early stage—possibly too early.

Implementation: Scoring Leads with the VendorStacks API

Here's a practical example: scoring inbound leads for a B2B data infrastructure product. Our ICP uses modern cloud infrastructure, has a data warehouse, and runs meaningful analytics workloads.

import requests

API_KEY = "vr_live_your_key_here"
BASE_URL = "https://api.vendorstacks.com/v1"

def get_vendor_stack(domain):
    """Fetch vendor stack for a domain."""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.get(
        f"{BASE_URL}/check",
        params={"url": domain},
        headers=headers
    )
    return response.json()

def calculate_tech_stack_score(vendor_data):
    """Score a lead based on their tech stack."""
    if not vendor_data.get("found"):
        return {"score": 0, "reason": "No tech stack detected"}
    
    stack = vendor_data.get("vendor_stack", {})
    score = 0
    signals = []
    
    # Cloud infrastructure (strong positive)
    cloud_vendors = stack.get("cloud_infra", [])
    if any(v in cloud_vendors for v in ["AWS", "Google Cloud", "Microsoft Azure"]):
        score += 30
        signals.append("Modern cloud infrastructure")
    
    # Data warehouse (strong positive)
    data_vendors = stack.get("database_infra", [])
    if "Snowflake" in data_vendors or "Databricks" in data_vendors:
        score += 25
        signals.append("Data warehouse detected")
    
    # Analytics tools (moderate positive)
    analytics = stack.get("analytics_data", [])
    if analytics:
        score += 15
        signals.append(f"Analytics: {', '.join(analytics[:2])}")
    
    # Modern sales tools (positive for budget/maturity)
    sales_tools = stack.get("crm_sales", [])
    if "Salesforce" in sales_tools or "HubSpot" in sales_tools:
        score += 10
        signals.append("Enterprise sales tools")
    
    # Payment processing (indicates B2B SaaS)
    payments = stack.get("payments", [])
    if "Stripe" in payments:
        score += 10
        signals.append("Stripe integration")
    
    return {
        "score": score,
        "signals": signals,
        "stack_summary": stack
    }

# Score an inbound lead
lead_domain = "acme-corp.com"
vendor_data = get_vendor_stack(lead_domain)
score_result = calculate_tech_stack_score(vendor_data)

print(f"Domain: {lead_domain}")
print(f"Tech Stack Score: {score_result['score']}/100")
print(f"Signals: {', '.join(score_result['signals'])}")

This returns structured scoring you can feed into your CRM, routing logic, or sales prioritization system.

Real Distribution Data for Calibration

When building your scoring model, calibrate against real adoption rates. In VendorStacks' index of 1,000 companies:

• AWS: 402 companies (40.2%)
• Google Analytics: 288 companies (28.8%)
• Stripe: 263 companies (26.3%)
• OpenAI: 221 companies (22.1%)
• Google Cloud: 193 companies (19.3%)
• Anthropic: 187 companies (18.7%)
• Cloudflare: 162 companies (16.2%)
• Salesforce: 159 companies (15.9%)
• Slack: 156 companies (15.6%)
• Snowflake: 146 companies (14.6%)
• HubSpot: 143 companies (14.3%)

If your ICP requires Snowflake adoption, you're targeting roughly 15% of the B2B SaaS market. That's a feature, not a bug—specificity improves conversion rates. If 80% of your customers use Snowflake but only 15% of prospects do, that's a powerful qualifying signal.

Handling Edge Cases

No stack found: The API returns "found": false when no public evidence exists. This doesn't mean the company uses nothing—it means they have minimal public web presence. For enterprise products, this might indicate a non-technical buyer. For developer tools, it's a red flag.

Partial stacks: Most companies expose 3-8 vendors publicly. You won't see their entire stack. Score based on what's visible. A company showing AWS + Stripe + Salesforce is likely using 20+ other tools you can't see, but those three alone tell you plenty.

Confidence levels: The API returns vendor_confidence (typically "high" or "medium") based on evidence strength. Weight high-confidence detections more heavily in scoring.

def calculate_weighted_score(vendor_data):
    """Score with confidence weighting."""
    stack = vendor_data.get("vendor_stack", {})
    confidence = vendor_data.get("vendor_confidence", "medium")
    
    base_score = calculate_tech_stack_score(vendor_data)["score"]
    
    # Apply confidence multiplier
    multiplier = 1.0 if confidence == "high" else 0.7
    
    return int(base_score * multiplier)

Combining with Firmographic Data

Tech stack scoring works best alongside traditional ICP dimensions:

def calculate_composite_score(domain, firmographic_data):
    """Combine tech stack and firmographic scoring."""
    # Firmographic score (0-50)
    firmographic_score = 0
    if 50 <= firmographic_data.get("employee_count", 0) <= 500:
        firmographic_score += 25
    if firmographic_data.get("industry") in ["Software", "Technology"]:
        firmographic_score += 25
    
    # Tech stack score (0-50)
    vendor_data = get_vendor_stack(domain)
    tech_score = calculate_tech_stack_score(vendor_data)["score"]
    tech_score = min(tech_score, 50)  # Cap at 50
    
    return {
        "total_score": firmographic_score + tech_score,
        "firmographic": firmographic_score,
        "tech_stack": tech_score
    }

A 200-person company in the right industry with a modern data stack scores 100/100. The same company without the tech stack scores 50/100. That delta changes routing decisions, sales effort allocation, and discount authority.

Integration Patterns

CRM enrichment: Run tech stack lookups on new leads and write scores to custom fields. In Salesforce, this might be a workflow that triggers on lead creation, calls your scoring API (which calls VendorStacks), and updates Tech_Stack_Score__c.

Lead routing: Score inbound leads in real-time and route high scorers (80+) to senior AEs, medium scorers (50-79) to SDRs, low scorers (<50) to nurture sequences.

Account prioritization: Score your TAM list and use it for territory planning. The top 20% by composite score gets white-glove outreach. The rest gets scaled campaigns.

Measuring Effectiveness

Track how tech stack scoring performs:

• Correlation with close rate: Do high-scoring leads close at higher rates?
• Time to close: Do high-scoring leads move faster through the pipeline?
• ACV by segment: Do high-scoring accounts buy larger contracts?

If leads with cloud infrastructure + data warehouse close at 35% while leads without close at 8%, you've validated the model. If there's no correlation, your ICP assumptions need revision.

Cost Management

VendorStacks charges 1 credit per successful lookup. A lookup that finds nothing costs 0 credits. For ICP scoring:

• Score new inbound leads in real-time (~100-500/month for most B2B companies)
• Batch score your TAM list quarterly (~5,000-20,000 domains)
• Cache results for 90 days to avoid re-scoring the same domain

With the $50/6,000 credit pack, you can score 6,000 domains for $50, or about $0.008 per lead. Compare that to the cost of an SDR spending 20 minutes manually researching a poor-fit lead.

Conclusion

ICP scoring with tech stack data turns vendor adoption into actionable lead intelligence. Instead of guessing which companies are good fits based on employee count and LinkedIn descriptions, you're reading direct evidence of their architecture, maturity, and budget allocation.

The VendorStacks API gives you programmatic access to this data with sub-second response times for indexed domains. Build it into your lead scoring system, measure the impact on conversion rates, and iterate on the signals that matter for your specific ICP.

Start with 25 free credits at https://api.vendorstacks.com—no payment method required.