How to Turn Notion or Obsidian Notes into a Course

To turn Notion or Obsidian notes into a course, export the pages as Markdown (or PDF) and attach them in an AI course builder like Ailurn. The planner reads your notes, groups scattered pages into modules, and puts the topics you flagged as confusing first. You then study those modules with quizzes and flashcards instead of re-reading your own highlights. The product page for this workflow is PDF to course, and it covers notes as well as PDFs.

Ailurn accepts .md, .txt, .docx, .pdf, and images while you plan. Attaching files starts on Pro (three files per course). Plus has no file limit.

The Problem with Studying from Your Own Notes

Personal notes are the most relevant study material you own. They cover exactly what you read, in your words, with your questions in the margins. They are also the least usable.

Three things break when you try to learn from a notes workspace:

1. Notes are a pile, not a path. Notion databases and Obsidian vaults grow by capture date. The page on ownership sits next to a page of book highlights and a half-finished project log. Links help you find things. They do not tell you what to learn first.
2. Re-reading your own words feels like knowing. You wrote it, so it reads as familiar. Familiar is not the same as being able to use it. Nobody quizzes you on your own Notion page.
3. The good parts are buried. The most valuable page in most workspaces is the one titled "things that confused me" or "questions." It rarely gets reopened.

Turning notes into a course keeps your material and your priorities, and adds the order and practice your workspace never had.

If your notes are already one clean PDF (lecture notes, a typed chapter summary), the PDF to course workflow covers it. This guide is for the messy, multi-page kind.

Step-by-Step: How to Turn a Notes Workspace into a Course

+---------------------------+
| Notion / Obsidian / Docs  |
| (one topic, many pages)   |
+-------------+-------------+
              |
              v
+---------------------------+
| Export                    |
| - Markdown or PDF         |
| - Merge into 1-3 files    |
|   on Pro                  |
+-------------+-------------+
              |
              v
+---------------------------+
| Ailurn planning chat      |
| - Name the outcome        |
| - Point at your gaps      |
| - Attach the files        |
+-------------+-------------+
              |
              v
+---------------------------+
| Structured course         |
| - Modules from your pages |
| - Gaps first              |
| - Ask, quiz, flashcards   |
+---------------------------+

1. Scope to One Topic

Do not export your whole second brain. Pick the pages behind one thing you are trying to learn:

• A self-study topic: "Learning Rust," "Statistics refresher," "Spanish subjunctive."
• A book you took notes on: chapter highlights plus your own reactions.
• A work area: the notes you took in your first month on a new team.

Ten to forty pages on one topic is a good size.

2. Export the Pages

Notion: open the parent page, choose Export from the page menu, pick Markdown & CSV, and include subpages. Notion gives you a ZIP. Unzip it; Ailurn accepts the .md files, not the ZIP. PDF export also works if you prefer one file.

Obsidian: your vault is already Markdown. Copy the notes for the topic out of the vault folder. Wiki-links ([[Ownership]]) come through as plain text, which is fine.

Google Docs, Apple Notes, Word: export as .docx or PDF.

On Pro, three attachments per course means you should merge. Concatenate the pages into one to three Markdown files, keeping each page title as a heading:

# Ownership
(page text)

# Borrowing and lifetimes
(page text)

# Things that confused me
(page text)

Each file can be up to 12 MB, far more than a notes workspace needs. On Plus, attach the pages individually.

Ailurn can also read public web pages you paste in chat. Notion renders pages in the browser, though, so a shared Notion link often comes through thin. Export is the reliable path.

3. Tell Ailurn What the Notes Are For

Your notes have context the planner cannot guess. Say it before you attach:

• "These are my notes from reading the Rust book. I'm fine on syntax. Build the course around the 'confused me' page: ownership, lifetimes, and trait objects. I want to ship a CLI tool in a month."
• "Notes from my first three weeks on the payments team. Turn them into something I can review before on-call. Skip the meeting notes."

Then attach the files in planning chat. The planner reads your pages and drafts an outline: modules grouped by concept rather than by capture date, with your flagged gaps early. Revise it in chat ("move traits after lifetimes," "drop the book-review page") before lessons are written.

Sketch the module list yourself first with the module outline generator if you want to compare.

4. Study the Course, Not the Notes

Now the notes become lessons you can be tested on:

• Ask inside a lesson: "My note says 'borrow checker hates this.' Why, exactly?"
• Quizzes and flashcards are generated from each lesson, so review hits the concepts you wrote down, not a generic syllabus.
• Sandboxes open when the lesson has Python, JavaScript, SQL, or HTML, so you can run the snippet you pasted into Notion six weeks ago. Other languages, like the Rust example below, get written exercises instead of a runnable editor.
• STEM models appear when a lesson needs a labeled figure or a worked problem, which helps with math and science notes.

Flashcards on your own confusions are where spaced repetition earns its keep.

Practical Worked Example: A Messy "Learning Rust" Workspace

Take a typical Notion workspace: 23 pages built over two months. Nine pages of Rust book highlights, a page of compiler errors pasted verbatim, a "things that confused me" page, three project-idea pages, a reading list, and a page of links.

The reading list, the links page, and two abandoned project ideas drop out. The page you never reopened becomes Module 1.

What This Workflow Does Not Do

• No live sync. Ailurn does not connect to your Notion workspace or Obsidian vault. It reads the export you attach, once. New notes mean a new export.
• The outline is grounded in your notes; lessons fill the gaps. Ailurn reads your pages to decide what the course covers and in what order. It then writes each lesson to that outline, adding explanation your notes skipped. That is usually what you want, but check any claim that contradicts what you wrote down.
• Thin notes make thin courses. A page that just says "lifetimes???" tells the planner it matters, not what you already know. One sentence of context per flagged topic helps a lot.
• Embeds and databases lose detail. Embedded videos, synced blocks, and database views export as links or CSV. Paste the text you care about into a page before you export.
• Free cannot attach files. On Free, a planning message is capped at 2,000 characters. You can paste your "confused me" list as a topic list and get an outline and one lesson, but the planner will not see the rest of your notes.

Comparing Ways to Study Your Notes

Chat over your notes is great for lookup. It does not give you a path. If that split matters, see Ailurn vs NotebookLM.

Best Practices

1. One topic per course. Start a second course for the next topic instead of attaching everything.
2. Write the "confused me" page if you do not have one. Five bullet points of what you cannot yet explain is the highest-value input you can give the planner.
3. Delete before you merge. Meeting logistics, link dumps, and duplicate highlights cost attention and add nothing to the outline.
4. Answer the quiz without opening Notion. If you need your notes to answer, the lesson is not done.

Put Your Notes to Work

You already did the hard part: you read the material and wrote down what mattered. Export the pages, attach them on PDF to course, and turn the pile into a path. Or start for free and paste your list of open questions.

Notes from a lecture deck rather than a notebook? See how to turn lecture slides into a course. Notes about a tool with public docs? Pair them with how to turn documentation into a course.