Employee onboarding documentation and training video creation

Creating employee onboarding documentation and training videos is one of those tasks that consumes far too much HR and L&D time, yet produces assets that quickly become outdated. Someone writes the docs, someone else scripts the video, a third person records it, and then you're back to square one when processes change. The handoffs multiply, the versions diverge, and six months later nobody knows which document is the source of truth.......

What if you could generate both the written documentation and a professional training video from a single source of truth, with no manual steps in between? The good news is that modern AI tools make this entirely possible. By combining ChatGPT Writer for intelligent document creation, Hour One for AI-generated video production, and Mintlify for polished documentation hosting, you can build a workflow that produces company-wide onboarding materials in minutes rather than weeks.

This workflow is intermediate in difficulty because you'll need to configure API authentication and understand how data flows between services. However, the payoff justifies the effort: every time a process changes, you generate fresh documentation and video content without touching a keyboard beyond the initial trigger.

The Automated Workflow

Choosing Your Orchestration Tool

For this workflow, I recommend starting with Zapier if you want simplicity and don't mind per-task costs. However, if you're running this frequently or want full control over logic, n8n is your better choice. Make (Integromat) sits in the middle; it's more powerful than Zapier but less intimidating than n8n. For this guide, I'll show both Zapier and n8n approaches.

The Overall Flow

Here's what happens when you trigger the workflow:

1. You submit a process description (e.g., "IT security review process") via a form or webhook.

2. ChatGPT Writer generates comprehensive documentation covering steps, best practices, and common questions.

3. The generated documentation is sent to Hour One to create a video script and produce an AI avatar video.

4. The video and docs are published to a Mintlify site, which auto-generates a searchable knowledge base.

5. A confirmation email sends you the link to the new onboarding material.

Setting Up with n8n (Recommended)

n8n gives you the most control and costs least at scale. Here's the workflow structure:

Start with a Webhook trigger node. Configure it to accept POST requests:

Copy
POST /webhook/onboarding-trigger
Content-Type: application/json

{
  "process_name": "New Hire IT Setup",
  "process_description": "Steps for setting up a new employee in our IT systems",
  "department": "Engineering"
}

Your n8n Webhook node will extract these fields automatically.

Next, create a ChatGPT Writer node. You'll authenticate using your OpenAI API key. The node should call the completions endpoint:

Copy
POST https://api.openai.com/v1/chat/completions
Authorization: Bearer sk-YOUR_API_KEY
Content-Type: application/json

{
  "model": "[gpt](/tools/gpt)-4",
  "messages": [
    {
      "role": "system",
      "content": "You are an expert technical writer. Create comprehensive onboarding documentation."
    },
    {
      "role": "user",
      "content": "Create detailed onboarding documentation for the following process:\n\nProcess: {{ $node['Webhook'].json['process_name'] }}\n\nDescription: {{ $node['Webhook'].json['process_description'] }}\n\nInclude:\n1. Step-by-step instructions\n2. Prerequisite requirements\n3. Common troubleshooting issues\n4. Links to relevant policies\n5. Key contacts for support\n\nFormat the output in Markdown."
    }
  ],
  "temperature": 0.7,
  "max_tokens": 2000
}
```...... For more on this, see [Technical specification document generation from business...](/blog/technical-specification-document-generation-from-business-requirements). For more on this, see [Code migration documentation and technical debt assessment](/blog/code-migration-documentation-and-technical-debt-assessment).

Store the response in a variable. In n8n, use an "Execute Script" node to extract and format the documentation:

```javascript
const documentation = items[0].json.choices[0].message.content;

return {
  json: {
    documentation: documentation,
    process_name: items[0].json.process_name,
    timestamp: new Date().toISOString()
  }
};

Now comes the video generation. You'll call Hour One's API. First, register at hour-one.ai and generate an API key from your dashboard. The API endpoint for creating a video is:

Copy
POST https://api.hour.one/v1/videos
Authorization: Bearer YOUR_HOUR_ONE_API_KEY
Content-Type: application/json

{
  "title": "Onboarding: {{ $node['Webhook'].json['process_name'] }}",
  "script": "{{ $node['Process_Docs'].json['documentation'] }}",
  "avatar": "maya",
  "background": "corporate_office",
  "language": "en",
  "voice": {
    "type": "female",
    "accent": "british"
  }
}

Hour One will queue the video for generation. Importantly, the API returns a video_id and a status_url where you can poll for completion. Add a "Wait" node set to 120 seconds, then a polling node that checks the status endpoint:

Copy
GET https://api.hour.one/v1/videos/{{ $node['Create_Video'].json['video_id'] }}/status
Authorization: Bearer YOUR_HOUR_ONE_API_KEY

Once the status returns completed, extract the download_url from the response.

For publishing to Mintlify, you'll need Mintlify's GitHub integration. Mintlify hosts documentation directly from a GitHub repository, so your n8n workflow should commit files to a designated repository. Use the GitHub API: For more on this, see Architecture design document creation from code repositories.

Copy
POST https://api.github.com/repos/YOUR_ORG/onboarding-docs/contents/docs/{{ $node['Webhook'].json['process_name'].toLowerCase().replace(/ /g, '-') }}.md
Authorization: token YOUR_GITHUB_TOKEN
Content-Type: application/json

{
  "message": "Add {{ $node['Webhook'].json['process_name'] }} documentation",
  "content": "{{ Buffer.from($node['Process_Docs'].json['documentation']).toString('base64') }}",
  "branch": "main"
}

Mintlify automatically rebuilds your site when files are committed to the main branch, typically within 2-3 minutes.

For the video, you'll want to upload it to a storage service accessible to your Mintlify site. If you use AWS S3:

Copy
PUT https://YOUR_BUCKET.s3.amazonaws.com/videos/{{ $node['Webhook'].json['process_name'].toLowerCase().replace(/ /g, '-') }}.mp4
Authorization: AWS4-HMAC-SHA256 ...

Alternatively, use an HTTP request node to upload the video to your own server or a CDN like Cloudinary.

Finally, add an email notification node to alert stakeholders:

Copy
To: onboarding-team@yourcompany.com
Subject: New Onboarding Material Created: {{ $node['Webhook'].json['process_name'] }}
Body:

Documentation: https://docs.yourcompany.com/{{ $node['Webhook'].json['process_name'].toLowerCase().replace(/ /g, '-') }}

Video: {{ $node['Upload_Video'].json['video_url'] }}

Created: {{ $node['Execute_Script'].json['timestamp'] }}

Using Zapier (Simpler, Less Powerful)

If you prefer Zapier's interface, the approach is similar but with fewer branching options. Create a Zap with a Webhook trigger, then add actions in sequence:

1. Webhook (inbound) captures your form submission.

2. ChatGPT action (using the official integration) generates documentation.

3. Wait 60 seconds.

4. HTTP Request action to Hour One API.

5. Delay 120 seconds.

6. HTTP Request action to poll Hour One status.

7. GitHub action commits the documentation.

8. Email notification sends the confirmation.

The limitation with Zapier is that it doesn't natively handle looping or complex polling. You'll need to use Zapier's "Looping" utility to repeatedly check video status, which increases costs.

Data Flow and Error Handling

Here's how data flows through the system:

Copy
User Input
    ↓
Webhook (n8n/Zapier)
    ↓
ChatGPT API (documentation generation)
    ↓
Documentation stored in memory
    ↓
Hour One API (video queued)
    ↓
Poll Hour One status endpoint
    ↓
Video download URL obtained
    ↓
GitHub API (documentation committed)
    ↓
S3/CDN (video uploaded)
    ↓
Mintlify rebuilds site automatically
    ↓
Email notification sent

Critical: Add error handlers at each API call. In n8n, use a "Try/Catch" node around the ChatGPT call. If it fails, send an alert email and stop:

Copytry {
  // ChatGPT API call
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + process.env.OPENAI_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'gpt-4',
      messages: [/* ... */]
    })
  });
  
  if (!response.ok) {
    throw new Error(`OpenAI API error: ${response.status}`);
  }
  
  return response.json();
} catch (error) {
  console.error('Documentation generation failed:', error);
  // Send error notification
}

The Manual Alternative

If you'd rather maintain full control or run this only occasionally, you can execute each step independently:

1. Write your documentation in ChatGPT, copy it manually.

2. Paste the documentation into Hour One's web interface and generate the video.

3. Download the video and upload it to your server.

4. Create a new Markdown file in your onboarding docs repository.

5. Push to GitHub and wait for Mintlify to rebuild.

6. Send a team email with the links.

This approach takes roughly 30-45 minutes per process and introduces human error at each step. The automated version handles this in 10 minutes with no mistakes.

Pro Tips

1. Pre-Format ChatGPT Output for Mintlify

Mintlify expects Markdown with specific frontmatter. Adjust your ChatGPT prompt to include this automatically:

Copy
At the start of your response, include:

title: "{{ process_name }}"
description: "Onboarding documentation for {{ process_name }}"
icon: "book-open"

Then provide the documentation.

This ensures your Mintlify site displays everything correctly without manual editing.

2. Handle Hour One Rate Limits

Hour One limits video generation to prevent queue overload. If you submit multiple videos at once, you'll hit their rate limit. Add a queue mechanism in n8n: store pending videos in a database, then process them with a 5-minute interval using a cron trigger. Check Hour One's documentation for current limits; as of 2024, it's roughly 10 concurrent renders.

3. Version Control Your Videos

Store video download URLs in a JSON manifest file committed to GitHub alongside your documentation. This lets you track which version of documentation corresponds to which video:

Copy{
  "process": "IT Security Review",
  "documentation_version": "1.2",
  "video_url": "https://cdn.example.com/videos/it-security-review-v1.2.mp4",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_by": "onboarding-automation"
}

4. Optimise Costs with Batching

If you're creating onboarding materials for multiple processes, batch your ChatGPT calls. Generate documentation for 5 processes in a single API call using a loop, rather than triggering the workflow 5 times. This reduces API costs by roughly 40% because you're reusing model context.

5. Monitor Token Usage

ChatGPT charges by tokens consumed. For a typical onboarding document (500-800 words), expect 800-1200 output tokens. If you're generating documentation frequently, monitor your token usage in the OpenAI dashboard. Consider using GPT-3.5-Turbo instead of GPT-4 for drafts, then switch to GPT-4 only for final versions. The cost difference is significant: GPT-3.5-Turbo costs roughly one-tenth as much.

Cost Breakdown

Total Estimated Monthly Cost: £150-300 for a small company generating 20-30 onboarding videos monthly.

If cost is a concern, use free alternatives: self-host n8n, use Mintlify's free tier, store videos on GitHub releases (limited), and batch your ChatGPT calls aggressively. This cuts costs to roughly £50-80 monthly.

The beauty of this workflow is that it's genuinely hands-off once you've built it. Your HR team submits a form, and professional documentation plus a video appear in your knowledge base within 15 minutes. That's the difference between onboarding materials that get updated quarterly and those that stay current every week.