Content Format Decision Guide

Not every lesson should be a video. Not every concept needs a code-along. This guide helps you match the RIGHT format to the RIGHT content for maximum learning effectiveness and minimum production effort.

Format Options

Decision Matrix: When to Use Each Format

Use VIDEO (Screencast) When:

✓ You're showing how to USE a tool (IDE, terminal, browser, admin panel)

✓ The sequence of steps matters (order of operations)

✓ Students need to see the RESULT of actions in real-time

✓ You're debugging or troubleshooting (showing your thought process)

✓ The visual context adds information (UI layout, terminal output)

✗ SKIP video when: The concept is purely logical/theoretical (use text), or when the information will change frequently (video is expensive to update)

Production tips:

• Record at 1920×1080 minimum
• Use a mic (audio quality > video quality)
• Increase font size to 16-18pt in editor
• Record in short segments (3-7 min), not one long take
• Post-process: cut silence, add chapter markers

Use WRITTEN TUTORIAL When:

✓ The concept is dense and benefits from re-reading

✓ You're explaining WHY (theory, architecture, design decisions)

✓ The content includes reference tables, comparison matrices

✓ Students will need to search/scan for specific information later

✓ The content changes frequently (text is cheap to update)

✓ Code snippets need to be copy-pasteable

✗ SKIP text when: The value is in SEEING the process unfold (use video), or when the content is a step-by-step procedure best shown live

Writing tips:

• Lead with the key insight, not the background
• Use headers aggressively (every 100-200 words)
• Include runnable code blocks (not pseudocode)
• Link to related lessons for deeper exploration
• Add "TLDR" boxes for scanners

Use INTERACTIVE EXERCISE When:

✓ The skill requires practice to internalize (not just comprehension)

✓ There's a clear right/wrong answer (auto-gradeable)

✓ You want to verify students can DO the thing, not just understand it

✓ The exercise builds directly toward the module project

✗ SKIP interactive when: The concept is introductory (use text/video first), or when there's no single correct approach (use project instead)

Exercise design tips:

• Start easy, increase difficulty within the exercise
• Provide starter code (reduce boilerplate friction)
• Include clear success criteria ("Your output should look like...")
• Offer hints (progressive disclosure, not immediate)
• Time-box exercises (always state expected time)

Use CODE-ALONG When:

✓ Students are building something from scratch

✓ The architecture/structure decisions are part of the lesson

✓ You want them to have a working project at the end

✓ The process involves multiple files/concepts coming together

✗ SKIP code-along when: The code is trivial and just illustrates a concept (use a snippet in text), or when the setup/boilerplate would take longer than the actual teaching

Code-along tips:

• Provide a "checkpoint" ZIP/repo at each major step
• Show the final result FIRST (so they know what they're building toward)
• Don't type boilerplate live — have it pre-written and explain it
• Commit frequently (if using Git) so they can diff against your solution

Use LIVE SESSIONS When:

✓ Students have accumulated questions that need personalized answers

✓ You're teaching problem-solving (your thought process IS the lesson)

✓ Community building and accountability are priorities

✓ The topic benefits from real-time discussion/debate

✗ SKIP live when: Content is factual and doesn't benefit from discussion, or when time zones make synchronous attendance impractical

Live session tips:

• Record EVERYTHING (for students who can't attend live)
• Have a structured agenda (don't just open for questions)
• Use polls/breakout rooms to maintain engagement
• Keep to 60-90 minutes max (attention drops after that)

Module-Level Format Mix

A well-designed module uses MULTIPLE formats. Here's a recommended pattern:

Lesson 1: WRITTEN TUTORIAL (introduce concept, theory, context)
    └── Quick Quiz (3 questions, verify comprehension)

Lesson 2: VIDEO SCREENCAST (show the concept in action)
    └── Follow-Along Exercise (replicate what was shown)

Lesson 3: CODE-ALONG (build something together)
    └── Downloadable Resource (cheat sheet of key patterns)

Lesson 4: INTERACTIVE EXERCISE (apply independently)
    └── Self-Check (automated tests or expected output)

Lesson 5: PROJECT (synthesize all lessons)
    └── Peer Review OR Instructor Feedback

Format Selection Cheat Sheet

Copy this for each lesson and check the most appropriate:

Lesson: [#.#] [Title]
Primary concept: [What are you teaching?]

This concept is best learned by:
[ ] Reading (it's abstract/theoretical/reference-heavy)
[ ] Watching (seeing it done reveals something text can't)
[ ] Doing (practice is essential; comprehension alone isn't enough)
[ ] Discussing (multiple perspectives/approaches exist)

The information:
[ ] Changes rarely (video is fine)
[ ] Changes often (text is better — cheaper to update)
[ ] Is procedural (step-by-step sequence matters)
[ ] Is conceptual (relationships between ideas matter)

Student needs to:
[ ] Understand WHY → Text/Video explanation
[ ] Know HOW → Video demonstration + exercise
[ ] Be able to DO → Interactive exercise or project
[ ] Remember WHAT → Quiz + downloadable reference

Production Effort vs Student Value Matrix

Plot each lesson on this grid to find the optimal format:

                HIGH PRODUCTION EFFORT
                        │
     Interactive        │        Video Course
     Platform           │        (Expensive to
     (expensive but     │         produce, high
      very sticky)      │         perceived value)
                        │
 ───────────────────────┼──────────────────────
                        │
     Downloadable       │        Written
     Resources          │        Tutorial
     (low effort,       │        (moderate effort,
      good supplement)  │         high reference
                        │         value)
                        │
                LOW PRODUCTION EFFORT

Strategy: Most of your content should be in the bottom-right (written + code) with strategic video for high-impact lessons. Don't make EVERYTHING a video — it's expensive and often unnecessary.

Accessibility Considerations

Every format should be accessible:

Minimum standard: Every video has captions. Every concept exists in at least TWO formats (e.g., video + written summary). No critical information is conveyed ONLY through color.

Course Platform Comparison Guide

Choosing the wrong platform costs you months of migration pain. This guide compares 12 major course platforms across the dimensions that actually matter for technical content creators.

Last updated: 2025

Decision Framework (Start Here)

Answer these 4 questions to narrow your shortlist to 2-3 platforms:

1. What's your course format?

2. What's your audience size?

3. What's your technical comfort?

4. What's your budget?

Platform Deep Dives

1. Teachable

Revenue calculation example:

• Course price: $199
• 100 students/month on Basic plan ($59/mo + 5% fee)
• Revenue: $19,900 - $995 (5% fee) - $59 (plan) = $18,846/mo net
• At Pro ($159/mo, 0% fee): $19,900 - $159 = $19,741/mo net
• Break-even for Pro vs Basic: 32 sales/month

2. Thinkific

3. Kajabi

4. Podia

5. Gumroad

Fee warning: At $10,000/mo revenue, Gumroad takes $1,000. That pays for any other platform multiple times over.

6. Self-Hosted (Your Own Platform)

Common self-hosted stacks:

• Next.js + Stripe + Supabase (auth/DB) + Mux (video) + Resend (email)
• Astro + Lemon Squeezy + Cloudflare R2 (video storage)
• WordPress + LearnDash + WooCommerce (if you must)

7. Skool

8-12: Quick Comparison (Niche Platforms)

Feature Comparison Matrix

Migration Considerations

Switching platforms is painful. Choose wisely upfront, but know your escape routes:

Golden rule: Always keep a local copy of ALL your content (videos, text, downloads) outside the platform. Never let a platform be the only place your content lives.

My Recommendation (Decision Tree)

START HERE: What's your priority?
│
├─ "Just launch fast, figure out later"
│   → Podia (Mover plan) or Gumroad
│
├─ "Best course experience for students"
│   → Thinkific (Pro) or Teachable (Pro)
│
├─ "I want ONE tool for everything"
│   → Kajabi (but budget $150-200/mo)
│
├─ "Community IS the course"
│   → Skool or Circle + simple LMS
│
├─ "Maximum control, I can code"
│   → Self-hosted (Next.js + Stripe + Mux)
│
└─ "I'm teaching live cohorts"
    → Maven or Circle + Teachable