Employee handbook to training module and onboarding video pipeline

Introduction

Your company has just updated the employee handbook. HR has sent it to the comms team, who need to turn it into a training module, which then needs to become an onboarding video for new starters. Right now, this happens through email chains, Slack messages, and manual copy-pasting. Someone rewrites the handbook content in a learning management system format. Someone else adapts it again for video scripts. By the time the third person gets involved, inconsistencies creep in. It takes weeks.

This is a solvable problem. You can build a pipeline that takes your handbook source document and automatically produces a polished training module and a professional onboarding video, with zero manual handoff between steps. Hour One handles video generation from scripts, QuillBot refines your copy, and an orchestration tool (Zapier, n8n, or Make) ties everything together.

The workflow runs end-to-end without you touching it. New handbook? Upload it once. The system transforms it into three assets: a learning module, a video script, and a finished onboarding video. This guide shows you exactly how to build it.

The Automated Workflow

Understanding the Data Flow

The pipeline works in five sequential steps:

1. You upload the handbook document (PDF or text).
2. The orchestration tool extracts the key content.
3. QuillBot rewrites it into training module language.
4. QuillBot produces a second version optimised for video narration.
5. Hour One generates a professional video from the script.

The orchestration tool acts as your conductor. It manages the timing, passes data between tools, stores outputs, and handles errors if something breaks.

Choosing Your Orchestration Tool

Zapier is the easiest entry point if you want a visual interface and minimal setup. It's cloud-hosted, so no infrastructure to maintain. The trade-off is that it's slower and more expensive for high-volume work.

n8n sits in the middle. You get more control, faster execution, and lower costs, but you need to host it yourself (or use their cloud option). The interface is visual and fairly intuitive.

Make (Integromat) is similar to Zapier but slightly cheaper and faster. The interface can feel less polished, though.

Claude Code is worth considering if you're comfortable with Python. You can write a single script that does everything, call APIs directly, and avoid vendor lock-in entirely.

For this guide, I'll show you the n8n approach, since it balances control, cost, and ease of use. The logic translates easily to Zapier or Make if you prefer those.

Setting Up n8n

You'll need n8n installed or access to their cloud version. The basic setup involves creating API connections to Hour One and QuillBot, then building the workflow.

Create a new workflow in n8n. Start with a trigger that watches for new files in your chosen location (Google Drive, Dropbox, or a webhook).

Step 1:

Document Ingestion

Your workflow begins with a file upload trigger. If you're using Google Drive, the trigger watches a specific folder for new PDFs.

Copy
Trigger: Google Drive - Watch for new files
Folder: /Employee Handbooks
File type: PDF or DOCX

For other storage options, use Dropbox, OneDrive, or a simple webhook that accepts file uploads via API.

The orchestration tool extracts text from the PDF. If your document is already text-based, you can skip this. If it's a scanned PDF or image-heavy, you'll need optical character recognition (OCR). n8n has built-in OCR nodes, or you can call the Google Vision API.

Copy
n8n node: "Read PDF"
Input: File from trigger
Output: Raw text content

At this point, you have the handbook text flowing through your workflow. The next step refines it.

Step 2:

Content Rewriting for Training Module

QuillBot's API accepts text and returns rewritten versions. You'll use it twice: once to create training module content, and once for video script content.

First, send the handbook text to QuillBot with instructions to create formal, structured training material. QuillBot's API endpoint is simple:

Copy
POST https://api.quillbot.com/batch

{
  "requests": [
    {
      "text": "{{ $node[\"Read PDF\"].data[\"text\"] }}",
      "mode": "formal",
      "intensity": "creative"
    }
  ]
}

You'll need a QuillBot API key. Sign up for their Business plan or API access to get one.

Configure the n8n HTTP Request node with these details:

Copy
Method: POST
URL: https://api.quillbot.com/batch
Headers:
  Authorization: Bearer {{ env.QUILLBOT_API_KEY }}
  Content-Type: application/json

Body:
{
  "requests": [
    {
      "text": "{{ $node[\"Read PDF\"].data[\"text\"] }}",
      "mode": "formal",
      "intensity": "creative"
    }
  ]
}

QuillBot returns the rewritten text. Store this as your training module content. You can save it directly to Google Docs, a Word document, or your LMS via API.

Copy
n8n node: "Google Docs - Create Document"
Title: Training Module - {{ $node[\"trigger\"].data[\"name\"] }}
Content: {{ $node[\"QuillBot Request 1\"].data[\"result\"][0][\"text\"] }}

This produces your first asset: a properly formatted training module. The content is now in formal, educational language, structured for learning.

Step 3:

Video Script Generation

Now you need to adapt the same content for video narration. Send it to QuillBot again, but this time with different instructions. Video scripts need shorter sentences, conversational tone, and explicit cues for visual elements.

Use another HTTP Request node:

Copy
POST https://api.quillbot.com/batch

{
  "requests": [
    {
      "text": "{{ $node[\"Read PDF\"].data[\"text\"] }}",
      "mode": "creative",
      "intensity": "moderate"
    }
  ]
}

The response comes back as conversational, script-friendly text. You might want to post-process it slightly. For instance, you could add formatting markers like [VISUAL: graphic of org chart] to indicate where Hour One should display visuals.

Add a Code node in n8n to insert these markers:

Copyconst scriptText = $node["QuillBot Request 2"].data["result"][0]["text"];
const sections = scriptText.split('\n\n');

const enhancedScript = sections.map((section, index) => {
  if (index % 3 === 0) {
    return `[VISUAL: Relevant workplace image]\n${section}`;
  }
  return section;
}).join('\n\n');

return {
  script: enhancedScript,
  generatedAt: new Date().toISOString()
};

This gives you a script that's ready for video production, with visual cues built in.

Step 4:

Video Generation with Hour One

Hour One is an AI video platform that generates professional videos from scripts. Their API accepts a script and configuration, then returns a video.

First, authenticate with Hour One:

Copy
Hour One API endpoint: https://api.hour.one/api/v1
Authentication: API key in header

Create the video request:

Copy
POST https://api.hour.one/api/v1/videos

{
  "script": "{{ $node[\"Code - Enhance Script\"].data[\"script\"] }}",
  "avatar": "emily_uk",
  "voice": "en_GB_native",
  "background": "corporate_blue",
  "language": "en",
  "quality": "hd"
}

Key parameters for professional onboarding videos:

• Avatar: Hour One offers several professional avatars. "emily_uk" is a good default for UK companies. You can also use "avatar_professional_diverse" for variety.

• Voice: Use "en_GB_native" for British English narration. Other options include "en_US_native", but the accent matters for internal content.

• Background: Corporate backgrounds look better than animated ones for formal training. "corporate_blue" or "corporate_minimal" work well.

• Quality: "hd" generates 1080p video. Use this for professional onboarding; "standard" is adequate for internal only.

The Hour One API is asynchronous. It returns a job ID immediately:

Copy
{
  "id": "video_job_12345",
  "status": "processing",
  "estimatedTime": 120
}

Your workflow needs to poll Hour One until the video is ready. Add a Wait node set to 2 minutes, then a polling loop:

Copy
n8n node: "Wait"
Time: 120 seconds

n8n node: "HTTP Request - Check Status"
Method: GET
URL: https://api.hour.one/api/v1/videos/{{ $node[\"Hour One - Create Video\"].data[\"id\"] }}

Headers:
  Authorization: Bearer {{ env.HOUR_ONE_API_KEY }}

Once the video is complete, Hour One returns a download URL:

Copy
{
  "id": "video_job_12345",
  "status": "completed",
  "videoUrl": "https://videos.hour.one/output/video_job_12345.mp4",
  "duration": 245
}

Download the video and store it. You can save it to Google Drive, Dropbox, your LMS, or a company video server:

Copy
n8n node: "HTTP Request - Download Video"
Method: GET
URL: {{ $node[\"Hour One - Check Status\"].data[\"videoUrl\"] }}
Authentication: none (public URL)

n8n node: "Google Drive - Upload File"
File content: {{ $node[\"Download Video\"].data[\"body\"] }}
Folder: /Onboarding Videos
Name: Onboarding Video - {{ $node[\"trigger\"].data[\"name\"] }}.mp4

At this point, you have three completed assets: a training module, a video script, and a finished onboarding video. All created automatically.

Step 5:

Completion Notification

Add a final notification so your team knows the pipeline has finished. Send an email or Slack message:

Copy
n8n node: "Slack - Send Message"
Channel: #onboarding
Message: ✓ New onboarding assets created from {{ $node[\"trigger\"].data[\"name\"] }}
  Training Module: [link to Google Doc]
  Video Script: [link to text file]
  Onboarding Video: [link to video file]

Or via email:

Copy
n8n node: "Send Email"
To: hr@company.com
Subject: Onboarding assets ready: {{ $node[\"trigger\"].data[\"name\"] }}
Body: Training module, video script, and onboarding video have been generated.
Attachments: Links to all three assets

The Manual Alternative

If you prefer more control over each step, you can use these tools individually:

1. Download your handbook from storage.
2. Paste it into QuillBot's web interface, rewrite for formal tone.
3. Paste it again, rewrite for conversational video script tone.
4. Copy the script into Hour One's web interface, configure the avatar and voice, generate the video.
5. Download the video and upload to your storage or LMS.

This takes roughly 30 minutes per handbook update. It's fine for occasional updates, but if you're iterating frequently or have multiple handbooks, the automated approach saves dozens of hours per year.

The main advantage of manual control is that you can intervene if the AI rewrites don't match your brand voice exactly. You can tweak the training module wording or edit the script before video generation. The trade-off is that you lose the hands-off automation.

Pro Tips

1. Handle API failures gracefully. Both QuillBot and Hour One occasionally experience rate limits or timeouts. In n8n, add Error Handlers to each API call. If QuillBot fails, retry after 60 seconds. If Hour One's polling times out after 10 minutes, send an alert rather than hanging indefinitely.

Copy
n8n node: "Error Handler"
Trigger on: QuillBot Request error
Action: Wait 60 seconds
Then: Retry QuillBot Request
Max retries: 3

2. Version your outputs. Store not just the final video, but also the processed script and training module text. If you need to regenerate the video with different settings later, you have the source material without re-processing the handbook.

3. Monitor costs carefully. QuillBot charges per API call, not per character, so large handbooks cost the same as small ones per request. Hour One's costs scale with video length and quality. A 5-minute video on their standard plan costs around £1.50. If you're generating videos frequently, this adds up. Use hourly batching if you have multiple handbooks to process.

4. Test with a sample handbook first. Before running this on your main employee handbook, test with a smaller document (e.g., a single policy or department guide). Verify that the training module tone is appropriate, the video script sounds natural, and the avatar choice fits your company brand.

5. Set explicit content guidelines for QuillBot. QuillBot works better when you're specific about desired output. Rather than just sending raw text, wrap it with instructions:

Copy
Rewrite the following employee handbook for an HR training module. 
Use formal tone, clear bullet points, and short paragraphs. 
Target audience: new employees with no company experience.

[handbook text here]

This produces better results than raw text alone.

Cost Breakdown

The costs scale with usage but remain reasonable for most companies. A handbook update that previously took 8 hours of staff time now costs £5–20 in tool charges and runs overnight.

Building this workflow takes roughly 2–3 hours upfront (more if you're new to n8n or APIs). After that, you save time on every handbook update, new policy document, or training material change. If your company updates employee materials even quarterly, the automation pays for itself quickly.