Static approach:
"Companies like Microsoft and Google use us!"

Prospect thinking:
"I'm not Microsoft. We're a 50-person startup."
Not relevant = not compelling.

Matched approach:
"[Similar-size SaaS company] saw 40% improvement.
They had the same challenge you mentioned."

Prospect thinking:
"They're like us. If it worked for them..."
Relevant = believable = compelling.

Direct quotes from customers:

"We cut our sales cycle by 30%."
- Sarah Chen, VP Sales at TechCorp

Best for:
- Emotional resonance
- Credibility from real person
- Quick impact

Detailed customer stories:

TechCorp: 500-person SaaS company
Challenge: Long sales cycles
Solution: Implemented [product]
Result: 30% faster close, $2M additional revenue

Best for:
- Analytical buyers
- Similar situations
- Proving methodology

Aggregate data:

"Our customers average 3.2x ROI"
"92% of users see results in 30 days"
"4.8/5 satisfaction rating"

Best for:
- Building credibility
- Supporting claims
- Analytical prospects

Visual credibility:

"Trusted by 500+ companies including..."
[Logo] [Logo] [Logo]

Best for:
- Establishing legitimacy
- Enterprise sales
- Aspirational alignment

Real-time social proof:

"15 companies signed up this week"
"Sarah from TechCorp is also exploring this"
"Most popular choice for teams your size"

Best for:
- FOMO creation
- Validating popularity
- Reducing risk perception

def select_social_proof(prospect):
    context = {
        "industry": prospect.industry,
        "company_size": prospect.employees,
        "role": prospect.title,
        "use_case": prospect.stated_needs,
        "stage": prospect.sales_stage,
        "pain_points": prospect.pain_points,
        "objections": prospect.objections_raised
    }

    # Find matching proof
    candidates = get_social_proof_library()
    scored = []

    for proof in candidates:
        score = calculate_relevance(proof, context)
        scored.append((proof, score))

    # Return top matches
    return sorted(scored, key=lambda x: -x[1])[:3]

def calculate_relevance(proof, context):
    score = 0
    weights = {
        "industry_match": 30,
        "size_match": 25,
        "role_match": 20,
        "use_case_match": 15,
        "pain_point_match": 10
    }

    # Industry match
    if proof.customer_industry == context["industry"]:
        score += weights["industry_match"]
    elif proof.customer_industry in related_industries(context["industry"]):
        score += weights["industry_match"] * 0.5

    # Size match
    size_diff = abs(proof.customer_size - context["company_size"])
    size_factor = max(0, 1 - (size_diff / context["company_size"]))
    score += weights["size_match"] * size_factor

    # Role match
    if proof.quote_role_level == get_role_level(context["role"]):
        score += weights["role_match"]

    # Use case match
    use_case_overlap = len(set(proof.use_cases) & set(context["use_case"]))
    score += weights["use_case_match"] * min(1, use_case_overlap / 2)

    # Pain point match
    if any(pain in proof.pain_points_addressed for pain in context["pain_points"]):
        score += weights["pain_point_match"]

    return score

Early in sequence, establish credibility:

"[Similar company] was dealing with the same
[pain point] before they found us. Happy to
share what worked for them."

Inject: Similar customer reference, early.

When they reveal a challenge:

"You mentioned [pain point]. [Customer name]
told us the same thing—here's what they did
about it: [brief summary/link]"

Inject: Directly relevant case study.

When they raise concerns:

Objection: "We tried something similar before"
Response: "[Customer] had the same concern.
They'd been burned by [competitor]. Here's
what made the difference: [specific detail]"

Inject: Proof that overcomes specific objection.

When close to deciding:

"Teams like yours typically see [result].
Here's a 2-minute video from [Customer VP]
explaining their experience."

Inject: High-impact proof for final push.

class SocialProofLibrary:
    def __init__(self):
        self.proofs = []

    def add_proof(self, proof):
        self.proofs.append({
            "id": generate_id(),
            "type": proof["type"],  # testimonial, case_study, metric
            "content": proof["content"],
            "customer": {
                "name": proof["customer_name"],
                "industry": proof["industry"],
                "size": proof["company_size"],
                "logo": proof["logo_url"]
            },
            "quote_source": proof.get("quote_source"),
            "metrics": proof.get("metrics", {}),
            "pain_points": proof.get("pain_points", []),
            "use_cases": proof.get("use_cases", []),
            "objections_addressed": proof.get("objections", []),
            "media": proof.get("media"),  # video, pdf, link
            "verified": proof.get("verified", False),
            "recency": proof.get("date")
        })

    def find_matches(self, context, limit=3):
        scored = []
        for proof in self.proofs:
            score = calculate_relevance(proof, context)
            if score > MINIMUM_RELEVANCE_THRESHOLD:
                scored.append((proof, score))

        return sorted(scored, key=lambda x: -x[1])[:limit]

def inject_social_proof(message, prospect, injection_point):
    # Find matching proof
    matches = social_proof_library.find_matches(
        context=get_prospect_context(prospect),
        limit=1
    )

    if not matches:
        return message  # No relevant proof available

    proof = matches[0][0]

    # Format based on type and context
    if proof["type"] == "testimonial":
        injection = format_testimonial(proof)
    elif proof["type"] == "case_study":
        injection = format_case_study_teaser(proof)
    elif proof["type"] == "metric":
        injection = format_metric(proof)

    # Insert at appropriate point
    return insert_into_message(message, injection, injection_point)

def format_testimonial(proof):
    return f'''
"{proof['content']}"
— {proof['quote_source']['name']}, {proof['quote_source']['title']} at {proof['customer']['name']}
'''

def format_case_study_teaser(proof):
    return f'''
{proof['customer']['name']} ({proof['customer']['industry']}, {proof['customer']['size']} employees)
saw {proof['metrics']['headline_result']} after implementing our solution.
[See the full story]({proof['media']['link']})
'''

def select_proof_for_objection(objection, prospect):
    # Map objection to proof need
    objection_mapping = {
        "too_expensive": "roi_focused_proof",
        "bad_past_experience": "similar_skeptic_success",
        "competitor_using": "competitor_switch_story",
        "implementation_concern": "fast_implementation_proof",
        "team_adoption": "high_adoption_story"
    }

    proof_need = objection_mapping.get(objection.type, "general_success")

    # Find proof that addresses this objection
    matches = social_proof_library.find_matches(
        context={
            "objection_type": objection.type,
            "industry": prospect.industry,
            "size": prospect.employees
        }
    )

    return matches[0][0] if matches else None

Strong proof:
- Specific metrics ("40% improvement")
- Named customer (with permission)
- Relevant to prospect's situation
- Recent (last 2 years)
- Verifiable

Weak proof:
- Vague ("great results")
- Anonymous ("a customer said")
- Irrelevant industry/size
- Outdated
- Unverifiable

Don't overdo it:
- 1 proof per message max
- 2-3 proofs per conversation
- Vary the type
- Make it natural

Too much proof = desperate.
Right amount = credible.

BAD:
"Buy our product. Also, Company X likes us.
And Company Y. And here's a case study.
And a testimonial."

GOOD:
"You mentioned [pain]. That's exactly what
[Company] was dealing with. They found that
[solution] made a big difference. [Brief result].
Happy to share more if helpful."

Integrate, don't dump.

Track:
- Response rate when proof included
- Conversion rate by proof type
- Which proofs get clicked/engaged
- A/B test proof vs no proof

Optimize:
- Which industries respond to which proof?
- What format works best?
- Which customers make best references?