How to personalize onboarding with Linkup

Automate research at the moment of onboarding to power personalized journeys for customers, employees, partners, and vendors—without manual research bottlenecks.

In This Guide

Customer Onboarding Personalization

Tailor onboarding based on company profile and use case signals

Employee Onboarding Context

Prepare teams with new hire background and work style insights

Partner Onboarding Research

Structure partnership approach based on capabilities and alignment

Vendor Onboarding Due Diligence

Risk assessment and relationship setup for new vendors

User Onboarding (B2C/PLG)

Personalize product-led onboarding based on user context

Account Expansion Onboarding

Contextual onboarding for existing customers expanding

Overview

Generic onboarding creates friction. Whether you're onboarding new customers, employees, partners, or vendors, the experience improves dramatically when it's tailored to who they are, what they need, and where they're coming from. Linkup enables automated research at the moment of onboarding—gathering context that powers personalized journeys without manual research bottlenecks.

Why Linkup for onboarding personalization?

event-driven

Trigger research automatically when a new entity enters your system

structured output

Returns data in formats that feed directly into onboarding logic

deep search

Gathers comprehensive context from multiple sources

real-time

Personalization from day one, not after manual research

Configuration

Recommended settings for onboarding personalization

Parameter	Value	Why
`depth`	`deep` or `standard`	Match depth to onboarding complexity
`outputType`	`structured`	Feed directly into onboarding automation
`fromDate`	`30-90 days`	Surface current context, not historical noise

Use Cases

Practical examples with prompts and schemas

Customer Onboarding Personalization

Tailor the customer onboarding experience based on company profile, industry, and use case signals.

Prompt- Customer Onboarding

You are an onboarding research assistant preparing to welcome a new customer.

New customer: {company_name}
Domain: {company_domain}
Plan/product purchased: {product}
Contact name: {contact_name}
Contact title: {contact_title}

Research this customer to personalize their onboarding:

1. Company Profile:
   - Scrape {company_domain} for company description, products/services, and target market
   - Find company size (employees) and industry classification
   - Identify their technology stack if visible (job postings, builtwith, etc.)

2. Use Case Signals:
   - Based on their industry and the contact's role ({contact_title}), infer likely use cases for {product}
   - Search for any public information about challenges in their industry that {product} solves
   - Check if they've mentioned relevant pain points publicly

3. Onboarding Context:
   - Search for any existing content they've created about topics related to {product}
   - Find their competitors (helps contextualize their needs)
   - Identify any integrations they likely use based on their stack

4. Relationship Context:
   - Search for any previous mentions of our company or product
   - Check if they've used competitor products (migration context)
   - Find mutual connections or shared customers

Return data to power personalized onboarding flows.

Onboarding Segmentation Logic (Example)

Based on research, route to appropriate onboarding track:

IF employee_count > 1000 AND enterprise_plan:
  → Enterprise onboarding (white-glove, dedicated CSM)

IF tech_stack includes [specific integrations]:
  → Integration-focused onboarding (start with connections)

IF competitor_products_used is not empty:
  → Migration onboarding (import wizards, comparison guides)

IF industry in [regulated industries]:
  → Compliance-focused onboarding (security docs, certifications)

IF contact_title contains "Developer" or "Engineer":
  → Technical onboarding (API-first, documentation-heavy)

ELSE:
  → Standard onboarding (product tour, quick wins)

Employee Onboarding Context

Gather context about new hires to personalize their onboarding experience and prepare their team.

Prompt- Employee Onboarding

You are an HR research assistant preparing for a new employee's onboarding.

New hire: {employee_name}
Role: {role}
Department: {department}
Start date: {start_date}
Previous company: {previous_company}

Research this new hire to personalize their onboarding:

1. Professional Background:
   - Find their LinkedIn profile for career history
   - Identify skills and expertise areas
   - Note their previous company's culture and size (adjustment context)

2. Work Style Signals:
   - Search for any content they've published (writing style, interests)
   - Find conference talks or podcasts (communication style)
   - Identify professional communities they're active in

3. Role Preparation:
   - Search for how their previous company ({previous_company}) approaches {department}
   - Identify tools and processes they're likely familiar with
   - Find any public work or projects they've contributed to

Return insights to help the team prepare and personalize onboarding.

Partner Onboarding Research

Research new partners to structure the right onboarding and partnership approach.

Prompt- Partner Onboarding

You are a partnerships research assistant preparing for a new partner onboarding.

New partner: {partner_company}
Partner type: {partner_type}
Partnership focus: {partnership_focus}
Partner contact: {contact_name}, {contact_title}

Research this partner to inform onboarding:

1. Partner Company Profile:
   - Scrape their website for business model and offerings
   - Identify their target customer segments
   - Find their geographic coverage and market presence
   - Assess company size and growth stage

2. Partnership Context:
   - Search for their existing partnerships and integrations
   - Identify how they work with companies similar to us
   - Find any case studies or success stories from their partnerships
   - Check for partner program tiers they participate in

3. Technical Readiness:
   - Search for their technical capabilities and team
   - Identify their tech stack and development resources
   - Find any public APIs or integrations they've built
   - Assess their documentation and developer resources

4. Go-to-Market Alignment:
   - Identify overlap in target customers
   - Find their sales motion and channels
   - Search for their marketing approach and content
   - Identify co-marketing opportunities

5. Relationship Intelligence:
   - Search for any previous interactions or mentions
   - Find mutual customers or connections
   - Check for any competitive considerations

Return insights for partnership onboarding planning.

Vendor Onboarding Due Diligence

Research new vendors during onboarding for risk assessment and relationship setup.

Prompt- Vendor Due Diligence

You are a vendor management research assistant conducting onboarding due diligence.

Vendor: {vendor_name}
Vendor domain: {vendor_domain}
Service category: {service_category}
Procurement contact: {contact_name}

Research this vendor for onboarding:

1. Company Verification:
   - Verify company registration and legal entity
   - Find headquarters location and operational locations
   - Identify company age and stability indicators
   - Check for any recent ownership or structural changes

2. Financial Health:
   - Search for any funding announcements or financial news
   - Look for signs of financial distress (layoffs, restructuring)
   - Find customer base indicators (client logos, case studies)
   - Check for recent growth or contraction signals

3. Reputation & Risk:
   - Search for customer reviews and complaints
   - Find any regulatory issues or legal problems
   - Check for data breaches or security incidents
   - Look for news about service outages or quality issues

4. Service Capability:
   - Scrape their website for service descriptions
   - Find certifications and compliance credentials
   - Identify their technology and security practices
   - Look for SLA commitments and support levels

5. Relationship Context:
   - Find their other major clients
   - Search for testimonials and case studies
   - Check for any existing relationships with our industry
   - Identify key contacts beyond procurement

Return risk assessment and onboarding recommendations.

User Onboarding Personalization (B2C/PLG)

Personalize product-led onboarding based on user context.

Prompt- PLG User Onboarding

You are a product personalization assistant preparing user onboarding.

User email: {user_email}
User name: {user_name}
Signup source: {signup_source}
Product: {product}

Research this user to personalize their onboarding:

1. Professional Context (from email domain):
   - If business email, research the company
   - Identify company size, industry, and likely use case
   - Find the user's likely role based on available signals

2. User Background (if findable):
   - Search for their LinkedIn profile
   - Identify their role and seniority
   - Note relevant skills or interests

3. Use Case Inference:
   - Based on company + role, infer likely use case for {product}
   - Identify which features would be most relevant
   - Note any specific pain points their role typically has

4. Personalization Signals:
   - Determine appropriate onboarding complexity (technical vs. simple)
   - Identify relevant templates or examples to show
   - Suggest personalized quick wins

Return onboarding personalization parameters.
Note: If personal email or limited information, return safe defaults.

Account Expansion Onboarding

Research existing customers expanding to new products or teams for contextual onboarding.

Prompt- Account Expansion

You are a customer success research assistant supporting account expansion.

Customer: {customer_name}
Existing products: {current_products}
New product/expansion: {new_product}
New stakeholder: {stakeholder_name}, {stakeholder_title}
Expansion context: {expansion_context}

Research to personalize expansion onboarding:

1. Existing Relationship Context:
   - Review what we know about their current usage and success
   - Identify integration points between {current_products} and {new_product}
   - Note any previous expansion discussions or interests

2. New Stakeholder Research:
   - Find {stakeholder_name}'s LinkedIn profile
   - Understand their role and how they relate to existing users
   - Identify their likely priorities and success metrics

3. Expansion Use Case:
   - Search for how companies like {customer_name} use {new_product}
   - Identify specific use cases relevant to {stakeholder_title}
   - Find success stories from similar expansions

4. Organizational Context:
   - Search for any organizational changes at {customer_name}
   - Identify other teams or stakeholders who might benefit
   - Find any public initiatives that align with {new_product}

Return insights to make expansion onboarding seamless and connected to existing value.

Best Practices

✓ Do's

✓
Trigger research automatically — Run Linkup when a new entity enters your system; don't wait for manual requests
✓
Match research depth to onboarding value — Enterprise customers warrant deep research; self-serve users need lightweight context
✓
Build decision trees from structured output — Use Linkup's structured data to route to the right onboarding track automatically
✓
Cache and reuse intelligently — Company data changes slowly; cache it. Role data changes faster; refresh more often
✓
Fail gracefully — Not everyone has a rich online presence. Design onboarding that works with or without enrichment
✓
Use signals, not assumptions — Present what you found as helpful context, not creepy surveillance

✗ Don'ts

✗
Don't skip privacy norms — Stick to professional, publicly available information
✗
Don't research once and forget — Refresh context at key moments (renewal, expansion, escalation)
✗
Don't over-personalize creepily — There's a line between helpful and invasive; stay on the right side

Integration Patterns

Event-Driven Onboarding Enrichment

Trigger: New signup / contract signed / employee start date set
Receive event (webhook, queue message)
Extract identifiers (email, company, name)
Call Linkup with appropriate prompt for onboarding type
Store enrichment data in customer/employee record
Feed into onboarding automation (select track, personalize messaging, prioritize features)

Onboarding Segmentation Flow

┌─────────────────────────────────────────────────────────────────┐
│                    New Entity Created                           │
└─────────────────────┬───────────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│               Linkup Enrichment                                 │
│  - Company profile                                              │
│  - Stakeholder context                                          │
│  - Use case signals                                             │
└─────────────────────┬───────────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│             Segmentation Logic                                  │
│                                                                 │
│  IF enterprise + regulated industry → Compliance Track          │
│  IF technical role → Developer Track                            │
│  IF migration from competitor → Migration Track                 │
│  IF SMB + simple use case → Self-Serve Track                    │
│  ELSE → Standard Track                                          │
└─────────────────────┬───────────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│           Personalized Onboarding                               │
│  - Track-specific email sequences                               │
│  - Relevant feature highlights                                  │
│  - Matched case studies / templates                             │
│  - Appropriate resource assignment                              │
└─────────────────────────────────────────────────────────────────┘

Pro Tip

For high-volume onboarding, implement a queue system with rate limiting to stay within API limits while ensuring every new entity gets personalized context.

Sample Integration Code

onboarding_enrichment.py

import requests
import json
from typing import Optional
from enum import Enum

class OnboardingTrack(Enum):
    ENTERPRISE = "enterprise"
    DEVELOPER = "developer"
    MIGRATION = "migration"
    SELF_SERVE = "self_serve"
    STANDARD = "standard"

class LinkupOnboardingEnrichment:
    """Linkup integration for onboarding personalization"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.linkup.so/v1/search"

    def _call_linkup(
        self,
        prompt: str,
        schema: dict,
        depth: str = "deep"
    ) -> dict:
        response = requests.post(
            self.base_url,
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "q": prompt,
                "depth": depth,
                "outputType": "Structured",
                "StructuredSchema": json.dumps(schema)
            }
        )
        return response.json()

    def enrich_new_customer(
        self,
        company_name: str,
        company_domain: str,
        contact_name: str,
        contact_title: str,
        product: str
    ) -> dict:
        """Enrich a new customer for onboarding personalization"""

        prompt = f"""
        Research new customer for onboarding personalization:

        Company: {company_name}
        Domain: {company_domain}
        Contact: {contact_name}, {contact_title}
        Product purchased: {product}

        1. Scrape {company_domain} for company description, industry, and size.
        2. Identify their tech stack and likely integrations.
        3. Infer likely use cases based on industry and contact role.
        4. Search for competitor products they may be migrating from.
        5. Find relevant talking points and case study matches.

        Return structured onboarding personalization data.
        """

        schema = {
            "type": "object",
            "properties": {
                "company_profile": {
                    "type": "object",
                    "properties": {
                        "description": {"type": "string"},
                        "industry": {"type": "string"},
                        "employee_count": {"type": "string"},
                        "company_type": {"type": "string"}
                    }
                },
                "tech_stack": {"type": "array", "items": {"type": "string"}},
                "likely_use_cases": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "use_case": {"type": "string"},
                            "confidence": {"type": "string"}
                        }
                    }
                },
                "migration_context": {
                    "type": "object",
                    "properties": {
                        "migrating_from": {"type": "string"},
                        "migration_signals": {"type": "array", "items": {"type": "string"}}
                    }
                },
                "personalization": {
                    "type": "object",
                    "properties": {
                        "recommended_track": {"type": "string"},
                        "priority_features": {"type": "array", "items": {"type": "string"}},
                        "relevant_case_studies": {"type": "array", "items": {"type": "string"}},
                        "talking_points": {"type": "array", "items": {"type": "string"}}
                    }
                }
            }
        }

        return self._call_linkup(prompt, schema)

    def enrich_new_employee(
        self,
        employee_name: str,
        role: str,
        department: str,
        previous_company: Optional[str] = None
    ) -> dict:
        """Enrich a new employee for onboarding preparation"""

        previous_context = f"Previous company: {previous_company}" if previous_company else ""

        prompt = f"""
        Research new employee for onboarding:

        Name: {employee_name}
        Role: {role}
        Department: {department}
        {previous_context}

        1. Find their LinkedIn profile for career history.
        2. Identify skills and expertise areas.
        3. Research their previous company's culture and tools.
        4. Find any content they've published.
        5. Identify connection opportunities with the team.

        Return onboarding preparation insights.
        """

        schema = {
            "type": "object",
            "properties": {
                "linkedin_url": {"type": "string"},
                "professional_background": {
                    "type": "object",
                    "properties": {
                        "years_experience": {"type": "number"},
                        "key_skills": {"type": "array", "items": {"type": "string"}},
                        "previous_companies": {"type": "array", "items": {"type": "string"}}
                    }
                },
                "previous_company_context": {
                    "type": "object",
                    "properties": {
                        "size": {"type": "string"},
                        "culture_notes": {"type": "string"},
                        "tools_used": {"type": "array", "items": {"type": "string"}}
                    }
                },
                "onboarding_recommendations": {
                    "type": "object",
                    "properties": {
                        "buddy_match_criteria": {"type": "array", "items": {"type": "string"}},
                        "training_priorities": {"type": "array", "items": {"type": "string"}},
                        "adjustment_notes": {"type": "array", "items": {"type": "string"}}
                    }
                }
            }
        }

        return self._call_linkup(prompt, schema)

    def determine_onboarding_track(self, enrichment_data: dict) -> OnboardingTrack:
        """Determine onboarding track based on enrichment data"""

        company = enrichment_data.get("company_profile", {})
        migration = enrichment_data.get("migration_context", {})
        personalization = enrichment_data.get("personalization", {})

        # Enterprise check
        employee_count = company.get("employee_count", "")
        if any(x in employee_count.lower() for x in ["1000", "enterprise", "10,000"]):
            return OnboardingTrack.ENTERPRISE

        # Migration check
        if migration.get("migrating_from"):
            return OnboardingTrack.MIGRATION

        # Developer check (from recommended track)
        if personalization.get("recommended_track") == "technical":
            return OnboardingTrack.DEVELOPER

        # SMB self-serve check
        if any(x in employee_count.lower() for x in ["1-10", "11-50", "small"]):
            return OnboardingTrack.SELF_SERVE

        return OnboardingTrack.STANDARD

    def enrich_plg_user(
        self,
        user_email: str,
        user_name: str,
        product: str
    ) -> dict:
        """Lightweight enrichment for PLG user onboarding"""

        # Extract domain from email
        domain = user_email.split("@")[1] if "@" in user_email else None
        is_business_email = domain and domain not in [
            "gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "icloud.com"
        ]

        if not is_business_email:
            return {
                "email_type": "personal",
                "personalization": {
                    "onboarding_track": "standard",
                    "complexity_level": "simple"
                },
                "confidence": "low"
            }

        prompt = f"""
        Quick research for PLG user onboarding:

        User: {user_name}
        Email domain: {domain}
        Product: {product}

        1. Research the company at {domain} - size, industry.
        2. Infer likely role based on available signals.
        3. Suggest appropriate onboarding complexity.

        Keep research lightweight for fast response.
        """

        schema = {
            "type": "object",
            "properties": {
                "email_type": {"type": "string"},
                "company_context": {
                    "type": "object",
                    "properties": {
                        "company_name": {"type": "string"},
                        "industry": {"type": "string"},
                        "size": {"type": "string"}
                    }
                },
                "user_context": {
                    "type": "object",
                    "properties": {
                        "likely_role": {"type": "string"},
                        "technical_level": {"type": "string"}
                    }
                },
                "personalization": {
                    "type": "object",
                    "properties": {
                        "onboarding_track": {"type": "string"},
                        "complexity_level": {"type": "string"},
                        "suggested_first_action": {"type": "string"}
                    }
                },
                "confidence": {"type": "string"}
            }
        }

        return self._call_linkup(prompt, schema, depth="standard")

# Example usage
if __name__ == "__main__":
    enricher = LinkupOnboardingEnrichment(api_key="your-api-key")

    # Customer onboarding
    customer_data = enricher.enrich_new_customer(
        company_name="Acme Corp",
        company_domain="acme.com",
        contact_name="Jane Smith",
        contact_title="VP Engineering",
        product="Enterprise Plan"
    )

    track = enricher.determine_onboarding_track(customer_data)
    print(f"Onboarding track: {track.value}")

    # Employee onboarding
    employee_data = enricher.enrich_new_employee(
        employee_name="John Doe",
        role="Senior Engineer",
        department="Platform",
        previous_company="Google"
    )

    # PLG user onboarding
    user_data = enricher.enrich_plg_user(
        user_email="jane@techstartup.io",
        user_name="Jane",
        product="Linkup API"
    )

python