Course curriculum and assessment generation from subject outline

Introduction

Creating a complete course curriculum from a subject outline is one of those tasks that devours time. You start with a list of topics, then you need to break them down into learning objectives, design assessments, create study materials, and structure everything into a coherent progression. Most educators do this manually, switching between documents and tools, copying and pasting content, and checking each step by hand. The result is inconsistent, slow, and error-prone.

What if you could feed a subject outline into a system and have it generate a full curriculum, complete with assessments and study decks, without touching a single file manually? This workflow does exactly that. It combines three specialist AI tools (AnkiDecks-AI for spaced repetition content, Hour One for video curriculum overview, and Resoomer-AI for content summarisation) and orchestrates them through a single trigger point. You submit your outline once, and the system handles everything in sequence.

This is an intermediate-difficulty automation because you'll need to configure API calls, map JSON payloads between tools, and handle conditional logic. But the payoff is significant: what takes a teacher six hours manually takes your workflow under five minutes.

The Automated Workflow

We'll use n8n as our orchestration platform, as it provides the best balance of visual workflow design and granular API control for this particular combination of tools. Make (Integromat) would work equally well, though the node configuration differs slightly. Zapier's free tier doesn't provide enough flexibility for the data transformation required here.

The Workflow Overview

Your automated process will follow this sequence:

1. Receive a subject outline (via webhook, form submission, or email)
2. Send the outline to Resoomer-AI to generate a condensed summary and key topics
3. Pass the summary to AnkiDecks-AI to create flashcard decks
4. Send the outline structure to Hour One to generate a video curriculum overview
5. Compile all outputs into a single structured document
6. Store results in Google Drive or your learning management system

The key is that each step feeds into the next. AnkiDecks-AI needs the summarised topics from Resoomer to create relevant cards. Hour One works better with a distilled structure. Everything converges into one final package.

Setting Up n8n

First, create a new workflow in n8n. You'll need to authenticate with each service. Install and configure these credentials:

• AnkiDecks-AI API key (from your dashboard)
• Hour One API key and workspace ID
• Resoomer-AI API key
• Google Drive (optional, for output storage)

Start with a Webhook node set to receive POST requests. This will be your trigger point. The webhook payload should include:

Copy{
  "subjectTitle": "Introduction to Photosynthesis",
  "outline": "1. Light reactions and photosystems\n2. Calvin cycle and carbon fixation\n3. Factors affecting photosynthetic rate\n4. Adaptations in C3 and C4 plants",
  "educationLevel": "secondary",
  "targetAudience": "biology students aged 14-16"
}

Step 1:

Summarise with Resoomer-AI

Add an HTTP Request node after the webhook. Configure it as follows:

Copy
Method: POST
URL: https://api.resoomer.com/v1/summarize
Headers:
  Authorization: Bearer YOUR_RESOOMER_API_KEY
  Content-Type: application/json
Body (raw):
{
  "text": "{{ $json.outline }}",
  "language": "en",
  "summaryLength": 40
}

Resoomer returns a summary object with a summary field and extracted keywords. Store these in n8n variables for the next steps.

Add a Set node to extract and restructure the response:

Copy{
  "summaryText": "{{ $node['HTTP Request'].json.summary }}",
  "extractedTopics": "{{ $node['HTTP Request'].json.keywords }}",
  "originalOutline": "{{ $json.outline }}",
  "subjectTitle": "{{ $json.subjectTitle }}"
}

Step 2:

Generate Flashcard Decks with AnkiDecks-AI

Add another HTTP Request node:

Copy
Method: POST
URL: https://api.ankidecks.ai/v2/decks/create
Headers:
  Authorization: Bearer YOUR_ANKIDECKS_API_KEY
  Content-Type: application/json
Body (raw):
{
  "deckName": "{{ $json.subjectTitle }} - Study Cards",
  "description": "Auto-generated study deck from curriculum outline",
  "topic": "{{ $json.subjectTitle }}",
  "difficultyLevel": "{{ $json.educationLevel }}",
  "numberOfCards": 30,
  "includeImages": true,
  "cardFormat": "question_answer"
}

AnkiDecks-AI returns a deckId and a set of card data. Capture this response in another Set node:

Copy{
  "ankiDeckId": "{{ $node['AnkiDecks Request'].json.deckId }}",
  "ankiCards": "{{ $node['AnkiDecks Request'].json.cards }}",
  "ankiDownloadUrl": "{{ $node['AnkiDecks Request'].json.downloadUrl }}"
}

If you want to generate cards for specific topics, add a Code node (JavaScript) to iterate through extracted topics:

Copyconst topics = $input.all()[0].json.extractedTopics;
const cardRequests = topics.map(topic => ({
  topic: topic,
  numberOfCards: 5,
  focusArea: topic
}));

return {
  "cardBatches": cardRequests
};

Then use a Loop node to send each topic batch to AnkiDecks-AI separately, collecting all deck URLs.

Step 3:

Generate Curriculum Overview with Hour One

Add an HTTP Request node for Hour One:

Copy
Method: POST
URL: https://api.hourone.com/v1/videos/generate
Headers:
  Authorization: Bearer YOUR_HOUR_ONE_API_KEY
  Content-Type: application/json
Body (raw):
{
  "scriptType": "curriculum",
  "subject": "{{ $json.subjectTitle }}",
  "topics": "{{ $json.extractedTopics.join(', ') }}",
  "length": 300,
  "presenter": "professional",
  "tone": "educational",
  "language": "en-GB"
}

Hour One processes asynchronously. The response includes a videoId and status. You'll need to poll for completion. Add a Wait node (5 seconds), then an HTTP Request node to check status:

Copy
Method: GET
URL: https://api.hourone.com/v1/videos/{{ $node['Hour One Generate'].json.videoId }}/status
Headers:
  Authorization: Bearer YOUR_HOUR_ONE_API_KEY

Add a Conditional node: if status is "completed", proceed; if "processing", loop back to the wait and check again (using a maximum of 10 attempts to avoid infinite loops).

Once complete, extract the video URL:

Copy{
  "videoUrl": "{{ $node['Hour One Status'].json.downloadUrl }}",
  "videoDuration": "{{ $node['Hour One Status'].json.duration }}",
  "videoId": "{{ $node['Hour One Generate'].json.videoId }}"
}

Step 4:

Compile Everything into a Structured Document

Add a Code node to assemble all outputs into a single, well-formatted curriculum document:

Copyconst compilation = {
  subject: $input.all()[0].json.subjectTitle,
  generatedAt: new Date().toISOString(),
  sections: {
    overview: {
      originalOutline: $input.all()[0].json.originalOutline,
      summary: $input.all()[0].json.summaryText,
      keyTopics: $input.all()[0].json.extractedTopics
    },
    curriculum: {
      videoOverview: {
        url: $input.all()[0].json.videoUrl,
        duration: $input.all()[0].json.videoDuration
      }
    },
    assessment: {
      studyDecks: {
        primaryDeck: {
          id: $input.all()[0].json.ankiDeckId,
          downloadUrl: $input.all()[0].json.ankiDownloadUrl,
          cardCount: 30
        }
      }
    }
  }
};

return {
  "curriculumPackage": compilation,
  "packageJson": JSON.stringify(compilation, null, 2)
};

Step 5:

Store Output

Add a Google Drive node (or your preferred storage service) to save the compiled package:

Copy
Action: Create a file
Parent Folder ID: YOUR_CURRICULUM_FOLDER_ID
File Name: {{ $json.subjectTitle }} - Curriculum Package - {{ now.format('YYYY-MM-DD') }}
File Content: {{ $json.packageJson }}

Optionally, add a Gmail node to email a summary to stakeholders:

Copy
To: {{ $json.notificationEmail }}
Subject: Curriculum generated: {{ $json.subjectTitle }}
Body:
Curriculum package for {{ $json.subjectTitle }} has been generated.

Study deck: {{ $json.ankiDownloadUrl }}
Video overview: {{ $json.videoUrl }}
Complete package stored at: {{ $node['Google Drive'].json.webViewLink }}

Deploy your workflow and test it with a sample subject outline through the webhook.

The Manual Alternative

If you prefer more control over each step, or if you're testing the process for the first time, you can work through this sequentially by hand:

1. Copy your subject outline into Resoomer-AI's web interface. Review the summary and keywords manually before proceeding.
2. Use the refined topics to craft a prompt for AnkiDecks-AI. You can specify card difficulty, focus areas, and even provide example cards you want included.
3. Write a curriculum script manually or paste your summarised outline into Hour One's script editor. Preview the generated video and request revisions if needed.
4. Download all assets (Anki deck, video file, summary) and organise them in a folder structure.
5. Create a master document (PDF, Google Doc, or LMS page) that links to or embeds everything.

This approach takes longer but gives you checkpoints to validate quality at each stage. Use it the first time you run this workflow, or whenever the subject matter is particularly sensitive or complex.

Pro Tips

Handle rate limits gracefully. Resoomer and AnkiDecks-AI enforce rate limits (typically 100 requests per hour for free tiers). Add a Rate Limit node in n8n set to maximum 50 requests per hour. If you need to process multiple outlines, schedule workflow runs rather than triggering them all at once.

Validate outline structure before processing. Add a Conditional node right after the webhook that checks if the outline contains at least 3 topics and is more than 100 characters long. Reject malformed inputs with an error response rather than wasting API calls on bad data.

Cache Resoomer summaries to reduce costs. If you're generating curricula for similar subjects, save the Resoomer output and reuse it rather than re-summarising. Store summaries in n8n's data store, keyed by a hash of the input outline text.

Implement error handling on the Hour One polling loop. Hour One sometimes takes longer than expected. Instead of a hard timeout, implement exponential backoff: wait 5 seconds on the first check, 10 on the second, 20 on the third, up to a maximum of 60 seconds. This reduces unnecessary API calls while handling slow processing gracefully.

Download and store video files immediately. Hour One's video URLs are temporary. Add a Download node that saves the video to Google Drive or your server within 10 minutes of generation, otherwise the link expires and you'll need to regenerate.

Test with small outlines first. Before running the full workflow on a complex curriculum, test with a 2-3 topic outline to identify configuration issues and see actual output quality. AnkiDecks-AI and Hour One produce different results based on input detail and wording.

Cost Breakdown

If you run fewer than 5 workflows per month, consider AnkiDecks-AI's free tier (20 decks) and Resoomer's free tier (5 summarisations), bringing monthly cost down to roughly £10-15. Hour One is the largest expense; if budget is tight, you could skip the video generation and rely on the study decks and summary alone.