Employee handbook to training module and onboarding video pipeline

Your HR team has spent three weeks writing a comprehensive employee handbook. It's thorough, well-researched, and sits in a Google Doc gathering dust. Meanwhile, new starters are onboarding without proper training materials, and you're manually converting PDFs into training modules and then asking someone to film a video version. This process takes days and involves multiple people, multiple tools, and multiple opportunities for information to get lost or become inconsistent....

The reality is that your handbook already contains everything needed for training. You just need to connect the dots between three discrete tasks: taking the handbook text, rewriting it for training purposes, and then generating a video. Each tool does one thing well, but none of them talk to each other without manual handoff.

This is where automation becomes practical. Instead of a five-person relay race, you can build a single pipeline that triggers when your handbook gets updated, runs through three tools in sequence, and outputs both a polished training module and a professional onboarding video, all with zero manual intervention between steps.

The Automated Workflow

Which orchestration tool to use

For this workflow, I'd recommend n8n over the alternatives. Zapier would work but feels like overkill for a three-step process, and its pricing scales quickly with multi-step workflows. Make (Integromat) is capable but n8n gives you more flexibility with custom scripts and better error handling. Claude Code is better suited for prototyping than production workflows.

n8n runs on your own infrastructure (or their cloud), handles retries natively, logs everything, and costs nothing at scale once deployed. You'll set up a workflow that monitors your handbook source, feeds it through QuillBot for tone adjustment, then passes the output to Hour One for video generation.

Understanding the data flow

Here's what happens at each stage:

1. Trigger: A new version of your handbook appears (via webhook, scheduled check, or manual trigger).

2. Transform: QuillBot rewrites the handbook text into training language, converting formal HR speak into something engaging and conversational.

3. Generate: Hour One takes the rewritten text and generates a video with a virtual presenter, B-roll, and professional polish.

4. Store: The final video and training module are saved to your learning management system or cloud storage.

The key insight is that each tool's output becomes the next tool's input. QuillBot's rewritten text isn't just useful for humans; it's optimised for Hour One's video generation engine.

Setting up the n8n workflow

Start by creating a new workflow in n8n. You'll need the following nodes in sequence: a trigger, a QuillBot integration, an Hour One integration, and a storage node.

Copy
[Trigger] → [QuillBot Node] → [Hour One Node] → [Google Drive/S3] → [Complete]

For the trigger, you have options. If your handbook lives in Google Docs, use n8n's Google Drive trigger set to watch for file changes. If it's in Notion or Confluence, use the appropriate trigger. The simplest option is a webhook trigger that your HR team hits manually when the handbook is ready.

Here's the webhook trigger configuration:

Copy{
  "method": "POST",
  "path": "handbook-to-video",
  "authentication": "basic-auth",
  "body": {
    "handbook_text": "string",
    "handbook_title": "string",
    "tone": "professional"
  }
}

When HR posts to this endpoint with the handbook content, the workflow starts.

Integrating QuillBot via API

QuillBot doesn't have an official n8n integration, but its API is straightforward. You'll use a standard HTTP Request node to call their API.

First, get your QuillBot API key from their developer dashboard. In n8n, add an HTTP Request node with these settings:

Copy
Method: POST
URL: https://api.quillbot.com/data/textSummarization
Headers:
  - Authorization: Bearer YOUR_QUILLBOT_API_KEY
  - Content-Type: application/json
Body:
{
  "text": "{{ $node.Webhook.json.handbook_text }}",
  "language": "en",
  "type": "paraphrase",
  "intentToMaintain": "true"
}

The key part is {{ $node.Webhook.json.handbook_text }}. This pulls the handbook text from your webhook trigger. QuillBot will rewrite it into more engaging language suitable for training.

QuillBot's API returns the rewritten text in the text field. Store this in a variable:

Copy{
  "quillbot_output": "{{ $node.QuillBotRequest.json.text }}"
}

You can also request a summary before the paraphrase if you want shorter training modules. Just add another HTTP Request node that calls QuillBot's summarisation endpoint first.

Feeding into Hour One for video generation

Hour One has native API support. In n8n, you can use their pre-built integration or call their API directly. Their API is cleaner, so here's the direct approach.

Add another HTTP Request node:

Copy
Method: POST
URL: https://api.hourone.ai/videos
Headers:
  - Authorization: Bearer YOUR_HOURONE_API_KEY
  - Content-Type: application/json
Body:
{
  "title": "{{ $node.Webhook.json.handbook_title }} - Training Module",
  "script": "{{ $node.QuillBotRequest.json.text }}",
  "avatar": "DEFAULT_AVATAR_ID",
  "voice": {
    "language": "en",
    "accent": "en-GB"
  },
  "video_quality": "1080p",
  "presentation_style": "professional"
}

Hour One will queue the video generation and return a job ID and status URL. Store both:

Copy{
  "video_job_id": "{{ $node.HourOneRequest.json.id }}",
  "video_status_url": "{{ $node.HourOneRequest.json.status_url }}"
}

Hour One videos typically take 5 to 15 minutes to generate. You have two options here: wait synchronously (block the workflow until the video is ready) or trigger an asynchronous check. For most use cases, asynchronous is better because it prevents n8n from holding resources.

Add a Wait node set to 2 minutes, then add a polling loop that checks the status URL every 30 seconds until the video is ready:

Copy
[Wait 2 minutes] → [Check Status] → [If Ready?] → [Yes: Get Video URL] / [No: Wait 30s and check again]

This is handled by n8n's IF node. Point it at the status endpoint:

Copy
Method: GET
URL: {{ $node.HourOneRequest.json.status_url }}

When the status returns "completed", extract the video URL from the response.

Storing the output

Once Hour One finishes, you have a video URL and the rewritten training text. Save both somewhere useful.

For Google Drive, use n8n's Google Drive node to upload both files:

Copy{
  "fileName": "{{ $node.Webhook.json.handbook_title }} - Training Video.mp4",
  "fileData": "{{ $node.HourOneRequest.json.video_url }}",
  "parentFolderId": "YOUR_TRAINING_FOLDER_ID"
}

For the training module text, save it as a document:

Copy{
  "fileName": "{{ $node.Webhook.json.handbook_title }} - Training Module.docx",
  "fileContent": "{{ $node.QuillBotRequest.json.text }}",
  "parentFolderId": "YOUR_TRAINING_FOLDER_ID"
}

If you use an LMS like Moodle, Blackboard, or Canvas, adapt these nodes to hit their course upload APIs instead.

Error handling and retries

n8n automatically retries failed HTTP requests up to three times. For a production workflow, add explicit error handling to avoid silent failures.

After your Hour One request, add an IF node that checks for errors:

Copy
{{ $node.HourOneRequest.json.error }} !== null

If true, send a notification to your HR team via Slack or email:

Copy{
  "message": "Video generation failed for {{ $node.Webhook.json.handbook_title }}. Error: {{ $node.HourOneRequest.json.error }}. Job ID: {{ $node.HourOneRequest.json.id }}"
}

For the polling loop, set a maximum iteration count (e.g., 60 checks over 30 minutes) to avoid infinite loops if Hour One's API breaks.

The Manual Alternative

If you want human oversight at any point, split the workflow into stages.

Stage 1: Have the webhook trigger only QuillBot and store the output for review. Your HR team manually approves the rewritten text before proceeding.

Stage 2: When approved, manually trigger Stage 2 of the workflow, which feeds the approved text into Hour One.

This adds friction but gives you quality control. You might catch tone issues, missing information, or technical errors before they reach your new starters. The trade-off is that it takes longer and requires someone to babysit the process.

Alternatively, add a Slack approval step using n8n's notification node. After QuillBot finishes, send a message with the rewritten text and two buttons: Approve or Reject. Only proceed to Hour One if Approve is clicked.

Pro Tips

1. Test QuillBot's output with Hour One first

QuillBot's paraphrase engine is good, but it occasionally rewrites ambiguous phrases in unexpected ways. Before running the full workflow on your actual handbook, do a test run with a sample chapter. Check that the rewritten text still makes sense and that Hour One's video generation handles it without errors. Hour One struggles with very short sentences and unusual punctuation, so if QuillBot introduces those, add a cleanup step.

2. Use QuillBot's tone controls

QuillBot has a "tone" parameter. Set it to "formal" or "formal-training" rather than neutral paraphrase. This nudges the output closer to training language from the start, reducing Hour One's interpretation overhead. Your final videos will be more consistent in voice.

3. Monitor API rate limits

QuillBot's free tier is limited to 125 requests per month. Their paid tiers go up to 500 per month, then unlimited. Hour One charges per video generated, not per API call. If you're generating more than four handbooks a month, you'll hit QuillBot's limits on the free tier. Budget for at least their $10/month plan, which gives 500 requests.

4. Cache QuillBot output for revisions

If your handbook gets updated, you'll regenerate the video. To avoid re-processing through QuillBot, store its output in n8n's built-in cache or in a database. If the handbook text hasn't changed significantly, skip QuillBot and jump straight to Hour One. This saves API calls and time.

5. Set realistic expectations for Hour One's avatars

Hour One's stock avatars are professional and diverse, but they're AI-generated. Some teams prefer a real person on camera. If that's important to you, use Hour One's "custom presenter" option to upload a video of your actual HR lead or CEO. Hour One will composite their face onto different backgrounds and gestures. This costs more but feels more authentic.

Cost Breakdown

This is dramatically cheaper than hiring a video producer or training specialist to do the work manually. A single contractor would charge £800–£2000 for this service; automated, you're looking at a tenth of that.......