These prompts help Customer Success teams write complete onboarding plans without starting from scratch. Copy any prompt, fill in the variables, and get a finished plan you can send to stakeholders or implement immediately.
These prompts pair well with Jasper AI for Customer Success-specific tone control, or Copy.ai for fast iteration.
New Enterprise Customer Onboarding Plans
You are a Customer Success Manager creating a 90-day onboarding plan for a new enterprise customer.
Customer: {company_name} Industry: {industry} Contract value: {annual_contract_value} Primary use case: {main_business_problem_being_solved} Key stakeholders: {decision_maker_name_and_title}, {technical_contact_name_and_title}, {end_user_champion_name_and_title} Implementation complexity: {low / medium / high} Success metrics: {primary_kpi}, {secondary_kpi} Previous tool they’re replacing: {competitor_or_manual_process} Go-live date: {target_date}
Write a detailed 90-day onboarding plan structured in 30-60-90 day phases. Include specific milestones, deliverables, and success criteria for each phase. Format as a plan you can send to the customer and internal team. 600 to 800 words.
When to use it: Right after contract signature when you need to align internal teams and set customer expectations before the kickoff call.
Pro tip: Always include buffer time in your dates. Enterprise implementations take 20% longer than planned, so build that cushion into your timeline upfront.
You are writing an onboarding plan for a mid-market customer who needs rapid deployment.
Customer: {company_name} Employees: {company_size} Requested go-live: {timeline_in_weeks} Champion: {internal_champion_name_and_department} Technical requirements: {integration_needs} Training audience: {number_of_end_users} Business driver: {urgent_reason_for_fast_deployment} Resource constraints: {limited_time_or_people} Risk tolerance: {high / medium / low}
Create a fast-track onboarding plan that gets them to basic functionality in {timeline_in_weeks}. Focus on must-have features only. Include weekly checkpoints and risk mitigation. Structure as an action plan with clear owners and deadlines. 400 to 500 words.
When to use it: When a customer has an urgent business need and standard timelines won’t work.
Pro tip: Document what you’re cutting from the standard onboarding process. This prevents scope creep and sets clear expectations about post-go-live additions.
You are creating an onboarding plan for a customer replacing a failed implementation.
Customer: {company_name} Previous vendor: {failed_solution_name} What went wrong: {main_failure_points} Stakeholder confidence level: {low / cautious / optimistic} Key skeptic: {name_and_concerns} Success requirements: {must_prove_points} Timeline pressure: {deadline_constraints} Internal politics: {team_dynamics_or_departments_involved} Proof points needed: {early_wins_required}
Write an onboarding plan that rebuilds confidence through early wins. Include specific trust-building milestones and stakeholder check-ins. Address their previous failure points directly. Format as a recovery plan with clear proof points. 500 to 600 words.
When to use it: When onboarding a customer who had a bad experience with a competitor or previous vendor.
Pro tip: Schedule success celebrations at 30% and 60% completion. Customers coming from failed implementations need positive reinforcement more frequently than normal.
You are planning onboarding for a customer with complex compliance requirements.
Customer: {company_name} Industry regulations: {compliance_frameworks} Security requirements: {data_protection_needs} Approval process: {internal_sign_off_requirements} Compliance officer: {name_and_specific_concerns} Documentation needs: {audit_trail_requirements} Testing phases: {validation_steps_required} Risk assessment: {potential_compliance_issues} Go-live dependencies: {external_approvals_needed}
Create a compliance-first onboarding plan with built-in validation checkpoints. Include documentation deliverables and approval gates. Structure with parallel workstreams to avoid delays. 550 to 650 words.
When to use it: Onboarding customers in regulated industries like healthcare, finance, or government.
Pro tip: Get compliance sign-off on your onboarding approach before starting implementation. One compliance objection can derail weeks of progress.
You are writing an onboarding plan for a customer expanding from a pilot to full deployment.
Customer: {company_name} Pilot scope: {original_use_case_and_users} Pilot results: {success_metrics_achieved} Full deployment scope: {expanded_use_case} New user count: {additional_users_being_added} Lessons learned: {what_worked_and_what_didnt_in_pilot} Expansion timeline: {rollout_schedule} Change management: {organizational_readiness} Success metrics: {expanded_success_criteria}
Create an expansion onboarding plan that builds on pilot learnings. Include phased user rollout and change management elements. Address any pilot gaps while scaling what worked. Format as a rollout plan. 450 to 550 words.
When to use it: When a successful pilot is expanding to full organizational deployment.
Pro tip: Interview your pilot users before writing the expansion plan. They’ll tell you the real friction points that didn’t show up in your success metrics.
Technical Integration Onboarding
You are creating an onboarding plan focused on complex technical integration.
Customer: {company_name} Integration type: {api_crm_database_or_other} Technical contact: {developer_or_it_contact_name} Systems involved: {existing_tools_to_integrate} Data migration: {volume_and_complexity} Custom requirements: {specific_technical_needs} Development timeline: {technical_work_estimate} Testing approach: {qa_and_validation_process} Rollback plan: {contingency_if_integration_fails}
Write a technical onboarding plan with parallel workstreams for business setup and technical integration. Include testing milestones and fallback options. Structure with clear technical and business tracks. 500 to 600 words.
When to use it: When the customer’s success depends heavily on technical integration rather than just configuration.
Pro tip: Always plan a soft launch period where integration runs parallel to old systems. Never switch everything over on day one, no matter how confident your technical team feels.
You are planning onboarding for a customer requiring extensive data migration.
Customer: {company_name} Data volume: {amount_of_historical_data} Data sources: {current_systems_containing_data} Data quality: {known_cleanup_requirements} Migration complexity: {technical_challenges} Business continuity: {uptime_requirements} Validation process: {how_success_is_measured} Backup strategy: {data_protection_approach} Timeline constraints: {business_deadline_requirements}
Create a data migration onboarding plan with validation checkpoints and rollback procedures. Include business continuity measures and quality assurance steps. Format as a migration project plan. 550 to 650 words.
When to use it: When customers have years of historical data that must be preserved and migrated.
Pro tip: Run data validation reports at 25%, 50%, 75%, and 100% of migration completion. Catching data quality issues early saves weeks of cleanup work.
You are writing an onboarding plan for multi-location deployment.
Customer: {company_name} Locations: {number_and_geographic_spread} Pilot location: {initial_deployment_site} Rollout sequence: {order_of_additional_locations} Local requirements: {regional_differences_or_regulations} Change management: {location_specific_concerns} Support model: {how_ongoing_support_will_work} Success criteria: {metrics_for_each_location} Timeline: {overall_deployment_schedule}
Create a multi-location onboarding plan with staggered rollout and location-specific considerations. Include lessons-learned feedback loops between locations. Structure as a phased deployment plan. 600 to 700 words.
When to use it: Onboarding customers with multiple offices, stores, or geographic locations.
Pro tip: Build a two-week gap between each location rollout. Use that time to document lessons learned and adjust your playbook for the next location.
You are creating an onboarding plan for API-first customer implementation.
Customer: {company_name} Developer team size: {technical_resources_available} API use case: {what_theyre_building} Integration timeline: {development_schedule} Technical expertise: {team_skill_level} Documentation needs: {developer_resources_required} Testing approach: {sandbox_and_production_plan} Go-live dependencies: {what_needs_to_be_ready} Support model: {ongoing_technical_support_expectations}
Write a developer-focused onboarding plan with technical milestones and code review checkpoints. Include sandbox setup, testing phases, and production deployment. Format as a technical project plan. 450 to 550 words.
When to use it: When onboarding customers who will primarily use your platform through APIs rather than the standard interface.
Pro tip: Give developers sandbox access before the official kickoff call. They’ll start experimenting immediately, and you’ll have better technical discussions when you formally begin.
You are planning onboarding for a customer with strict uptime requirements.
Customer: {company_name} Uptime requirement: {acceptable_downtime_limits} Business impact: {cost_of_system_downtime} Current system: {what_theyre_replacing} Cutover approach: {parallel_vs_direct_migration} Testing requirements: {validation_before_go_live} Rollback criteria: {conditions_that_trigger_rollback} Support coverage: {required_support_hours} Success metrics: {performance_benchmarks}
Create a zero-downtime onboarding plan with parallel system operation and careful cutover procedures. Include extensive testing phases and clear rollback triggers. Format as a high-availability deployment plan. 550 to 650 words.
When to use it: Onboarding customers in mission-critical environments where system downtime has severe business consequences.
Pro tip: Practice the cutover procedure in your test environment first. Run through the exact sequence of steps with realistic data volumes before touching production systems.
Team Training and Adoption Plans
You are creating an onboarding plan focused on user adoption for a large team.
Customer: {company_name} User count: {total_number_of_end_users} User types: {different_roles_and_access_levels} Training preference: {in_person_virtual_or_self_paced} Change readiness: {team_enthusiasm_level} Previous tool: {what_users_are_familiar_with} Power users: {names_of_potential_champions} Training timeline: {when_training_must_be_complete} Success metrics: {adoption_goals}
Write a user adoption onboarding plan with role-based training tracks and champion development. Include practice exercises and competency validation. Structure as a training curriculum with clear learning objectives. 500 to 600 words.
When to use it: When user adoption is the primary success factor and technical setup is straightforward.
Pro tip: Identify and train your power users two weeks before general training begins. They become your unofficial support team during the broader rollout.
You are planning onboarding for a customer with remote and hybrid teams.
Customer: {company_name} Team distribution: {office_remote_and_hybrid_breakdown} Time zones: {geographic_spread} Training delivery: {virtual_session_requirements} Technology constraints: {video_conferencing_and_bandwidth_limits} Manager involvement: {leadership_participation_level} Collaboration needs: {how_distributed_teams_work_together} Support model: {ongoing_help_for_remote_users} Success tracking: {how_adoption_is_measured_remotely}
Create a distributed team onboarding plan with flexible training delivery and strong remote support elements. Include asynchronous learning options and virtual collaboration setup. 450 to 550 words.
When to use it: Onboarding customers whose teams are spread across locations and time zones.
Pro tip: Record all training sessions and create short recap videos for each major feature. Remote teams consume training content differently than office-based teams.
You are writing an onboarding plan for executive stakeholder engagement.
Customer: {company_name} Executive sponsor: {c_level_or_vp_name_and_title} Business objectives: {strategic_goals_for_this_implementation} Executive involvement: {how_hands_on_leadership_will_be} Reporting requirements: {what_executives_need_to_see} Success timeline: {when_executives_expect_results} Risk concerns: {what_keeps_executives_awake} Communication preference: {meeting_cadence_and_format} Success metrics: {executive_level_kpis}
Create an executive-focused onboarding plan with strategic milestone reporting and business impact tracking. Include executive briefings and decision points. Format as a business case with clear ROI timelines. 400 to 500 words.
When to use it: When C-level executives are personally invested in implementation success and need regular updates.
Pro tip: Lead with business metrics, not feature adoption, in executive communications. They care about revenue impact and efficiency gains, not training completion rates.
You are creating an onboarding plan for change-resistant users.
Customer: {company_name} Resistance source: {why_users_are_hesitant} Previous change failures: {past_implementations_that_failed} Skeptical groups: {departments_or_roles_most_resistant} Change champions: {people_who_support_the_change} Success requirements: {what_would_convince_skeptics} Timeline pressure: {urgency_vs_change_management_needs} Leadership support: {management_backing_level} Communication needs: {how_to_address_concerns}
Write a change management onboarding plan that addresses resistance through early wins and peer influence. Include skeptic conversion strategies and feedback loops. Structure as a change management campaign. 550 to 650 words.
When to use it: When user resistance is high due to past failed implementations or organizational change fatigue.
Pro tip: Identify one vocal skeptic and convert them early through personal attention and customized training. Nothing changes minds faster than peer advocacy from former doubters.
You are planning onboarding with gradual feature rollout.
Customer: {company_name} User complexity tolerance: {appetite_for_learning_new_features} Core features: {must_have_functionality_for_go_live} Advanced features: {capabilities_to_introduce_later} Rollout timeline: {spacing_between_feature_releases} Training capacity: {how_much_learning_users_can_handle} Success metrics: {adoption_goals_for_each_phase} Feature dependencies