Master Notion: From Confused to Confident with Marie Poulin's Coaching
Based on Tiago Forte's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Replace a single evolving “canonical” speaker-notes page with a database so updates don’t break reliability.
Briefing
A major source of Notion stress isn’t the app’s complexity—it’s the lack of a reliable structure for changing content without losing authority. In a coaching session with Marie Poulin, the focus lands on turning a constantly evolving “speaker notes” document into a system that stays trustworthy even as new cohorts, resources, recordings, and feedback keep arriving.
The workflow starts with a tension many teams recognize: one “canonical” document that must remain stable versus the reality that improvements keep demanding edits. The solution is to stop treating pages like static truth and instead build a database-backed template where changes are fast, reversible, and automatically organized. Rather than relying on folders where data lives in one place, the approach leans into Notion’s ability to access the same information in multiple contexts—so the same speaker notes can be filtered, embedded, and reused without duplicating chaos.
Poulin demonstrates this by creating a database on the “parent page” for “live session speaker notes,” then dragging existing pages into that database. Key properties are added to make the records usable over time: automated timestamps like created time and last edited time, a version/cohort tag (e.g., “V 15”), status phases (planning, preparation, delivery, finished), and practical links such as a URL for the keynote file or related assets. Person properties help assign ownership so team members can work without seeing everything.
From there, the dashboard becomes the control center. Resources and past-session material are organized into headings and pulled into a table of contents so staff can find what matters quickly. Filtering by cohort/version (for example, showing only items tagged with “v15”) keeps views clean and prevents accidental clutter. The system also anticipates operational needs: where recordings live (e.g., Panopto), where feedback is stored, and how responsibilities shift over time through “responsible person” assignments and filtered views.
A second database for “in-class resources” adds another layer of reuse. Resources can be stored once (as URLs, file properties, or attachments like worksheets), then linked to sessions through relations. Two-way relations let a resource page show every session where it was referenced, enabling consistent reuse of high-value materials without hunting through scattered Google Drive folders or video links.
Finally, the session turns these building blocks into templates. Instead of starting from scratch each time, the content for each course section (e.g., “Express” and “distill”) is copied into templates and converted into text blocks inside the template so new sessions inherit a proven starting point. The result is a repeatable “starting script” that reduces fluster and preserves consistency—while still allowing edits where they matter.
The coaching takeaway is as much behavioral as technical: build systems that match existing habits, then standardize them. The goal isn’t to impose rigid rules that make people feel worse—it’s to make the next session easier to run, easier to update, and easier for a team to maintain with confidence.
Cornell Notes
The coaching session reframes Notion from a place to store documents into a system for managing change. A “live session speaker notes” database replaces a single, fragile canonical page, using properties like cohort/version tags, status phases, timestamps, ownership, and URLs to keep records reliable over time. A dashboard then filters and presents only what’s relevant for the current cohort, while relations connect sessions to reusable “in-class resources.” Templates capture the repeatable parts of each session type (e.g., Express, distill) so new sessions start from a proven structure rather than from scratch. This matters because it reduces stress, prevents clutter, and helps teams maintain authoritative materials without freezing them in place.
How does a database-based approach reduce the “canonical document” problem in team workflows?
Which Notion properties make speaker notes manageable as cohorts repeat?
How does the dashboard avoid clutter while still keeping access to past information?
What role do relations play between sessions and reusable resources?
Why convert content into templates, and how is that done in this workflow?
What’s the coaching principle behind the technical choices?
Review Questions
- When would a cohort/version tag be more useful than relying on manual page naming, and how would you use it in a filtered view?
- How would you decide which properties to add to a speaker-notes database without turning it into excessive data entry?
- What are the practical benefits of using two-way relations between sessions and resources compared with storing only URLs inside each session page?
Key Points
- 1
Replace a single evolving “canonical” speaker-notes page with a database so updates don’t break reliability.
- 2
Use cohort/version tags (e.g., “V 15”) and filtered views to keep dashboards clean for the current session cycle.
- 3
Add operational properties—status phases, timestamps, URLs, and ownership—to make maintenance and delegation straightforward.
- 4
Build a dashboard that combines navigation (headings and table of contents) with embedded access to past recordings and resources.
- 5
Create a separate “in-class resources” database and link it to sessions using relations so references are reusable and searchable.
- 6
Turn repeatable session structures into templates so new cohorts start from a proven baseline instead of rebuilding from scratch.
- 7
Standardize what already works, then add only the properties and connections that support the team’s real workflow goals.