What Is The Customer Onboarding Process?
The moment a prospect becomes a customer represents a critical transition in the customer journey. This is where the promises made during the sales process must be fulfilled, and the foundation for a long-term relationship is established. HubSpot’s Service Hub provides powerful tools to automate and optimize the customer onboarding process, ensuring consistent experiences and setting new clients up for success.
Why Customer Onboarding Matters
An effective customer onboarding process delivers multiple benefits to both your organization and your customers:
- Reduces time-to-value: Helps customers realize benefits from your product or service faster
- Decreases churn risk: Well-onboarded customers are less likely to cancel early
- Increases expansion opportunities: Properly educated customers adopt more features and services
- Improves customer satisfaction: Clear expectations and guidance create positive experiences
- Reduces support burden: Proactive education minimizes reactive support requests
- Standardizes processes: Ensures consistent quality regardless of which team member is involved
- Scales efficiently: Allows you to onboard more customers without proportionally increasing staff
Research shows that customers who experience a structured onboarding process are 3x more likely to renew or upgrade compared to those who receive inadequate onboarding.
Setting Up Your Customer Onboarding Workflow
Let’s build a comprehensive workflow that automates and optimizes the customer onboarding journey from signed contract to fully implemented customer.
Step 1: Define Your Onboarding Stages
Before building the workflow, establish clear stages for your onboarding process:
- Welcome: Initial welcome and account setup
- Kickoff: Formal introduction to your team and process
- Implementation: Technical setup and configuration
- Training: User education and adoption
- Review: Success verification and feedback collection
- Handoff: Transition to regular customer success management
Step 2: Create the Base Workflow
- Navigate to Automation > Workflows in your HubSpot account
- Click “Create workflow” > “From scratch”
- Select “Contact-based” workflow (or “Company-based” for B2B with multiple contacts)
- Name it “Customer Onboarding Automation”
Step 3: Set Up Enrollment Triggers
Define when contacts should enter the onboarding process:
- Set enrollment trigger: “Lifecycle stage is known” AND “Lifecycle stage equals Customer”
- Alternatively, use “Deal stage equals Closed Won” if you want to trigger from the sales process
- Consider adding a custom property like “Onboarding Status” and trigger when it’s set to “Ready to Start”
Step 4: Welcome Stage Automation
Begin with immediate welcome actions:
- Add a “Delay” action of 0 days (immediate execution)
- Add a “Send email” action with your welcome email template that includes:
- Congratulations message
- Introduction to the onboarding process
- What to expect in the coming days/weeks
- Access to initial resources (customer portal, knowledge base)
- Introduction to their dedicated onboarding specialist
- Add a “Create task” action for the onboarding specialist to make a welcome call
- Add a “Set property value” action to update “Onboarding Status” to “Welcome Complete”
Step 5: Kickoff Meeting Scheduling
Automate the kickoff meeting process:
- Add a “Delay” action of 1 business day after welcome
- Add a “Send email” action with a meeting scheduling link
- Add an “If/then branch” to check if meeting was scheduled within 2 days
- If not scheduled, add a “Create task” for manual follow-up
- After meeting is scheduled, add a “Set property value” action to update “Onboarding Status” to “Kickoff Scheduled”
Step 6: Implementation Phase Automation
Manage the technical implementation process:
- Add a “Wait until” action that pauses until “Kickoff Meeting Held” property equals “Yes”
- Add a “Create task” action to initiate technical implementation
- Add a “Send email” action with implementation requirements and checklist
- Add a “Wait until” action that pauses until “Implementation Status” equals “Complete”
- Add a “Set property value” action to update “Onboarding Status” to “Implementation Complete”
Step 7: Training Coordination
Automate the training process:
- Add a “Send email” action with training scheduling options
- Add a “Create task” for the training team to prepare materials
- Add a “Wait until” action that pauses until “Training Status” equals “Complete”
- Add a “Set property value” action to update “Onboarding Status” to “Training Complete”
Step 8: Success Review and Handoff
Complete the onboarding process:
- Add a “Delay” action of 7 days after training
- Add a “Send email” action with a satisfaction survey
- Add a “Create task” for the onboarding specialist to conduct a success review call
- Add a “Wait until” action that pauses until “Success Review” equals “Complete”
- Add a “Send email” action introducing the ongoing customer success manager
- Add a “Create task” for the customer success manager to schedule their first check-in
- Add a “Set property value” action to update “Onboarding Status” to “Complete”
- Add a “Set property value” action to update “Customer Stage” to “Active”
Advanced Implementation: Custom Code for Personalized Onboarding Path
Implement this custom code to create a sophisticated onboarding path generator that tailors the onboarding experience based on customer attributes and needs:
// Custom code for personalized onboarding path generation
exports.main = (functionContext, sendResponse) => {
// Get customer properties from the workflow
const {
contact_id,
company_id,
product_purchased,
company_size,
industry,
technical_complexity,
goals,
prior_experience,
implementation_timeframe
} = functionContext.parameters;
// Initialize HubSpot client
const hubspot = require('@hubspot/api-client');
const hubspotClient = new hubspot.Client({
accessToken: process.env.PRIVATE_APP_ACCESS_TOKEN
});
async function generateOnboardingPath() {
try {
// Get company information if available
let companyData = {};
if (company_id) {
companyData = await getCompanyData(company_id);
}
// Get product details
const productDetails = getProductDetails(product_purchased);
// Determine complexity level
const complexityLevel = determineComplexityLevel(
technical_complexity,
company_size,
productDetails.complexityScore,
prior_experience
);
// Generate timeline
const timeline = generateTimeline(
complexityLevel,
implementation_timeframe,
productDetails.averageImplementationDays
);
// Determine required resources
const resources = determineRequiredResources(
complexityLevel,
productDetails,
industry,
goals
);
// Create milestone plan
const milestones = createMilestones(
productDetails,
timeline,
complexityLevel
);
// Determine training requirements
const trainingPlan = createTrainingPlan(
productDetails,
company_size,
prior_experience,
goals
);
// Generate success criteria
const successCriteria = generateSuccessCriteria(goals, productDetails);
// Return the personalized onboarding plan
sendResponse({
statusCode: 200,
body: {
customer_name: companyData.name || "New Customer",
onboarding_path: determinePathType(complexityLevel, company_size),
complexity_level: complexityLevel,
estimated_completion_date: timeline.estimatedCompletionDate,
key_milestones: milestones,
required_resources: resources,
training_plan: trainingPlan,
success_criteria: successCriteria,
recommended_customer_actions: generateNextSteps(milestones[0]),
recommended_internal_actions: generateInternalNextSteps(milestones[0], complexityLevel)
}
});
} catch (error) {
// Handle errors
sendResponse({
statusCode: 500,
body: {
error: error.message
}
});
}
}
// Helper function to get company data
async function getCompanyData(companyId) {
// In a real implementation, this would query HubSpot for company details
// For this example, we'll return mock data
return {
name: "Acme Corporation",
size: company_size || "51-200",
industry: industry || "Technology"
};
}
// Helper function to get product details
function getProductDetails(productPurchased) {
// In a real implementation, this would retrieve product information
// from a database or HubSpot custom objects
const productCatalog = {
"basic_crm": {
name: "Basic CRM",
complexityScore: 2,
averageImplementationDays: 14,
requiredModules: ["Contact Management", "Deal Tracking"],
optionalModules: ["Email Integration", "Basic Reporting"],
trainingModules: ["CRM Basics", "Contact Management", "Deal Tracking"]
},
"professional_crm": {
name: "Professional CRM",
complexityScore: 4,
averageImplementationDays: 30,
requiredModules: ["Contact Management", "Deal Tracking", "Automation", "Custom Fields"],
optionalModules: ["API Integration", "Advanced Reporting", "Sales Forecasting"],
trainingModules: ["CRM Basics", "Automation Fundamentals", "Reporting", "Admin Configuration"]
},
"enterprise_suite": {
name: "Enterprise Suite",
complexityScore: 8,
averageImplementationDays: 60,
requiredModules: ["Contact Management", "Deal Tracking", "Automation", "Custom Fields", "API Integration", "Single Sign-On"],
optionalModules: ["Custom Objects", "Advanced Workflows", "Data Migration", "Enterprise Reporting"],
trainingModules: ["CRM Basics", "Automation Advanced", "System Administration", "API & Integration", "Data Management"]
}
};
return productCatalog[productPurchased] || productCatalog["basic_crm"];
}
// Helper function to determine complexity level
function determineComplexityLevel(technicalComplexity, companySize, productComplexity, priorExperience) {
// Convert inputs to numeric scores
const technicalScore = parseInt(technicalComplexity) || 3; // 1-5 scale
let companySizeScore;
switch(companySize) {
case "1-10": companySizeScore = 1; break;
case "11-50": companySizeScore = 2; break;
case "51-200": companySizeScore = 3; break;
case "201-1000": companySizeScore = 4; break;
default: companySizeScore = 5; // 1000+
}
let experienceScore;
switch(priorExperience) {
case "None": experienceScore = 5; break; // Higher score means more support needed
case "Limited": experienceScore = 4; break;
case "Moderate": experienceScore = 3; break;
case "Experienced": experienceScore = 2; break;
case "Expert": experienceScore = 1; break;
default: experienceScore = 4;
}
// Calculate weighted complexity score
const complexityScore = (
(technicalScore * 0.3) +
(companySizeScore * 0.2) +
(productComplexity * 0.3) +
(experienceScore * 0.2)
);
// Determine complexity level
if (complexityScore < 2) return "SIMPLE";
if (complexityScore < 3.5) return "STANDARD";
if (complexityScore < 4.5) return "COMPLEX";
return "ENTERPRISE";
}
// Helper function to determine path type
function determinePathType(complexityLevel, companySize) {
if (complexityLevel === "ENTERPRISE" || companySize === "1000+") {
return "WHITE_GLOVE";
} else if (complexityLevel === "COMPLEX" || companySize === "201-1000") {
return "GUIDED";
} else if (complexityLevel === "STANDARD") {
return "STANDARD";
} else {
return "SELF_SERVICE";
}
}
// Helper function to generate timeline
function generateTimeline(complexityLevel, requestedTimeframe, averageImplementationDays) {
// Calculate base timeline based on complexity
let baseTimelineDays;
switch(complexityLevel) {
case "SIMPLE": baseTimelineDays = averageImplementationDays * 0.7; break;
case "STANDARD": baseTimelineDays = averageImplementationDays; break;
case "COMPLEX": baseTimelineDays = averageImplementationDays * 1.5; break;
case "ENTERPRISE": baseTimelineDays = averageImplementationDays * 2; break;
default: baseTimelineDays = averageImplementationDays;
}
// Adjust for requested timeframe
let adjustedTimelineDays;
switch(requestedTimeframe) {
case "Urgent": adjustedTimelineDays = baseTimelineDays * 0.7; break;
case "Standard": adjustedTimelineDays = baseTimelineDays; break;
case "Relaxed": adjustedTimelineDays = baseTimelineDays * 1.3; break;
default: adjustedTimelineDays = baseTimelineDays;
}
// Calculate estimated completion date
const today = new Date();
const completionDate = new Date(today);
completionDate.setDate(today.getDate() + Math.ceil(adjustedTimelineDays));
// Generate phase durations
return {
estimatedCompletionDate: completionDate.toISOString().split('T')[0],
kickoffPhase: Math.ceil(adjustedTimelineDays * 0.1),
implementationPhase: Math.ceil(adjustedTimelineDays * 0.6),
trainingPhase: Math.ceil(adjustedTimelineDays * 0.2),
reviewPhase: Math.ceil(adjustedTimelineDays * 0.1),
totalDays: Math.ceil(adjustedTimelineDays)
};
}
// Helper function to determine required resources
function determineRequiredResources(complexityLevel, productDetails, industry, goals) {
const resources = {
documentation: [],
tools: [],
personnel: []
};
// Add base documentation
resources.documentation.push("Getting Started Guide");
resources.documentation.push("Product Documentation");
// Add required modules documentation
productDetails.requiredModules.forEach(module => {
resources.documentation.push(`${module} Setup Guide`);
});
// Add industry-specific resources if available
if (industry) {
resources.documentation.push(`${industry} Best Practices Guide`);
}
// Add tools based on complexity
resources.tools.push("Customer Portal Access");
if (complexityLevel === "COMPLEX" || complexityLevel === "ENTERPRISE") {
resources.tools.push("Implementation Project Plan");
resources.tools.push("Data Migration Tool");
resources.tools.push("API Documentation");
}
// Add personnel based on complexity
switch(complexityLevel) {
case "SIMPLE":
resources.personnel.push("Customer Success Specialist");
break;
case "STANDARD":
resources.personnel.push("Onboarding Specialist");
resources.personnel.push("Customer Success Manager");
break;
case "COMPLEX":
resources.personnel.push("Implementation Consultant");
resources.personnel.push("Technical Specialist");
resources.personnel.push("Customer Success Manager");
break;
case "ENTERPRISE":
resources.personnel.push("Senior Implementation Consultant");
resources.personnel.push("Technical Architect");
resources.personnel.push("Project Manager");
resources.personnel.push("Executive Sponsor");
resources.personnel.push("Customer Success Director");
break;
}
return resources;
}
// Helper function to create milestones
function createMilestones(productDetails, timeline, complexityLevel) {
const milestones = [];
const today = new Date();
// Welcome milestone
milestones.push({
name: "Welcome and Account Setup",
description: "Initial welcome, account creation, and resource sharing",
dueDate: today.toISOString().split('T')[0],
assignedTo: "Onboarding Team",
completionCriteria: "Welcome call completed, account access confirmed"
});
// Kickoff milestone
const kickoffDate = new Date(today);
kickoffDate.setDate(today.getDate() + 3);
milestones.push({
name: "Project Kickoff",
description: "Formal kickoff meeting to align on goals, timeline, and responsibilities",
dueDate: kickoffDate.toISOString().split('T')[0],
assignedTo: "Onboarding Specialist",
completionCriteria: "Kickoff meeting held, project plan approved"
});
// Implementation milestones - vary based on product and complexity
const implementationStartDate = new Date(kickoffDate);
implementationStartDate.setDate(kickoffDate.getDate() + 1);
// Core setup milestone
const coreSetupDate = new Date(implementationStartDate);
coreSetupDate.setDate(implementationStartDate.getDate() + Math.ceil(timeline.implementationPhase * 0.3));
milestones.push({
name: "Core System Setup",
description: "Implementation of core modules and basic configuration",
dueDate: coreSetupDate.toISOString().split('T')[0],
assignedTo: "Implementation Team",
completionCriteria: "Core modules configured and tested"
});
// Add complexity-specific milestones
if (complexityLevel === "COMPLEX" || complexityLevel === "ENTERPRISE") {
// Data migration milestone
const dataMigrationDate = new Date(coreSetupDate);
dataMigrationDate.setDate(coreSetupDate.getDate() + Math.ceil(timeline.implementationPhase * 0.3));
milestones.push({
name: "Data Migration",
description: "Migration of customer data into the system",
dueDate: dataMigrationDate.toISOString().split('T')[0],
assignedTo: "Data Migration Specialist",
completionCriteria: "All data migrated and verified"
});
// Integration milestone
const integrationDate = new Date(dataMigrationDate);
integrationDate.setDate(dataMigrationDate.getDate() + Math.ceil(timeline.implementationPhase * 0.3));
milestones.push({
name: "System Integrations",
description: "Setup of required integrations with other systems",
dueDate: integrationDate.toISOString().split('T')[0],
assignedTo: "Technical Specialist",
completionCriteria: "All integrations configured and tested"
});
}
// Training milestone
const trainingDate = new Date(today);
trainingDate.setDate(today.getDate() + timeline.kickoffPhase + timeline.implementationPhase);
milestones.push({
name: "User Training",
description: "Training sessions for customer team members",
dueDate: trainingDate.toISOString().split('T')[0],
assignedTo: "Training Specialist",
completionCriteria: "All scheduled training sessions completed"
});
// Review milestone
const reviewDate = new Date(trainingDate);
reviewDate.setDate(trainingDate.getDate() + timeline.trainingPhase);
milestones.push({
name: "Success Review",
description: "Review of implementation success and goal achievement",
dueDate: reviewDate.toISOString().split('T')[0],
assignedTo: "Customer Success Manager",
completionCriteria: "Success review meeting held, all success criteria met"
});
return milestones;
}
// Helper function to create training plan
function createTrainingPlan(productDetails, companySize, priorExperience, goals) {
const trainingPlan = {
recommendedSessions: [],
materials: [],
certificationPath: null
};
// Add core training sessions based on product
productDetails.trainingModules.forEach(module => {
trainingPlan.recommendedSessions.push({
name: module,
format: "Live Webinar",
duration: "60 minutes",
audience: "All Users"
});
});
// Add role-specific training if company is larger
if (companySize === "51-200" || companySize === "201-1000" || companySize === "1000+") {
trainingPlan.recommendedSessions.push({
name: "Administrator Training",
format: "Live Workshop",
duration: "120 minutes",
audience: "System Administrators"
});
trainingPlan.recommendedSessions.push({
name: "Manager Dashboard Training",
format: "Live Webinar",
duration: "60 minutes",
audience: "Managers and Executives"
});
}
// Add training materials
trainingPlan.materials.push("User Guides");
trainingPlan.materials.push("Video Tutorials");
trainingPlan.materials.push("Quick Reference Cards");
// Add certification path for more complex implementations
if (productDetails.complexityScore > 3) {
trainingPlan.certificationPath = {
name: `${productDetails.name} Certification`,
modules: productDetails.trainingModules,
estimatedCompletion: "4 weeks"
};
}
return trainingPlan;
}
// Helper function to generate success criteria
function generateSuccessCriteria(goals, productDetails) {
const successCriteria = [];
// Add standard success criteria
successCriteria.push("System fully configured and operational");
successCriteria.push("All users have access and completed basic training");
successCriteria.push("Customer team can perform core functions independently");
// Add goal-specific success criteria
if (goals) {
const goalArray = goals.split(',').map(goal => goal.trim());
goalArray.forEach(goal => {
switch(goal.toLowerCase()) {
case "increase sales efficiency":
successCriteria.push("Sales process fully configured in system");
successCriteria.push("Sales team actively using system for deal management");
break;
case "improve customer service":
successCriteria.push("Support ticket workflow implemented");
successCriteria.push("Customer service team trained on ticket management");
break;
case "enhance marketing":
successCriteria.push("Marketing campaigns configured");
successCriteria.push("Lead scoring implemented and tested");
break;
case "data centralization":
successCriteria.push("All legacy data successfully migrated");
successCriteria.push("Reporting dashboards configured for key metrics");
break;
}
});
}
return successCriteria;
}
// Helper function to generate next steps
function generateNextSteps(firstMilestone) {
return [
`Complete account setup by ${firstMilestone.dueDate}`,
"Review welcome materials and documentation",
"Identify key stakeholders for kickoff meeting",
"Prepare questions for kickoff discussion"
];
}
// Helper function to generate internal next steps
function generateInternalNextSteps(firstMilestone, complexityLevel) {
const internalSteps = [
`Schedule welcome call by ${firstMilestone.dueDate}`,
"Prepare customer-specific onboarding materials",
"Configure initial account settings"
];
if (complexityLevel === "COMPLEX" || complexityLevel === "ENTERPRISE") {
internalSteps.push("Assemble specialized implementation team");
internalSteps.push("Prepare technical requirements document");
internalSteps.push("Schedule internal kickoff planning meeting");
}
return internalSteps;
}
// Execute the main function
generateOnboardingPath();
};
This serverless function creates a sophisticated onboarding path generator that analyzes customer attributes, product complexity, and business goals to create a personalized onboarding experience.
The output can be used to set up custom onboarding workflows, create personalized resources, and establish appropriate timelines and milestones.
Integrating with Customer Health Monitoring
To maximize the impact of your onboarding workflow, integrate it with ongoing customer health monitoring:
- After completing onboarding, enroll the customer in a health monitoring workflow:
- Set up regular check-in tasks for the customer success manager
- Monitor product usage metrics and trigger alerts for low-adoption
- Send periodic satisfaction surveys
- Create automated touchpoints at key milestones (30, 60, 90 days)
- Implement an early warning system for at-risk customers:
- Track key usage metrics during and after onboarding
- Set up alerts if adoption falls below expected thresholds
- Create automated re-engagement campaigns for inactive users
Measuring Success
To evaluate the effectiveness of your customer onboarding workflow, monitor these key metrics:
- Time to first value: How quickly customers achieve their first success milestone
- Onboarding completion rate: Percentage of customers who complete all onboarding steps
- Onboarding satisfaction: Customer feedback on the onboarding experience
- Early adoption metrics: Usage statistics during the first 30/60/90 days
- Time to full implementation: Average days from purchase to complete implementation
- Early churn rate: Percentage of customers who cancel during or shortly after onboarding
Real-World Impact
A well-implemented customer onboarding workflow delivers significant business benefits. One of our SaaS clients achieved:
- 64% reduction in time-to-value (from 45 days to 16 days)
- 78% increase in feature adoption during the first 90 days
- 42% reduction in support tickets during the implementation phase
- 35% improvement in customer satisfaction scores
- 28% decrease in early-stage churn
The key to their success was creating a personalized onboarding experience based on customer size, complexity, and goals while maintaining consistent quality through automation.
Best Practices for Customer Onboarding
- Start pre-sale: Begin the onboarding process before the deal closes with proper expectation-setting.
- Personalize the experience: Tailor the onboarding path based on customer attributes and needs.
- Set clear milestones: Establish and communicate specific success milestones.
- Provide self-service options: Create resources for customers who prefer to learn independently.
- Celebrate successes: Acknowledge and celebrate when customers achieve key milestones.
- Gather continuous feedback: Regularly solicit input to improve the onboarding process.
- Smooth the handoff: Ensure a seamless transition from onboarding to ongoing customer success.
By implementing this customer onboarding workflow, you’ll create a consistent, scalable process that turns new customers into successful, loyal advocates for your business.
