Obsidian Meeting Template: The Complete Guide to Structured Meeting Notes

If you’ve ever searched through a dozen scattered notes trying to find what you decided in last month’s client call, you already know the pain of disorganized meeting notes. Obsidian can become your single source of truth for meetings when you pair it with a dedicated meeting template and a simple workflow that takes seconds to trigger.

Why You Need an Obsidian Meeting Template (Answer the Query Fast)

A reusable obsidian meeting template saves time before, during, and after every meeting you attend. Before the call, your agenda is already formatted and waiting. During the meeting, you capture discussion points without fumbling with structure. Afterward, you update a one-line summary and your entire vault becomes searchable by person, project, or date.

This guide walks you through everything you need to build a productive meeting note system:

• Setting up a clean folder structure for all your meetings

• Creating a reusable meeting note template with YAML properties and structured sections

• Adding a meta bind button to create new meeting notes in seconds

• Querying meetings by attendee, company, or project using Dataview tables

The instructions assume Obsidian v1.6+ on desktop (2024) and reference several plugins: Templater, Dataview, Calendar or Full Calendar, and Meta Bind. All features work with the free version of Obsidian.

The Big Picture: How an Obsidian Meeting System Works

Before diving into settings and code, it helps to understand what happens end-to-end when you use this system.

You click a “New Meeting” button on your Meetings MOC page (or a calendar entry). Obsidian automatically creates a dated meeting note from your template. You fill in the agenda before the call, capture notes and decisions during the meeting, and log action items with owners and due dates. Later, you can filter all meetings by person, project, or date range using Dataview queries that update in real time.

Here’s a concrete flow example:

• Meeting title: “2024-05-13 – Weekly Product Sync”

• Start time: 10:00

• Attendees: [[Jane Smith]], [[John Doe]]

• Project: [[Backend Platform]]

• Location: Conference room B or Zoom link

The file name combines the date and a short descriptive subject—something like 2024-05-13 – Marketing Q3 Planning.md. This pattern keeps your notes sortable by date while still being human-readable.

Your system rests on three core pieces:

• A Meetings folder where individual notes live

• A Meetings MOC (map of content) that serves as your dashboard

• A Meeting Note template file that Templater uses to generate each new note

Set Up Your Obsidian Vault for Meeting Notes

A simple folder structure keeps your vault organized and your Dataview queries fast. Create a parent folder for time-based content:

/Timestamps/
/Timestamps/Daily/
/Timestamps/Meetings/

Why group dates together in a shared “Timestamps” area? It keeps all chronological notes—daily notes, meetings, and events—in one logical location. Dataview scans this structure efficiently, handling 10,000+ files in under a second on modern hardware.

Store all individual meeting notes directly inside /Timestamps/Meetings/, not in subfolders organized by project or client. Flat structures simplify queries and avoid fragmenting your results.

Name your Meetings MOC file with an emoji prefix—something like 🗣 Meetings MOC.md—so it sorts above dated notes in the file explorer.

Example filenames for individual notes:

• 2024-05-13 – Product Roadmap Review.md

• 2024-05-14 – Client ABC Onboarding.md

If you use the Calendar or Full Calendar plugin, point the default new file location to your Meetings folder. Go to Settings → Core Plugins → Daily Notes (or the plugin-specific settings) and set the folder path to /Timestamps/Meetings.

Essential Plugins and Tools for an Obsidian Meeting Template

Four plugins form the technical backbone of this workflow. Each one handles a specific job in the creation and management of your meeting notes.

Installing plugins (2024 process):

1. Open Settings → Community plugins

2. Turn off Safe mode if prompted

3. Click Browse

4. Search for each plugin by name

5. Click Install, then Enable

Here are the plugins you need:

• Templater (or core Templates): Inserts your meeting note structure with dynamic variables like <% tp.date.now("YYYY-MM-DD") %>. Templater supports conditionals and loops, making it far more powerful than the built-in Templates plugin for this use case.

• Dataview: Powers your Meetings MOC with live-updating tables showing all meeting notes, attendees, projects, and summaries. Use Dataview 0.5+ syntax for the examples in this guide.

• Calendar or Full Calendar: Enables date-based creation and browsing. Calendar creates one daily note per day; Full Calendar supports multiple separate meeting notes per day with start_time and end_time properties.

• Meta Bind (or Buttons plugin): Creates a clickable “New Meeting” button inside your Meetings MOC that triggers Templater to generate a fresh note. The meta bind plugin handles interactive elements elegantly.

All examples assume Markdown notes with YAML properties (frontmatter) at the top of each file.

Designing Your Obsidian Meeting Note Template

Your meeting template should be lightweight enough to use in real-time but structured enough to capture everything that matters. Here’s a concrete template with YAML frontmatter and body sections:

---
date: <% tp.date.now("YYYY-MM-DD") %>
start_time:
type: meeting
company:
attendees:
projects:
summary:
---

## Agenda
-

## Discussion & Notes
-

## Decisions
-

## Action Items / Next Steps
- [ ] Task @[[Owner]] due YYYY-MM-DD

## Attachments & Resources
-

YAML properties explained:

Property	Example Value	Purpose
date	2024-05-13	ISO format for sorting
start_time	10:00	Meeting start time
type	meeting	Filter meetings from other note types
company	[[Acme Corp]]	Link to organization note
attendees	[[Jane Smith]], [[John Doe]]	YAML list of person links
projects	[[Product Roadmap 2024]]	YAML list of project links
summary	Finalized Q3 features	1-2 sentence tl;dr added after meeting

Body sections:

• Agenda: Pre-fill with bullet points before the meeting starts

• Discussion & Notes: Capture key points during the call

• Decisions: Document what was decided (this is gold for future you)

• Action Items / Next Steps: Use checkbox tasks with owners and due dates, e.g., - [ ] Prepare Q3 forecast @[[Jane Smith]] due 2024-05-20

• Attachments & Resources: Links, embedded files, or recording URLs

Keep sections lightweight. Bullet lists work better than complex tables during live note-taking. The goal is to create a document you can actually use in the moment, not a form that slows you down.

Creating and Using the “New Meeting” Button

The fastest way to create a new meeting note is a button on your Meetings MOC. One click prompts you for a title, and Obsidian generates a fully formatted note in the right folder with today’s date already inserted.

Here’s example button code using Meta Bind syntax:

```meta-bind-button
style: primary
label: ➕ New Meeting
actions:
  - type: templaterCreateNote
    templateFile: Templates/Meeting Template.md
    folderPath: Timestamps/Meetings
    fileName: <% tp.date.now("YYYY-MM-DD") %> – {{TITLE:prompt}}
    openNote: true

When you click the button:

1. A prompt appears asking for a short title (e.g., “Client XYZ Kickoff”)

2. Templater creates a new file named `2024-06-03 – Client XYZ Kickoff.md`

3. The note opens with all template sections ready for input

**Troubleshooting tips:**

* Duplicate filenames cause Templater errors. If you have two meetings on the same date, keep titles unique by adding “#2” or a more specific descriptor

* Make sure your template file path matches exactly what you’ve configured in Templater settings

* If the button doesn’t work, verify that both Meta Bind and Templater plugins are enabled and configured

## Building a Meetings MOC with Dataview

Your `🗣 Meetings MOC` page becomes a dashboard when you add a Dataview table. This query scans your Meetings folder and displays a sortable list of all your meetings related to any topic.

Here’s the Dataview query to insert:

```dataview
TABLE
  date,
  company,
  summary
FROM "Timestamps/Meetings"
SORT date DESC

This produces a live-updating table with columns for the file name (which serves as your meeting subject), the date, the company, and a short summary you write after each call.

Filename vs. summary distinction:

• The filename is your subject line—short and scannable, like “Q3 Marketing Planning”

• The summary property holds a 1-2 sentence tl;dr for future you searching the archive

Example output might look like:

File	date	company	summary
2024-05-13 – Product Roadmap Review	2024-05-13	[[Product Team]]	Finalized Q3-Q4 features
2024-05-10 – Client ABC Onboarding	2024-05-10	[[Client ABC]]	Aligned on success metrics and launch dates

The latest meeting notes live at the top. You can filter by adding WHERE clauses (e.g., WHERE company = [[Acme Corp]]) or use CONTAINS for attendees.

Linking Meetings to People and Projects

The real power of this obsidian meeting note template emerges when you link meetings to people and projects. Those attendees and projects properties become queryable backlinks.

Per-attendee view:

In your [[Jane Smith]] person note, add a Dataview query:

TABLE WITHOUT ID
  file.link AS "Meetings",
  date,
  summary
FROM "Timestamps/Meetings"
WHERE contains(attendees, this.file.link)
SORT date DESC

This automatically lists every meeting Jane Smith attended, sorted by date. No manual tagging required—if she’s in the attendees list, she appears here.

Per-project view:

In your [[Product Roadmap 2024]] project note, use a similar query:

TABLE WITHOUT ID
  file.link AS "Meetings",
  date,
  summary
FROM "Timestamps/Meetings"
WHERE contains(projects, this.file.link)
SORT date DESC

Now you can see the chronological history of every discussion about that project.

Use case examples:

• Open a person’s page before a 1:1 to review your past conversations

• Check a project page to see what decisions have been made over time

• Cross-link from meetings back to people and projects for full bidirectional navigation

For users exploring Obsidian Bases (in beta as of 2024), these linked properties will integrate with relational database features in the future.

Using Calendar or Full Calendar for Time-Based Meetings

Both Calendar and Full Calendar plugins let you click on a date to create or open meeting notes. The choice depends on how you prefer to organize your workflow.

Calendar (core plugin):

• Creates one daily note per day using the format YYYY-MM-DD-dddd (e.g., 2024-05-13-Monday)

• You can store multiple meeting sections inside that daily note

• Pros: Simple setup, works well for journaling-style logs

• Cons: Harder to filter and link individual meetings

Full Calendar (community plugin):

• Supports multiple separate meeting notes per day

• Uses properties like start_time: "10:00" and end_time: "10:30"

• Can sync with external calendars (iCal, Outlook)

• Pros: Better for per-meeting filtering and linking

• Cons: More setup required

Recommendation for 2024:

• Use daily notes with meeting sections if you prefer a journaling approach and have fewer than 3 meetings per day

• Use dedicated meeting notes (as described in this article) if you need better per-meeting search, linking, and action item tracking

To connect either plugin to your workflow, point its settings to the /Timestamps/Meetings folder as the default new file location.

Example: A Real Meeting Note from Start to Finish

Let’s walk through a specific example to see how the template feels in actual use. The meeting is “2024-06-05 – Q3 Marketing Planning” with attendees [[Jane Smith]] and [[Carlos Perez]], tied to the project [[Marketing FY2024]].

09:55 – Creation: You click the New Meeting button on your Meetings MOC. The prompt appears, you type “Q3 Marketing Planning,” and the note generates instantly.

09:58 – Pre-meeting agenda: You fill in the agenda section while waiting for attendees to join:

• Budget review for Q3

• Campaign themes and messaging

• Channel mix (paid vs. organic)

10:00-10:30 – During the meeting: As the discussion unfolds, you capture notes in real time:

• Budget approved at $45K for Q3

• Focus on product launch campaign in July

• Carlos to own the content calendar

10:31 – Post-meeting: You update the summary property with a one-sentence tl;dr and add action items.

Here’s what the final file looks like:

---
date: 2024-06-05
start_time: "10:00"
type: meeting
company: [[Marketing Dept]]
attendees: [[Jane Smith]], [[Carlos Perez]]
projects: [[Marketing FY2024]]
summary: Approved $45K Q3 budget; Carlos owns content calendar.
---

## Agenda
- Budget review for Q3
- Campaign themes and messaging
- Channel mix (paid vs. organic)

## Discussion & Notes
- Budget approved at $45K, up from $40K in Q2
- Product launch campaign kicks off July 1
- Shift 60% of spend to paid channels for launch month

## Decisions
- Q3 budget: $45,000
- Primary focus: July product launch
- Carlos leads content; Jane leads paid

## Action Items / Next Steps
- [ ] Draft Q3 content calendar @[[Carlos Perez]] due 2024-06-12
- [ ] Finalize paid channel plan @[[Jane Smith]] due 2024-06-10

## Attachments & Resources
- [[Q3 Marketing Brief]]

The whole process—from creation to finished note—takes about two minutes of focused post-meeting effort. Everything searchable, everything linked.

Maintaining Your Obsidian Meeting System Over Time

The best meeting note system is one you actually use. Start with a minimum viable template and edit it over weeks rather than trying to perfect it on day one.

Practical evolution tips:

• Review your template monthly and remove sections you never fill in

• Add a new property only when you notice a repeated need (e.g., recording_link or client_status)

• Don’t add features speculatively—wait until testing in real meetings reveals gaps

Habit loop that works:

1. Always create the note before the meeting starts

2. Always capture 1-3 decisions (even if one is “no decision made”)

3. Always log action items with a clear owner and due date

The moment you start skipping steps, the system breaks down. Prioritize documenting real meetings over endlessly tweaking your setup. After a month of consistent use, you’ll have a searchable archive that rivals any CRM—at zero cost.

Summary: Turn Obsidian into Your Meeting Command Center

You now have everything you need to build a meeting note system that actually works:

• Create structured meeting notes in seconds using your template and the New Meeting button

• Track attendees, projects, and companies with linked YAML properties that power bidirectional navigation

• Browse and search all meetings via your Meetings MOC and Dataview tables sorted by date

• See every discussion tied to a person or project through per-attendee and per-project queries

• Choose your calendar integration based on whether you prefer daily notes or dedicated meeting files

This system handles recurring team syncs, client calls, and one-off workshops equally well. The workflow scales from a handful of meetings per month to dozens without any structural changes.

Here’s your next step: set aside 30-60 minutes to implement the core setup—folders, template, MOC, and button—then test it in your next real meeting. That single hour of investment will pay off every time you need to answer “what did we decide about X?” and the answer appears in seconds.