Notion
Notion is an all-in-one note-taking and task-management tool. It allows creating docs, wikis, databases, and tasks, with high customization for individuals and teams.
- Getting started
- Workspace & sidebar
- Pages & blocks
- Databases
- Sharing & collaboration
- Marketplace (Template Gallery)
- Data & integrations
- Settings
- Plans, billing & payment
- Security & privacy
Getting started
Quick scan
- Set up your first workspace + personal structure
- Create pages fast using sidebar + slash commands
- Share safely: members vs guests + basic permissions
- Know where Settings live and what to configure first
1) Purpose / Outcome
This section gets you from “brand new” to a working Notion setup you can trust: a workspace, a simple page structure, and a repeatable way to create content. The goal is to reduce early confusion and help you build momentum.
- Decide your first use-case: personal notes, school, or a small team hub
- Create (or join) a workspace and name it clearly (e.g., Personal, Class 10A, Project X)
- Pin 3 essentials in your sidebar: Home page, Tasks, Notes
- Pick one template to start (don’t build from scratch on day 1)
- Set a “default capture” page (where new notes always go)
- Do a 5-minute trial: create 1 page, 1 database, 1 share link
2) Who is this for + When to use
For brand-new users or anyone restarting with a cleaner system. Use this when you feel lost in the sidebar, don’t know what a page vs database is, or you keep duplicating messy pages.
- Use if you need a simple, reliable structure (not a “perfect system”)
- Use if you’re setting up Notion for the first time on desktop/web
- Use before inviting teammates (to avoid permission chaos)
- Use when migrating from docs/spreadsheets into one place
- Skip if your workspace is already stable and you’re optimizing workflows
3) Where in navigation + Related tabs
Most beginner actions happen in the left sidebar (create pages, find templates, open Settings). You’ll bounce between a few core tabs as you build.
- Where: Sidebar → New page, Templates, Settings
- Related: Workspace & sidebar (navigation), Pages & blocks (writing), Databases (structured tracking)
- Related: Sharing & collaboration (invite + permission), Settings (account + workspace controls)
4) Mental model / Flow
Notion is built from pages, and pages can contain blocks (text, headings, embeds) and databases (collections of pages with properties). Your early job is to create a simple “home base” and connect pages logically via the sidebar and links.
- Create or join a workspace
- Build a small sidebar structure (Home → Notes / Tasks / Projects)
- Create pages with blocks (/ commands) and links
- Add one database for tracking (tasks or class assignments)
- Create 1–2 views (e.g., Board + Calendar) if useful
- Share a page with correct access level (viewer/editor)
- Refine: favorites, teamspaces (if on teams), settings
Expected outcome: You can capture info fast, find it later, and share it without breaking access.
5) Objects & Terms
These words show up everywhere in the Help Center. Knowing them prevents 80% of beginner confusion.
- Workspace: the container for your pages, people, and settings
- Sidebar: navigation hub for pages, teamspaces, settings, trash
- Page: a document that can contain blocks and databases
- Block: a unit of content (text, heading, image, embed, to-do, etc.)
- Database: a collection of pages with properties (table/board/calendar views)
- Template: a prebuilt page you can add and customize
- Member vs Guest: member is in the workspace; guest is invited to specific pages
6) State machine / Lifecycle
Beginner lifecycle is mostly about content maturity (draft → shared → maintained). Notion doesn’t force states, but your process can.
- Draft: private notes, unstructured capture
- Organized: moved into correct page/database, tagged
- Shared: permissions set, link shared, comments enabled
- Maintained: templates/automations reduce repeated manual work
- Archived: moved out of daily sidebar, kept searchable
7) Core jobs-to-be-done
These are the beginner “jobs” you should master before fancy setups.
- Create a page fast (title + headings + bullets) using / commands
- Find content quickly (sidebar structure + search)
- Track repeatable items (tasks/assignments) in one database
- Reuse structure (templates for notes/meetings/classes)
- Share a page safely (invite + access level)
- Adjust settings that affect your day-to-day (notifications, workspace settings)
8) Happy path workflow #1 — Set up your first workspace in 10 minutes
A fast setup that gives you a stable starting point without overthinking.
- Create/join a workspace and set a clear name
- Open the sidebar and create a Home page
- Under Home, create sub-pages: Notes, Tasks, Projects
- Favorite Home + Tasks for quick access
- In Tasks, insert a simple database (table) and add properties: Status, Due date
- Create at least one alternate view (Board by Status, if helpful)
- Add one template (e.g., meeting notes or class notes) to your Notes area
- Do a test capture: add 1 note and 1 task with a due date
Expected outcome: You have a clean sidebar, a capture place, and a working tracker you’ll actually use.
9) Happy path workflow #2 — Share a page with the right access
Sharing is where beginners accidentally leak info or block collaboration. Use this flow to share cleanly.
- Open the page you want to share
- Click Share (top of page)
- Invite a member if they should access more workspace content; invite a guest for just this page
- Choose an access level that matches intent (view/comment/edit)
- Check inheritance: confirm if sub-pages are also shared (or not)
- Send the link and ask the recipient to confirm they can open it
- Optional: turn on/off public sharing if you’re publishing
- Re-check after 5 minutes: verify nobody has higher access than needed
Expected outcome: The right people can access the right content—no more, no less.
10) Decision points (A/B)
Use this table when you’re unsure which Notion “path” to take as a beginner.
| Situation | If A… | If B… |
|---|---|---|
| Who needs access? | A: Only one person → keep private pages | B: Team needs it → create teamspace + shared pages |
| How structured is the info? | A: Freeform notes → pages with headings + links | B: Track items → database with properties + views |
| Repeating docs? | A: Rare → duplicate a page | B: Often → make a template (page or database template) |
| Sharing externally? | A: One-off share → invite as guest | B: Public publish → enable share-to-web carefully |
11) Common mistakes (and how to avoid)
These are the classic beginner traps that cause messy workspaces.
- Everything becomes a page dump: create a Home page + 2–3 core areas
- Too many databases early: start with one (Tasks) and expand later
- Wrong sharing model: guests for specific pages; members for workspace participation
- No naming rules: use clear prefixes (e.g., “NOTE — …”, “MEETING — …”)
- Over-customizing day 1: use templates first, then tweak after 1 week of usage
12) Proof & practice (what good looks like + checklist + lab + links)
A quick way to verify you set things up correctly, plus a short practice lab.
What good looks like
- You can create a new note in <30 seconds
- You can find last week’s note in <10 seconds (sidebar or search)
- Your Tasks database has at least Status + Due date
- Sharing is intentional: no accidental public pages
Checklist
Pre-check
- Workspace name + icon set
- Home page exists
- Favorites set (Home/Tasks)
- One database created
- One template added
Post-check
- Test note captured
- Test task created with due date
- Search finds both items
- Share test succeeds (viewer access)
- Trash/restore understood
Practice lab (5–10 min)
- Create a page called “Inbox” for quick capture
- Add a to-do list block and write 5 tasks
- Convert the tasks into a small database (or move into Tasks DB)
- Create a “This Week” view filtered by due date
- Share the Inbox page with a friend as “Can view”
Verify you did it right: Your friend can open the page, but cannot edit; you can see tasks in “This Week”.
Official docs links (titles)
- Getting started (Help Center category)
- Intro to workspaces
- Navigate with the sidebar
- Intro to writing & editing
- Intro to databases
- Sharing & permissions
Pages & blocks
Quick scan
- Pages are documents; blocks are the building units inside pages
- Use / commands to add blocks fast (text, headings, media, embeds)
- Use formatting + styles to make pages scannable
- Use links/backlinks to connect knowledge (not endless nesting)
1) Purpose / Outcome
This section helps you write and structure content in Notion using blocks—so your pages are easy to scan, edit, and share. The outcome is consistent pages that look good and stay maintainable.
- Create pages with a repeatable structure (title → summary → sections)
- Add blocks via / menu and understand basic vs media vs inline options
- Format text quickly (headings, lists, callouts, code, quotes)
- Embed files/media (images, PDFs, videos) where they’re needed
- Use links to connect pages instead of duplicating content
- Adopt a simple page template for notes/meetings/classes
2) Who is this for + When to use
For anyone writing notes, docs, wikis, or study materials. Use it when your pages feel messy, hard to scan, or inconsistent.
- Use when you’re starting a new docs/notes habit
- Use when converting existing documents into Notion pages
- Use when collaborating and you want consistent formatting
- Skip if you mostly work inside databases and rarely write long pages
3) Where in navigation + Related tabs
You’ll work inside any page. Most actions are through typing “/” or selecting formatting UI.
- Where: Any page → type
/to open block menu - Related: Templates (reuse structure), Databases (pages inside databases), Sharing & collaboration (comments/mentions)
4) Mental model / Flow
Think “document blocks” rather than “one giant text field.” Each block can be moved, duplicated, nested, or converted—so editing is modular.
- Start with a page outline (H1 title + H2 sections)
- Add content blocks (bullets, toggles, callouts) under each section
- Embed supporting material (images/files/links) near the relevant text
- Use mentions/links to connect related pages
- Polish: spacing, highlights, callouts, icons/cover (optional)
- Share for feedback (comments/suggested edits if available)
Expected outcome: A page others can understand in under 60 seconds of scanning.
5) Objects & Terms
Key content terms from Notion’s writing/editing guidance.
- Blocks: text, headings, to-dos, media, embeds, code, etc.
- / menu: block menu opened by typing “/”
- Inline options: mentions (@person, @page), dates/reminders
- Callout: highlighted block for emphasis
- Code block: formatted code snippet block
- Embeds: interactive previews (e.g., maps, Figma, video)
6) State machine / Lifecycle
Pages typically evolve through drafting and collaboration cycles.
- Draft: rough capture, unstructured blocks
- Structured: headings + sections + key links added
- Reviewed: comments addressed, clarity improved
- Published/shared: permissions set; optionally verified/wiki structure
- Maintained: updated via templates/buttons/consistent edits
7) Core jobs-to-be-done
Master these jobs and your pages will feel effortless.
- Capture notes fast with bullets + headings
- Turn messy notes into a clean outline
- Add media (image/PDF/video) next to the related text
- Create reusable structures (templates, template buttons, or simple duplicates)
- Link to related pages to avoid duplication
- Add reminders via inline dates so things don’t slip
8) Happy path workflow #1 — Create a scannable notes page
A simple structure that works for class notes, meeting notes, or research.
- Create a new page with a clear title (include date/topic)
- Add a 2–3 line summary at the top (what + why)
- Add sections using Heading 2: Context, Key points, Actions/Next
- Under Key points, capture bullets; use sub-bullets for detail
- Add a callout for “TL;DR” or “Decision” if needed
- Embed supporting material (PDF/image/link) under the relevant section
- Add @mentions for people/pages you want to connect
- End with a short checklist of next actions (to-do list)
Expected outcome: Someone else can skim the page and understand the essentials immediately.
9) Happy path workflow #2 — Turn repeating docs into a template
Stop recreating the same structure every time.
- Pick a page you like (e.g., your best meeting notes page)
- Remove one-off content; keep headings/structure
- Add prompts in italics (e.g., “What did we decide?”)
- Include default blocks (agenda list, action items table, etc.)
- Duplicate the page and name it “TEMPLATE — …”
- Store templates in a Templates area (or use Template Gallery if suitable)
- For teams: share template page as read-only; duplicate when needed
Expected outcome: New docs take seconds: duplicate template → fill prompts → share.
10) Decision points (A/B)
Pick the right block/tool for the job.
| Situation | If A… | If B… |
|---|---|---|
| Need quick capture? | A: Yes → bullets/to-dos now, structure later | B: No → outline with headings first |
| Content repeats often? | A: Yes → template or template button | B: No → single page is fine |
| Info should be tracked? | A: Yes → database (pages with properties) | B: No → normal page blocks |
| Need rich context? | A: Yes → embed media near text | B: No → link out to source |
11) Common mistakes (and how to avoid)
Most page problems are formatting and consistency issues.
- Wall of text: use headings + bullets + callouts
- No summary: add 2–3 lines at top so readers don’t guess
- Embedding everything: embed only what’s needed; link the rest
- Duplicating info across pages: link to a source page instead
- Inconsistent templates: pick one structure and reuse it
12) Proof & practice (checklist + lab + links)
Do this once and you’ll feel comfortable building pages forever.
Checklist
- Page has title + short summary
- Uses headings to segment content
- Has at least one callout or “Key takeaway” block
- Includes links/mentions to related pages
- Has a clear “Next actions” list
Practice lab (5–15 min)
- Create a “Study Notes” page
- Add headings: Concepts, Examples, Questions, Next steps
- Use / menu to add a code block (any language) and a callout
- Embed one image or PDF related to the topic
- Create 5 to-dos as next actions
Verify you did it right: You can scan the page and find Concepts/Examples/Questions instantly.
Official docs links (titles)
- Intro to writing & editing
- Style & customize your page
- Block basics (guide)
- Buttons (if you automate page creation)
Databases
Quick scan
- Database = a collection of pages with properties
- Views (table/board/calendar/list/gallery) are different lenses on the same data
- Use properties + filters + sorts + groups to make tracking usable
- Templates/automations reduce repeated manual work
1) Purpose / Outcome
Databases turn Notion into a tracker: tasks, assignments, projects, reading lists—anything you want to filter, sort, and view in multiple ways. The outcome is one source of truth you can update once and see everywhere.
- Create a database for a real use-case (tasks/school/projects)
- Add properties that answer key questions (status, due, owner, priority)
- Set up at least 2 views (e.g., Board + Calendar or Table + List)
- Use filters/sorts/groups to show only what matters
- Use database templates for consistent entries
- Optionally enable sub-items/dependencies if you need them
2) Who is this for + When to use
For anyone who tracks many items and needs “different views” without duplicating data. Use when lists become too long or you keep losing what’s next.
- Use for tasks, projects, homework, content calendars, inventories
- Use when you want multiple views (board/status, calendar/dates)
- Use when you need filtering (only “due this week”)
- Skip if you only take unstructured notes (pages may be enough)
3) Where in navigation + Related tabs
Databases can be full pages or inline inside a page.
- Where: Create page → add database (table/board/list/calendar/gallery)
- Related: Pages & blocks (inline databases), Templates (database templates), Automations (buttons/database automations)
4) Mental model / Flow
A database is a set of pages plus properties. Views don’t duplicate data; they only change how you see it.
- Create database with a clear purpose (one sentence)
- Define properties (what you need to know about each entry)
- Create views for common questions (What’s next? What’s overdue? What’s blocked?)
- Add templates for fast, consistent entries
- Review weekly: clean statuses, close loops, archive completed items
Expected outcome: You update one task once, and all views reflect it instantly.
5) Objects & Terms
Database vocabulary you’ll see in Notion’s database articles.
- Entry/Page: each row/card is a page with content
- Property: fields like Status, Date, Select, Person, etc.
- View: table/board/calendar/list/gallery view types
- Filter/Sort/Group: ways to shape what you see
- Template: default structure for new entries
- Sub-items: nested tasks (if enabled)
- Automations: rule-based actions (plan-dependent)
6) State machine / Lifecycle
Most trackers revolve around a status lifecycle (even if you name it differently).
- Backlog: captured but not scheduled
- In progress: active work
- Blocked: waiting on something
- Done: completed
- Archived: hidden from daily views but retained
7) Core jobs-to-be-done
These jobs make databases feel powerful instead of overwhelming.
- Design a minimal property set (avoid 20 columns early)
- Create a “This Week” filter view
- Group a board by Status for drag-and-drop progress
- Sort by Due date (then priority)
- Use templates to standardize new entries
- Tune database settings when you add advanced features (sub-items/automations)
8) Happy path workflow #1 — Build a Tasks database that you’ll actually use
A practical setup using properties and two views.
- Create a database (Table) named “Tasks”
- Add properties: Status, Due date, Priority (select), Area/Project (select)
- Create a Board view grouped by Status
- Create a “This Week” view filtered by Due date (and optionally Status ≠ Done)
- Add a Sort: Due date ascending
- Add 10 real tasks (not dummy data) and set at least 3 due dates
- Test the workflow: move 2 tasks across Status on the Board
- Hide/limit columns you never use daily
Expected outcome: You can answer “What should I do next?” in seconds.
9) Happy path workflow #2 — Use database templates for repeatable entries
Perfect for meeting notes, assignments, bug reports, or content briefs stored as database pages.
- Open the database and click the dropdown next to New
- Create a new template and name it clearly (e.g., “Weekly meeting”)
- Add a default page structure inside the template (agenda, notes, actions)
- Pre-fill standard properties (default Status, tags, etc.)
- Create one new entry from the template
- Verify properties + page content are created as expected
- Optional: explore repeating templates if you need recurring entries
Expected outcome: New entries are consistent and take seconds to create.
10) Decision points (A/B)
Choose the simplest database setup that still answers your questions.
| Situation | If A… | If B… |
|---|---|---|
| Need multiple perspectives? | A: Yes → add views (Board/Calendar) | B: No → keep one Table view |
| Status matters? | A: Yes → Status property + Board grouping | B: No → use a simple checkbox or tag |
| Recurring structure? | A: Yes → database templates/repeating templates | B: No → manual pages are fine |
| Too complex? | A: Yes → remove properties, keep only essential 3–5 | B: No → add one advanced feature at a time |
11) Common mistakes (and how to avoid)
Database pain usually comes from overbuilding.
- Too many properties: start with 3–5, expand only if used weekly
- No views: create at least one view that answers “what’s next?”
- Unclear status meanings: define statuses and keep them consistent
- Manual duplication: use templates for repeatable entries
- Forgetting to review: weekly cleanup prevents backlog rot
12) Proof & practice (checklist + lab + links)
A short test to confirm your database setup is healthy.
Checklist
- Database purpose is clear (one sentence)
- Properties are minimal and meaningful
- At least 2 views exist (or 1 if very simple)
- Filters/sorts make views actionable
- Templates exist for repeatable entries
Practice lab (10–15 min)
- Create a “Homework” or “Reading list” database
- Add properties: Status, Due date, Subject/Topic
- Create a Calendar view
- Create a “Overdue” view filtered by Due date < today and Status ≠ Done
- Add 5 items and verify they appear in the right views
Verify you did it right: A due date change updates both Calendar and Overdue views instantly.
Official docs links (titles)
- Databases (Help Center category)
- Intro to databases
- Views, filters, sorts & groups
- Database properties
- Database templates
- Database settings
- Sub-items & dependencies
- Database automations (if available on your plan)
Sharing & collaboration
Quick scan
- Share pages with members/groups or invite guests to specific pages
- Pick the right permission level (full access/edit/comment/view)
- Understand inheritance (sub-pages can inherit access)
- Use comments/mentions for collaboration instead of rewriting in chat
1) Purpose / Outcome
This section helps you share Notion content safely and collaborate smoothly: invite the right people, set the right access, and use comments/mentions to coordinate work. The outcome is fewer access problems and fewer accidental leaks.
- Share a page with members/groups inside your workspace
- Invite external collaborators as guests when appropriate
- Choose the right permission level for each person
- Verify access inheritance for sub-pages and linked content
- Use comments and @mentions to drive decisions and tasks
- Establish a simple “sharing checklist” before sending links
2) Who is this for + When to use
For anyone collaborating with classmates, teammates, or clients. Use this before you invite many people or publish anything to the web.
- Use for team docs, shared tasks, project hubs, class group work
- Use when you keep getting “no access” errors
- Use when you’re unsure if someone should be a guest or member
- Skip if you only work privately in personal pages
3) Where in navigation + Related tabs
Most actions are on the page header via the Share button, plus workspace people/settings screens.
- Where: Page → Share (top) + Settings → People/Members (role management)
- Related: Workspace & sidebar (teamspaces), Settings (members/notifications), Security & privacy (2-step verification, admin controls)
4) Mental model / Flow
Sharing is a permissions graph: who has access to which page, at what level, and whether that access inherits to sub-pages. Always set access intentionally, then verify with a quick test.
- Identify the audience (internal members vs external guests)
- Open the page and click Share
- Add people/groups (or guest emails) and set access level
- Check if sub-pages inherit access (and if that’s intended)
- Send link and ask the recipient to confirm access
- Re-audit access when the project ends
Expected outcome: No surprise access errors, and no accidental over-sharing.
5) Objects & Terms
These terms are central to Notion’s sharing and permissions guidance.
- Member: part of the workspace
- Guest: invited to specific pages (not full workspace)
- Workspace roles: workspace owner, membership admin (Enterprise), member, guest
- Teamspace roles: teamspace owner/member (separate from workspace role)
- Permission levels: full access, can edit, can comment, can view
- Inheritance: sub-pages can inherit permissions from parent pages
6) State machine / Lifecycle
Access changes as work moves from drafting to delivery.
- Private draft: only you
- Internal review: teammates can comment/edit
- External share: guests/viewers added with minimal access
- Active collaboration: mentions, comments, notifications
- Closeout: remove guest access, archive page, keep audit trail if needed
7) Core jobs-to-be-done
Practical collaboration tasks that matter every week.
- Invite someone as a guest to a single project page
- Share with a workspace group for consistent access
- Switch a page from “editable” to “view-only” for final versions
- Use @mentions to assign attention and capture decisions
- Resolve access issues (find which parent page controls permissions)
- Manage members/guests from workspace settings when needed
8) Happy path workflow #1 — Share a project page with a teammate
A safe default for internal collaboration.
- Open the project page
- Click Share
- Search/select the teammate (workspace member)
- Set access: “Can edit” if they will contribute; otherwise “Can comment”
- Confirm whether sub-pages should also be shared
- Add a short message describing what you want them to do
- Send invite
- Ask them to leave one comment to confirm access works
Expected outcome: Teammate can open and contribute at the intended level.
9) Happy path workflow #2 — Share with an external collaborator (guest)
A safe pattern for clients or people outside your workspace.
- Open the exact page the external person needs
- Click Share
- Enter their email to invite as a guest
- Set minimal access (start with “Can view” or “Can comment”)
- Check for sensitive sub-pages—avoid sharing a parent page that includes private content
- Send invite and confirm they can access
- When the work ends, remove guest access in workspace member/guest management
Expected outcome: External collaborator only sees what you intended—nothing else.
10) Decision points (A/B)
Use this to decide guest vs member and what permission level is right.
| Situation | If A… | If B… |
|---|---|---|
| Person is inside your org/team? | A: Yes → member (workspace access) | B: No → guest (page-only) |
| They should change content? | A: Yes → can edit/full access | B: No → can comment/view |
| Sharing a parent page? | A: Safe → share parent so sub-pages inherit | B: Risky → share only the specific page |
| Final doc version? | A: Still drafting → can comment/edit | B: Final → view-only + controlled edits |
11) Common mistakes (and how to avoid)
Sharing mistakes are usually permission level and inheritance issues.
- Inviting as member when guest is enough: default to guest for external people
- Over-granting edit access: start with view/comment; upgrade only when needed
- Sharing a parent with private sub-pages: share the specific leaf page instead
- Not removing access after project: do a closeout checklist
- Access confusion: trace permissions to the parent page controlling inheritance
12) Proof & practice (checklist + lab + links)
Use this to build confidence and reduce access bugs.
Checklist
- Correct audience (member vs guest)
- Minimal permission level assigned
- Inheritance checked (sub-pages)
- Recipient confirmed access
- Plan for removing access later
Practice lab (5–10 min)
- Create a page “Collab Test”
- Create a sub-page “Private Note” under it
- Share “Collab Test” with someone as “Can view”
- Ask: can they also see “Private Note”? If yes, you learned inheritance risk
- Adjust: stop sharing parent, share only the specific page that’s safe
Verify you did it right: Recipient sees only the intended page(s), and access levels match your plan.
Official docs links (titles)
- Sharing & permissions
- Guides: Sharing & permissions
- Manage members & guests
- Who’s who in a workspace
Marketplace (Template Gallery)
Quick scan
- Templates are prebuilt pages you can add and customize
- Template Gallery is a fast way to start without overbuilding
- Prefer “database-powered” templates for trackers (tasks/projects/meetings)
- Duplicate → adapt → standardize, then create your own
1) Purpose / Outcome
Templates accelerate setup by giving you a proven structure: pages, databases, and views already arranged. The outcome is a working system you customize gradually instead of building from scratch.
- Choose 1 template aligned to your real goal (not the fanciest one)
- Add it to your workspace from the Templates button or during page creation
- Customize names/properties to match your workflow
- Remove unused sections to keep it lightweight
- Standardize: make a “team version” and reuse it
- Build your own template after 1–2 weeks of real usage
2) Who is this for + When to use
For beginners who want results fast: students, personal planning, small teams. Use this when you’re tempted to spend hours designing the “perfect system.”
- Use when you need a task/project/meeting system quickly
- Use when onboarding teammates and you need consistency
- Use when you’re exploring what’s possible in Notion
- Skip if you already have a stable system and only need small improvements
3) Where in navigation + Related tabs
Templates are accessible from the sidebar Templates area and the online Template Gallery.
- Where: Sidebar → Templates (add to workspace) / Template Gallery
- Related: Pages & blocks (page templates), Databases (database templates), Workspace & sidebar (organize template area)
4) Mental model / Flow
Treat templates as “starter systems.” Your job is to reduce and adapt them, not preserve every feature.
- Pick a template that matches your top job (e.g., tasks)
- Duplicate/add it to your workspace
- Rename databases and views to your language/style
- Delete sections you won’t use weekly
- Adjust properties (status options, tags, due date usage)
- Create a “clean base version” for future duplication
Expected outcome: A usable workflow today, and a standardized version you can reuse tomorrow.
5) Objects & Terms
Template terms you’ll see in Notion’s template guidance.
- Template: a prebuilt Notion page you add to your workspace
- Template Gallery: library of templates
- Database-powered template: includes databases + views (recommended for tracking)
- Starter templates: templates that may already be in your workspace
- Duplicate: make a copy and customize without breaking the original
6) State machine / Lifecycle
Template usage typically goes through adoption and stabilization phases.
- Browse: evaluate quickly against your goal
- Adopt: add to workspace
- Customize: rename, remove noise, adjust properties
- Standardize: create a clean base version for duplication
- Maintain: refine based on weekly usage
7) Core jobs-to-be-done
Use templates to save time and reduce inconsistency.
- Find a template for a known workflow (to-do, projects, meetings, docs)
- Evaluate complexity (choose the simplest that works)
- Customize database properties and views
- Remove sections you don’t use
- Create a “team-ready” version
- Teach others how to duplicate and use it
8) Happy path workflow #1 — Adopt a template for your team
A safe way to introduce templates without overwhelming teammates.
- Pick a database-powered template aligned to a shared need (tasks/projects/meetings)
- Add it to your workspace
- Rename key databases and views to match team language
- Trim to essentials (remove sections not used weekly)
- Set sharing: teammates can view/edit as needed
- Write a short “How we use this” section at the top
- Ask 1 teammate to try it for a day and give feedback
- Freeze the base version and use it going forward
Expected outcome: Team adopts a consistent workflow with minimal friction.
9) Happy path workflow #2 — Turn a template into your own lightweight system
Perfect for personal planning or school systems.
- Choose one template for your main goal
- Duplicate it into a “My System” area
- Delete any section you won’t use weekly
- Rename Status options to match how you think (e.g., Not started/In progress/Done)
- Create one “Today” or “This Week” view
- Add 10 real items and use it for 7 days
- After a week, remove anything you never touched
Expected outcome: A system that fits your habits instead of someone else’s aesthetic.
10) Decision points (A/B)
Choose templates based on your constraints and adoption speed.
| Situation | If A… | If B… |
|---|---|---|
| Need quick wins? | A: Yes → pick simplest template | B: No → try a richer template and trim later |
| Tracking many items? | A: Yes → database-powered template | B: No → simple page template |
| Team adoption risk? | A: High → small scope + clear instructions | B: Low → broader workspace template is OK |
| Repeatable entries? | A: Often → add templates inside databases | B: Rare → manual duplication is fine |
11) Common mistakes (and how to avoid)
Templates fail when they’re too complex or never customized.
- Choosing by looks: choose by workflow fit
- Keeping every feature: delete unused sections early
- No clear instruction: add a “How to use” block at top
- Over-customizing immediately: use it for a week first
- Multiple competing templates: standardize on one base version
12) Proof & practice (checklist + lab + links)
A simple way to validate a template before committing.
Checklist
- Template matches your main job-to-be-done
- Has only features you’ll use weekly
- Database properties align with your questions
- You created at least one “actionable” view
- You can explain it to someone in 30 seconds
Practice lab (5–10 min)
- Pick a “To-do list” or “Projects & tasks” template
- Add it to your workspace
- Delete 2 sections you won’t use
- Create a “This Week” view
- Add 5 real items and complete one
Verify you did it right: You can add a new item in <15 seconds and immediately see what’s next.
Official docs links (titles)
- The ultimate guide to Notion templates
- Getting started with templates for your team
- Start with a template
Data & integrations
Quick scan
- Connect Notion to other tools via built-in integrations and the API
- Add/manage connections at workspace or page level
- Slack integration is a common starter (notifications + sending info)
- Use automations/webhook actions via partner tools (no-code workflows)
1) Purpose / Outcome
Integrations reduce manual copy-paste by connecting Notion with tools like Slack and partner automation platforms. The outcome is a workspace that stays in sync with how your team already communicates and works.
- Understand what a “connection” is in Notion
- Add a connection at the workspace level and/or page level
- Set up a starter integration (e.g., Slack notifications)
- Learn basic integration hygiene: least access, review, remove when done
- Know the difference between partner OAuth installs and internal integration tokens
- Identify where the Notion API fits (for custom workflows)
2) Who is this for + When to use
For teams or individuals who rely on multiple tools and want fewer manual steps. Use this once your core Notion structure is stable.
- Use if you want Slack updates when something changes in Notion
- Use if you need data to move between apps (via partner platforms)
- Use if you’re building custom integration workflows with the Notion API
- Skip if you’re still learning basic pages/databases and don’t feel stable yet
3) Where in navigation + Related tabs
Integrations live in connection management areas and within pages.
- Where: Help Center → Data & integrations; Settings/connection management (varies by plan)
- Related: Automations (buttons/webhook actions), Security & privacy (safe access), Databases (integration targets)
4) Mental model / Flow
An integration is an authorized bridge: it can read/write only what you grant it. Start with one narrow, high-value workflow (like Slack notifications), then expand.
- Choose a single workflow to improve (notifications, data capture, publishing)
- Pick the integration method (native integration vs partner tool vs API)
- Install/connect with least access needed
- Limit scope to specific pages/databases
- Test with a small change and verify expected behavior
- Document the workflow (who owns it, how to disable it)
Expected outcome: The integration saves time weekly and doesn’t create surprise access risk.
5) Objects & Terms
Terms commonly used in Notion’s integration guidance.
- Connection: authorized integration installed in your workspace
- OAuth install: connect via partner platform authorization flow
- Internal integration token: token-based install method for some integrations
- Notion API: programmatic access for integrations
- Webhook actions: triggers/actions via automation tools to connect apps
6) State machine / Lifecycle
Integrations should have an “owned lifecycle” so they don’t rot.
- Planned: workflow defined + owner assigned
- Installed: connection added with least privilege
- Validated: test events confirm expected behavior
- Operational: used weekly; monitored for issues
- Retired: disabled/removed when no longer needed
7) Core jobs-to-be-done
Practical integration tasks beginners actually do.
- Connect Slack and send updates/notifications tied to Notion activity
- Add/manage connections in the workspace and within pages
- Use link previews to keep context from external tools in Notion pages
- Pick a partner automation workflow (e.g., publish via webhooks)
- Decide when to use the Notion API vs no-code tools
- Audit and remove unused connections periodically
8) Happy path workflow #1 — Set up Slack integration for a Notion workflow
A common starter: connect team communication with the work tracker.
- Open Notion’s Slack integration setup guidance
- Connect the workspace to the correct Slack workspace
- Choose which database/page events should notify Slack (keep it minimal)
- Pick the Slack channel for the notifications
- Trigger a test event in Notion (e.g., status change)
- Verify Slack receives the expected message
- Write a short “What triggers this” note in the Notion page
Expected outcome: Slack updates appear reliably for the events you care about.
9) Happy path workflow #2 — Add and manage connections with the API (high-level beginner flow)
If you need custom behavior, Notion supports integrations via its API. This is a beginner-safe sequence (no code required here).
- Decide what you need: read data, write data, or both
- Create/choose an integration method (partner OAuth vs internal token, as supported)
- Add the connection and share the target pages/databases with the integration
- Confirm access is limited to intended content
- Test with one small data action (search/query/update)
- Document how to rotate/revoke access if needed
Expected outcome: You understand the setup steps and can safely proceed to implementation.
10) Decision points (A/B)
Pick the simplest integration route that meets your needs.
| Situation | If A… | If B… |
|---|---|---|
| Need quick automation? | A: Yes → native integration or partner tool | B: No → consider API for custom build |
| Scope is sensitive? | A: Yes → limit to specific pages; minimal permissions | B: No → broader access may be acceptable (still audit) |
| Workflow is one-off? | A: Yes → manual + link previews | B: Repeated weekly → invest in automation |
| Team owns maintenance? | A: Nobody → keep it simple | B: Owner assigned → more complex integration OK |
11) Common mistakes (and how to avoid)
Integration failures are usually scope and ownership issues.
- Installing everything: start with one workflow
- Over-broad access: share only the pages/databases needed
- No owner: assign someone to maintain/disable when broken
- Notification spam: reduce triggers; notify only on meaningful events
- Never auditing: remove unused connections quarterly
12) Proof & practice (checklist + lab + links)
Run this quick check after any integration setup.
Checklist
- Integration solves a weekly pain (not a novelty)
- Permissions are minimal
- Triggers are documented
- Test event succeeded
- Owner is identified
Practice lab (10 min)
- Pick one integration (Slack is a common start)
- Connect it and set a single notification rule
- Trigger one event in Notion
- Confirm the message arrives and is understandable
- Write a short “Disable steps” note for future you
Verify you did it right: One action in Notion produces one correct external event—no noise.
Official docs links (titles)
- Data & integrations (Help Center category)
- Add & manage integrations
- Integrate Slack
- Guides: Connecting tools to Notion
- Notion API Docs (developers)
Settings
Quick scan
- Settings control account preferences, notifications, and workspace configuration
- New users should set: notifications, workspace basics, and security basics
- Know where People/Members management lives (roles + guests)
- Don’t over-tweak: change only what affects daily flow
1) Purpose / Outcome
Settings are where you tune Notion to match how you work and how your workspace is governed. The outcome is fewer distractions (notifications), fewer access headaches (members/roles), and fewer security surprises.
- Set account preferences (language, personal settings as available)
- Configure notifications so you don’t miss important updates
- Understand workspace settings basics (domains, general workspace config)
- Manage people: members, guests, and roles (where applicable)
- Enable security options like two-step verification if available
- Know how to find specialized settings (IP/domains/HIPAA may be plan-dependent)
2) Who is this for + When to use
For anyone who wants Notion to fit their routine (and for admins who manage a shared workspace). Use this after you’ve created a few pages and know what annoys you.
- Use when notifications are too noisy or too silent
- Use when you’re inviting people and need role clarity
- Use when you’re setting up a team or school workspace
- Skip if you’re purely exploring and haven’t committed yet
3) Where in navigation + Related tabs
Settings are accessed from the sidebar.
- Where: Sidebar → Settings
- Related: Sharing & collaboration (people/roles), Plans billing & payment (plan changes), Security & privacy (security controls)
4) Mental model / Flow
Settings split into: (1) personal preferences, (2) workspace-level configuration, and (3) security/governance. Start with what affects your daily experience first.
- Set notification defaults (so you don’t miss mentions/reminders)
- Review workspace basics (name, trusted domains if relevant)
- Confirm who can invite/own/manage people (roles/permissions)
- Enable security basics (2-step verification if applicable)
- Only then explore advanced org controls (plan-dependent)
Expected outcome: Notion behaves predictably for you and your team (no surprise pings, no missing alerts).
5) Objects & Terms
Terms commonly seen in Notion’s Settings category navigation.
- Account settings & preferences: personal configuration
- Notification settings: what triggers alerts
- Workspace settings: workspace-level configuration (domains, general settings)
- Two-step verification: extra security step (if available)
- People/Members: member/guest management
6) State machine / Lifecycle
Settings changes should be deliberate and reversible.
- Baseline: default settings
- Tuned: notifications + preferences adjusted
- Governed: roles/policies set for collaboration
- Reviewed: periodic check (monthly/quarterly)
- Updated: changes made when team/process changes
7) Core jobs-to-be-done
High-impact settings tasks that improve daily experience.
- Reduce noise: turn off unneeded notification types
- Ensure you get mentions/reminders reliably
- Set trusted domains if you’re managing a shared organization workspace
- Manage members/guests and roles when onboarding/offboarding
- Enable security features (2-step verification) if available
- Find advanced controls only when needed (IP/domains/HIPAA may be plan-dependent)
8) Happy path workflow #1 — Fix notifications so they’re useful
Get to “I see what matters, I ignore the rest.”
- Open Settings from the sidebar
- Go to Notification settings
- Identify the 2–3 alerts you must never miss (mentions, reminders, important comments)
- Disable or reduce noisy alerts you ignore
- Do a test: @mention yourself or set a reminder date
- Confirm you receive the expected notification
- Adjust again after 2 days of real usage
Expected outcome: You reliably get high-signal notifications without constant distraction.
9) Happy path workflow #2 — Prepare workspace settings before inviting people
A lightweight admin pass before collaboration ramps up.
- Open Settings → Workspace settings
- Confirm workspace name/icon are clear
- Review any domain/trusted domain settings if relevant to your org
- Open People/Members area and understand roles available
- Decide your default sharing model (members vs guests)
- Invite one test user and validate collaboration works
- Document a simple onboarding note (where to find Home/Tasks)
Expected outcome: New members join smoothly with fewer permission issues.
10) Decision points (A/B)
Make the smallest settings change that solves your problem.
| Situation | If A… | If B… |
|---|---|---|
| Notifications feel noisy? | A: Yes → reduce alert types | B: No → keep defaults |
| Team onboarding soon? | A: Yes → review People/Members + roles | B: No → postpone admin settings |
| Security requirement exists? | A: Yes → enable 2-step verification and org controls (plan-dependent) | B: No → basic setup is enough |
| Need advanced controls? | A: Yes → consult Security/Enterprise docs | B: No → don’t touch advanced settings |
11) Common mistakes (and how to avoid)
Most mistakes are “tweak-first, understand-later.”
- Turning off too many notifications: keep mentions/reminders on
- Changing workspace policies mid-project: align changes with team communication
- Unclear roles: decide who owns membership/admin tasks
- Ignoring security basics: enable 2-step verification if you share sensitive info
- Editing advanced settings without need: avoid IP/domains/HIPAA unless you have a requirement
12) Proof & practice (checklist + lab + links)
Validate your settings with a quick real-world test.
Checklist
- You receive @mentions and reminders
- You’re not overwhelmed by noise
- Workspace basics are set
- You know where People/Members management is
- Security basics are considered (2-step verification if applicable)
Practice lab (5–10 min)
- Set a reminder date in a page
- @mention a friend or yourself in a comment
- Confirm notification arrives
- Adjust one setting and verify it changes behavior
- Write down your “preferred defaults” in a small page
Verify you did it right: Alerts are reliable and aligned with what you actually want to see.
Official docs links (titles)
- Settings (Help Center category)
- Account settings & preferences
- Notification settings
- Workspace settings
- Two-step verification
Plans, billing & payment
Quick scan
- Plans determine feature access and admin controls
- Billing is impacted by membership changes (team size matters)
- Keep invoices/payment methods organized
- Use this tab when upgrading, adding members, or handling refunds
1) Purpose / Outcome
This section helps beginners understand where billing lives, how plan changes work, and how membership impacts cost. The outcome is fewer surprises when you add people or upgrade for features.
- Identify your current plan and what it enables
- Know where to change plan and manage billing details
- Understand that adding/removing members can affect billing
- Keep payment methods and invoices accessible
- Know where to look for refunds/education/startups programs (if relevant)
- Adopt a simple billing owner process for team workspaces
2) Who is this for + When to use
For workspace owners/admins or anyone paying for a plan. Use when you’re upgrading, inviting more members, or troubleshooting charges.
- Use before adding many members to a paid workspace
- Use when enabling paid features (automations, advanced admin controls, etc.)
- Use when you need invoices for reimbursement
- Skip if you’re on a free personal workspace and not changing plans
3) Where in navigation + Related tabs
Billing content is found under the Help Center billing category and in workspace/admin settings.
- Where: Help Center → Plans, billing & payment; workspace billing settings (plan-dependent)
- Related: Settings (workspace ownership), Security & privacy (enterprise controls), Sharing & collaboration (membership changes)
4) Mental model / Flow
Billing is usually triggered by plan selection + seat/membership changes. Make changes intentionally and keep an audit note for teams.
- Check your current plan and limits
- Forecast membership (how many people will be added?)
- Choose plan upgrade/downgrade timing
- Update payment method if needed
- Download/store invoices regularly
- After changes, verify billing details match expectations
Expected outcome: You control plan upgrades and costs instead of reacting to surprises.
5) Objects & Terms
Terms commonly used in billing documentation.
- Plan: subscription tier determining features
- Billing cycle: monthly/annual (if applicable)
- Invoices: records of charges
- Payment method: card/billing details
- Members: can impact billing in team workspaces
6) State machine / Lifecycle
Billing changes often occur around growth and renewals.
- Trial/Free: exploring features
- Upgraded: paid plan active
- Scaled: membership changes affect billing
- Renewed: ongoing billing cycle
- Downgraded/Canceled: plan reduced or ended
7) Core jobs-to-be-done
Common billing tasks that prevent headaches.
- Check plan details before enabling new features
- Change plan at the right time (before team rollout)
- Manage payment methods
- Access and store invoices
- Understand member-add/remove billing impact
- Request refunds or apply programs (education/startups) if eligible
8) Happy path workflow #1 — Upgrade plan safely for a team rollout
A minimal-risk path when you’re about to onboard teammates.
- Estimate how many members you’ll add in the next 30 days
- Review what features you need (and whether they’re plan-gated)
- Choose the plan that fits your needs
- Update payment method before changing plan
- Upgrade and confirm the plan is active
- Add members gradually (start with 1–2) and verify everything works
- Download the first invoice and store it in a shared admin page
Expected outcome: Team gets needed features and billing stays predictable.
9) Happy path workflow #2 — Routine billing hygiene (monthly)
Keeps finances and admin clean.
- Check invoices for the month
- Store invoices in a single “Billing” page
- Review membership count (remove unused accounts/guests if relevant)
- Confirm payment method is valid (avoid failed payments)
- Review upcoming renewals or plan changes
- Document any changes in a short changelog note
Expected outcome: You always know what you paid for and why.
10) Decision points (A/B)
Use this when deciding whether to change plans or adjust membership.
| Situation | If A… | If B… |
|---|---|---|
| Need a paid feature now? | A: Yes → upgrade before rollout | B: No → stay on current plan |
| Team growing fast? | A: Yes → forecast seats + billing impact | B: No → review monthly only |
| Invoice required? | A: Yes → set up invoice storage and owner | B: No → optional |
| Cost too high? | A: Yes → remove unused members/adjust plan | B: No → keep stable |
11) Common mistakes (and how to avoid)
Billing surprises mostly come from timing and membership changes.
- Upgrading without a goal: tie upgrades to a real need
- Adding members without forecasting: estimate costs first
- Not saving invoices: store them monthly in one place
- No billing owner: assign responsibility in team workspaces
- Ignoring refunds/policy info: consult official billing help articles when issues arise
12) Proof & practice (checklist + lab + links)
A simple sanity check after any plan or membership change.
Checklist
- Plan matches required features
- Payment method confirmed
- Invoice downloaded/stored
- Membership count verified
- Admin notes updated
Practice lab (5–10 min)
- Create a “Billing” admin page
- Add sections: Plan, Invoices, Payment method, Membership notes
- Paste summaries (no sensitive numbers if shared widely)
- Set a monthly reminder in your Tasks database to update it
Verify you did it right: You can answer “what plan are we on and where are invoices?” in under 30 seconds.
Official docs links (titles)
- Plans, billing & payment (Help Center category)
- Change your plan
- Billing
- How adding & removing members impacts billing
- Invoices
- Payment methods
- Refunds
Security & privacy
Quick scan
- Security is a mix of settings + permissions + operational habits
- Use least privilege: share only what’s needed, to the right people
- Enable two-step verification where available
- Enterprise controls (SSO/SCIM/audit logs) are plan-dependent
1) Purpose / Outcome
This section helps you protect your Notion content: control access, reduce accidental sharing, and understand what security options exist. The outcome is a workspace where sensitive information is handled intentionally.
- Adopt least-privilege sharing (minimal permissions)
- Understand the difference between private, shared, and public pages
- Enable security basics like two-step verification when available
- Know plan-dependent enterprise features (SSO/SCIM/audit logs)
- Set basic operational hygiene (review guests, remove old access)
- Know where to find privacy practices documentation
2) Who is this for + When to use
For anyone storing personal info, school/work documents, or team knowledge. Use it before publishing pages to the web or inviting many external guests.
- Use if you share content externally (clients, collaborators)
- Use if your workspace has many members/guests
- Use if your org needs compliance/security controls
- Skip only if you keep everything private and non-sensitive (still recommended)
3) Where in navigation + Related tabs
Security is covered in the Help Center Security & privacy category and related settings areas.
- Where: Help Center → Security & privacy; Settings → Two-step verification; Sharing UI on pages
- Related: Sharing & collaboration (permissions), Settings (security toggles), Data & integrations (connection access)
4) Mental model / Flow
Security is “layers”: account security, workspace governance, page-level permissions, and integration access. Start with the highest-impact layers first.
- Secure accounts (2-step verification where available)
- Use correct roles (owner/admin/member/guest) and keep them minimal
- Set page permissions intentionally (view/comment/edit)
- Review public sharing and disable where not needed
- Audit integrations/connections and remove unused ones
- Periodically review guests and external access
Expected outcome: You can explain who has access to what—and you’re confident it’s correct.
5) Objects & Terms
Common security-related terms in Notion’s official materials.
- Two-step verification: adds an extra authentication layer
- Roles: workspace owner/membership admin/member/guest (availability depends on plan)
- Permissions: full access/edit/comment/view per page
- SSO (SAML): enterprise single sign-on (plan-dependent)
- SCIM: user provisioning automation (plan-dependent)
- Audit log: activity tracking (plan-dependent)
6) State machine / Lifecycle
Security posture should mature as you grow from personal to team to org scale.
- Personal: private pages, basic account security
- Small team: clear sharing rules + guest hygiene
- Org: role governance + domain controls (as needed)
- Enterprise: SSO/SCIM/audit controls (plan-dependent)
- Ongoing: periodic audits and access cleanups
7) Core jobs-to-be-done
Beginner-friendly security jobs that matter the most.
- Enable two-step verification (if available)
- Reduce over-sharing by using view/comment instead of edit
- Remove guests after a project ends
- Identify which pages are public and disable if not intended
- Review integrations and their access scope
- Know where to find privacy/security practices docs
8) Happy path workflow #1 — Lock down a workspace for safe collaboration
A lightweight security pass for new teams.
- List the types of content you store (public vs sensitive)
- Define default sharing behavior (internal only unless approved)
- Set minimal roles for admins/owners
- Review top shared pages and ensure permissions are correct
- Check for public pages and disable share-to-web unless needed
- Enable two-step verification guidance for members (where available)
- Create a short “Security rules” page for the team
Expected outcome: Collaboration works without accidentally exposing content.
9) Happy path workflow #2 — Clean up external access (guest audit)
Use monthly or at project close to reduce lingering risk.
- Identify current guests and why they have access
- For each guest: confirm the pages they can access are still needed
- Reduce permissions (edit → comment/view) if collaboration ended
- Remove guests who no longer need access
- Re-check critical pages: confirm no unexpected sharing via inheritance
- Document changes in an admin note
Expected outcome: Only active collaborators retain access.
10) Decision points (A/B)
Use this when balancing convenience vs security.
| Situation | If A… | If B… |
|---|---|---|
| Need external collaboration? | A: Yes → invite as guest with minimal access | B: No → keep pages internal |
| Should page be public? | A: Yes → publish intentionally, review content | B: No → disable share-to-web |
| Integration needed? | A: Yes → limit scope to specific pages/databases | B: No → don’t install |
| Org requires compliance? | A: Yes → consult enterprise security controls (SSO/SCIM/audit) | B: No → stick to basics + reviews |
11) Common mistakes (and how to avoid)
Security issues are often accidental, not malicious—prevent the accidents.
- Sharing parent pages: can unintentionally share private sub-pages
- Everyone can edit: use comment/view by default
- Never removing guests: audit after projects
- Installing integrations without scope control: grant least privilege
- Ignoring account security: enable two-step verification if available
12) Proof & practice (checklist + lab + links)
A small exercise to ensure you can control access confidently.
Checklist
- Two-step verification enabled (if available)
- Public pages reviewed intentionally
- Guests list is clean and current
- Key pages have least-privilege permissions
- Integrations are audited and scoped
Practice lab (10 min)
- Pick one important page
- Review who has access and at what level
- Reduce one person from edit → comment (if appropriate)
- Check sub-pages for inheritance effects
- Write a short “Access policy” note on the page
Verify you did it right: You can describe permissions clearly, and changes behave as expected.
Official docs links (titles)
- Security & privacy (Help Center category)
- Privacy practices
- Notion Security & Compliance overview (security page)
- Two-step verification
- Sharing & permissions
