Employee onboarding documentation and training video creation

Introduction

Creating employee onboarding documentation and training videos is one of those tasks that eats time disproportionate to its actual complexity. You write the same explanations repeatedly, record similar videos for different departments, and manually upload everything to your training platform. Meanwhile, new hires sit waiting for materials that should have been ready before their first day.

The real problem isn't that the work is hard; it's that it involves jumping between five different tools and babysitting each handoff. You export from one platform, import into another, fix formatting issues, wait for processing, then repeat. By the time you've onboarded ten employees, you've spent eight hours on administrative nonsense instead of actual content creation.

This workflow solves that. We're combining ChatGPT Writer for generating role-specific documentation, Hour One for creating talking-head training videos from that text, and Mintlify for turning technical docs into a searchable knowledge base. An orchestration tool ties it all together and runs the entire sequence without you touching anything in between.

The Automated Workflow

We'll use n8n as the orchestration layer for this example, though Zapier and Make would work equally well. N8n is particularly good here because it lets you build conditional logic and you're not paying per task run, which matters when you're generating multiple documents and videos.

How the Data Flows

The workflow runs in this sequence:

1. A new employee entry appears in your HR system (we'll use a webhook trigger).
2. N8n extracts their role, department, and seniority level.
3. ChatGPT Writer generates role-specific onboarding documentation.
4. That documentation is sent to Hour One to create a personalized training video.
5. The video and documentation are uploaded to Mintlify to create a knowledge base entry.
6. Your HR system gets a confirmation that onboarding materials are ready.

Let's build it.

Step 1:

Trigger and Data Collection

Your HR system (Workday, BambooHR, ADP, or even a Google Form) sends a webhook to n8n when a new hire record is created. The webhook payload contains basic information about the new employee.

Copy{
  "employee_id": "EMP-2024-0847",
  "full_name": "Sarah Chen",
  "role": "Senior Software Engineer",
  "department": "Platform Engineering",
  "start_date": "2024-02-19",
  "manager": "James Mitchell",
  "experience_level": "senior"
}

In n8n, you'll add a Webhook node that listens for POST requests. Configure it to accept the JSON structure your HR system sends.

Step 2:

Generate Documentation with ChatGPT Writer

ChatGPT Writer integrates with n8n via the OpenAI API. We're asking it to generate role-specific onboarding documentation based on the employee's details.

Create an HTTP Request node configured as follows:

Copy
Method: POST
URL: https://api.openai.com/v1/chat/completions
Headers:
  Authorization: Bearer YOUR_OPENAI_API_KEY
  Content-Type: application/json

The request body:

Copy{
  "model": "gpt-4",
  "temperature": 0.7,
  "messages": [
    {
      "role": "system",
      "content": "You are a technical writer specialising in employee onboarding documentation. Create clear, step-by-step documentation tailored to the employee's role and experience level."
    },
    {
      "role": "user",
      "content": "Generate a 5-day onboarding plan for a new hire with these details:\n\nName: {{$node[\"Webhook\"].json[\"full_name\"]}}\nRole: {{$node[\"Webhook\"].json[\"role\"]}}\nDepartment: {{$node[\"Webhook\"].json[\"department\"]}}\nExperience Level: {{$node[\"Webhook\"].json[\"experience_level\"]}}\nManager: {{$node[\"Webhook\"].json[\"manager\"]}}\n\nInclude:\n1. Day-by-day breakdown\n2. Key systems to access\n3. People to meet\n4. Success metrics for the first month\n\nFormat as Markdown."
    }
  ]
}

Store the response in a variable. N8n will expose the documentation text as $node[\"HTTP Request\"].json[\"choices\"][0][\"message\"][\"content\"].

Step 3:

Create Training Video with Hour One

Hour One creates video avatars that read scripts aloud. We're feeding it the documentation we just generated.

First, you need to split the documentation into chunks suitable for video narration. A talking-head video works better with 200-300 words per segment rather than 2,000 words.

Add a Code node to break the documentation into chapters:

Copyconst documentation = $node["HTTP Request"].json.choices[0].message.content;
const paragraphs = documentation.split('\n\n');

let chapters = [];
let currentChapter = '';
let charCount = 0;

paragraphs.forEach(para => {
  if ((charCount + para.length) > 2000) {
    chapters.push(currentChapter);
    currentChapter = para;
    charCount = para.length;
  } else {
    currentChapter += '\n\n' + para;
    charCount += para.length;
  }
});

if (currentChapter.length > 0) {
  chapters.push(currentChapter);
}

return chapters;

Now add an HTTP Request node for Hour One's API. You'll need to authenticate with your Hour One account and create a video for each chapter. Hour One's endpoint looks like this:

Copy
Method: POST
URL: https://api.hourone.ai/v1/videos
Headers:
  Authorization: Bearer YOUR_HOUR_ONE_API_KEY
  Content-Type: application/json

Request body for each chapter:

Copy{
  "script": "{{$node[\"Code\"].json[0]}}",
  "avatar": "jonathan",
  "voice": {
    "language": "en-GB",
    "gender": "male"
  },
  "name": "{{$node[\"Webhook\"].json[\"role\"]}} - Onboarding Video Part 1",
  "settings": {
    "duration": "auto",
    "quality": "1080p"
  }
}

Since you have multiple chapters, use n8n's Loop functionality to iterate through each chapter and create a separate video. Store all video URLs in an array.

Hour One's API returns a video ID and a processing status. You'll need to poll the /videos/{id}/status endpoint to check when videos are ready. Use n8n's Wait node to pause execution until the status changes to "completed".

Copy
Method: GET
URL: https://api.hourone.ai/v1/videos/{{video_id}}/status
Headers:
  Authorization: Bearer YOUR_HOUR_ONE_API_KEY

Once all videos are processed, extract their download URLs.

Step 4:

Upload to Mintlify Knowledge Base

Mintlify is a documentation platform with an API for creating knowledge base entries. You're uploading both the documentation and links to the training videos.

Configure an HTTP Request node:

Copy
Method: POST
URL: https://api.mintlify.com/v1/pages
Headers:
  Authorization: Bearer YOUR_MINTLIFY_API_KEY
  Content-Type: application/json

Request body:

Copy{
  "title": "{{$node[\"Webhook\"].json[\"role\"]}} - Onboarding Guide",
  "slug": "onboarding-{{$node[\"Webhook\"].json[\"employee_id\"]}}",
  "description": "Personalized onboarding materials for {{$node[\"Webhook\"].json[\"full_name\"]}}",
  "content": "{{$node[\"HTTP Request\"].json[\"choices\"][0][\"message\"][\"content\"]}}",
  "metadata": {
    "employee_id": "{{$node[\"Webhook\"].json[\"employee_id\"]}}",
    "role": "{{$node[\"Webhook\"].json[\"role\"]}}",
    "department": "{{$node[\"Webhook\"].json[\"department\"]}}",
    "created_date": "{{new Date().toISOString()}}",
    "training_videos": [
      "{{$node[\"Hour One Part 1\"].json[\"video_url\"]}}",
      "{{$node[\"Hour One Part 2\"].json[\"video_url\"]}}"
    ]
  }
}

Mintlify returns a page ID and a public URL. Store this URL for the next step.

Step 5:

Confirm Completion in HR System

Finally, send a completion notification back to your HR system so recruiters know the materials are ready.

Add another HTTP Request node pointing to your HR system's API. For example, if you're using BambooHR:

Copy
Method: PUT
URL: https://api.bamboohr.com/api/gateway.php/{{YOUR_SUBDOMAIN}}/v1/employees/{{$node[\"Webhook\"].json[\"employee_id\"]}}
Headers:
  Authorization: Bearer YOUR_BAMBOOHR_API_KEY
  Content-Type: application/json

Request body:

Copy{
  "customFields": {
    "onboardingMaterialsReady": "yes",
    "trainingMaterialsURL": "{{$node[\"Mintlify Upload\"].json[\"page_url\"]}}",
    "generatedDate": "{{new Date().toISOString()}}"
  }
}

This closes the loop. Your recruiters can see in their HR system that materials are ready, and they have a link to share with the new hire.

Complete n8n Workflow Summary

Your workflow should look like this:

1. Webhook (trigger)
2. HTTP Request (ChatGPT API)
3. Code (split documentation into chapters)
4. Loop with HTTP Request inside (Hour One API)
5. Wait nodes (check video processing status)
6. HTTP Request (Mintlify upload)
7. HTTP Request (HR system update)

The total execution time is roughly 2-5 minutes per employee, depending on how many video chapters you generate and how long Hour One takes to process videos.

The Manual Alternative

If you prefer not to automate the entire chain, you can use these tools individually with minimal setup:

Documentation only: Use ChatGPT Writer directly in your browser or through their API. Copy the output to Mintlify manually. This takes about 15 minutes per employee.

Video only: Generate documentation manually, then upload it to Hour One's web interface and download the videos. Takes 20-30 minutes per employee depending on video length.

Partial automation: Use n8n to generate documentation and upload to Mintlify, but create Hour One videos manually through their UI. This reduces manual work by 40% without the complexity of video processing automation.

The manual approach is sensible if you onboard fewer than five people per month or if your roles vary dramatically. Automation becomes worthwhile when you have repeatable patterns and regular hiring.

Pro Tips

Error handling and retries: Hour One videos sometimes fail to process on the first attempt. Add error handling in n8n: if a video processing request fails, wait 30 seconds and retry up to three times before alerting you.

Rate limiting: OpenAI and Hour One both have rate limits. Space out your requests if you're onboarding multiple people simultaneously. N8n's Delay node can add pauses between iterations of your loop.

Video generation cost: Hour One charges per minute of generated video. A five-minute training video costs roughly £1.50. Generating multiple videos per employee adds up quickly. Consider creating one comprehensive video per role instead of multiple short ones.

Template variables in documentation: Ask ChatGPT to generate documentation with placeholder variables like {{MANAGER_NAME}} and {{START_DATE}}. After generation, use n8n to replace these with actual values from your HR system.

Reusing videos across cohorts: Once you've generated a training video for the "Senior Software Engineer" role, store the video URL and reuse it for all subsequent hires in that role. Only regenerate videos when role responsibilities change.

Cost Breakdown

The cost per employee is roughly £15-45 depending on how many videos you generate. Compare this to hiring a contractor to create onboarding materials, which typically costs £150-300 per person.