Meeting Notes

The Problem

Most meeting notes die in a Google Doc that nobody opens again. Decisions get forgotten. Action items have no owner. Follow-ups don't happen. The meeting was a waste of everyone's time — not because of the conversation, but because nothing carries forward.

The fix isn't better note-taking. It's a system where notes live next to the work, action items become real tasks with assignees and due dates, and decisions are findable when you need them months later.

How It Works in Based

In Based, meeting notes are pages. Tasks are entities. They live in the same workspace, so the path from "we decided X" to "Alice is doing X by Friday" is one click — not a copy-paste into a separate tool.

• Meeting note = a page with a structured template (attendees, agenda, notes, decisions, actions)
• Action item = a task entity created inline with /task in the editor, linked to the meeting page
• Decision log = a DataTable view over meeting-decision entities, searchable across all meetings
• Carry-forward = open action items from last meeting surface automatically in the next one

Page Structure

📝 Meetings
│
├── 📅 Meeting Index
│   ├── DataTable: meetings/ sorted by date desc
│   │   Columns: title, type, date, attendees, actionCount, openActions, status
│   └── Filtered views:
│       ▶ This Week (filtered by date in current week)
│       ▶ My Meetings (filtered by attendees contains currentUser)
│       ▶ With Open Actions (filtered by openActions > 0)
│
├── 📋 Recurring Meetings (one sub-page per series)
│   │
│   ├── Team Standup
│   │   ├── Next meeting note (always at the top, linked to latest)
│   │   ├── DataTable: meetings/ filtered by series="standup" sorted by date desc
│   │   └── Open Actions Rollover
│   │       DataTable: tasks/ filtered by source contains "standup", status != done
│   │
│   ├── Weekly All-Hands
│   │   ├── Latest note
│   │   ├── Past meetings table
│   │   └── Open actions rollover
│   │
│   ├── Board Meeting
│   │   ├── Latest note
│   │   ├── Past meetings table
│   │   └── Open actions rollover
│   │
│   ├── 1:1s
│   │   ├── [Person A] 1:1
│   │   │   ├── Latest note
│   │   │   ├── Running topics list (things to discuss next time)
│   │   │   ├── Past meetings
│   │   │   └── Open actions
│   │   ├── [Person B] 1:1
│   │   │   └── ...
│   │   └── 1:1 Template
│   │
│   └── Sprint Retro
│       ├── Latest note
│       ├── Past retros
│       └── Open improvement actions
│
├── 📌 Decisions Log
│   ├── DataTable: decisions/ sorted by date desc
│   │   Columns: decision, context, date, meeting, owner, status
│   └── Search: find any past decision by keyword
│
├── ✅ All Meeting Actions
│   ├── Kanban: tasks/ filtered by meetingId exists, grouped by status
│   │   todo → in_progress → done
│   ├── DataTable: tasks/ filtered by meetingId exists, status != done
│   │   Columns: title, assignee, dueDate, meeting, status
│   │   → "What's still open from meetings?"
│   └── Overdue Actions
│       DataTable: tasks/ filtered by dueDate < today, status != done, meetingId exists
│
└── 📚 Meeting Wiki
    ├── Meeting Types & Cadences
    ├── How to Run a Good Meeting
    └── Note-Taking Responsibilities

The Meeting Note Template

Create this as a page. Copy it each time you start a new meeting. The structure is designed so the note-taker fills it in order during the meeting, and the action items section is the last thing before you close.

# [Meeting Title] — [Date]

## Meta
- **Type**: standup | 1:1 | all-hands | planning | retro | client | partner | board
- **Date**: YYYY-MM-DD
- **Attendees**: @alice @bob @carol  (use mention blocks)
- **Facilitator**: @alice
- **Note-taker**: @bob

---

## Open Actions from Last Meeting

[DataTable block: tasks/ filtered by series="this-series", status != done]

Review each one:
- Done? → mark complete in the table
- Still in progress? → update and carry forward
- Blocked? → discuss and reassign or escalate

---

## Agenda

1. [Topic 1] — @owner (X min)
2. [Topic 2] — @owner (X min)
3. [Topic 3] — @owner (X min)

---

## Notes

### [Topic 1]
- Discussion point
- Discussion point
- Key insight or data shared

### [Topic 2]
- Discussion point
- Discussion point

### [Topic 3]
- Discussion point

---

## Decisions

> Use callout blocks for each decision. These get extracted into the Decisions Log.

[callout: Decision] We will [do X] because [reason]. Owner: @alice

[callout: Decision] We decided not to [Y] because [reason]. Revisit in Q3.

[callout: Decision] Approved [Z] with budget of $X. @bob to execute.

---

## Action Items

> Use /task in the editor to create real task entities inline.
> Each action must have: what, who, when.

[task] Ship the landing page redesign — @alice — due 2026-03-01
[task] Send partner intro to Acme Corp — @bob — due 2026-02-28
[task] Write up the pricing analysis — @carol — due 2026-03-05
[task] Schedule follow-up with investor — @alice — due 2026-02-27

---

## Parking Lot

- [Topic deferred to next meeting]
- [Idea to revisit later]
- [Question that needs more research]

Meeting Type Templates

Different meetings need different structures. Here are templates for common meeting types:

Daily Standup (15 min)

# Standup — [Date]

Attendees: [team]

### Updates (per person)

**@alice**
- Yesterday: [what was done]
- Today: [what's planned]
- Blockers: [none / description]

**@bob**
- Yesterday: ...
- Today: ...
- Blockers: ...

### Blockers to Resolve
- [blocker] → @owner to unblock by [when]

### Action Items
[task] [action] — @assignee — due [date]

1:1 Meeting (30 min)

# 1:1 — [Manager] & [Report] — [Date]

## Check-in
- How are you doing? (1-10)
- What's on your mind?

## Open Actions from Last Time
[DataTable: tasks filtered by series="1:1-alice-bob", status != done]

## Their Agenda (report drives)
- [Topic they want to discuss]
- [Topic they want to discuss]

## Your Agenda (manager)
- [Feedback or topic]
- [Career development topic]

## Decisions
[callout] ...

## Action Items
[task] [action] — @assignee — due [date]

## Running Topics for Next Time
- [save items for next 1:1 here]

Sprint Retrospective (60 min)

# Retro — Sprint [N] — [Date]

Attendees: [team]
Facilitator: @name

## Open Improvements from Last Retro
[DataTable: tasks filtered by series="retro", status != done]

## What Went Well
- [good thing]
- [good thing]
- [good thing]

## What Didn't Go Well
- [pain point]
- [pain point]

## What Can We Improve
- [suggestion] → vote: 👍👍👍
- [suggestion] → vote: 👍👍
- [suggestion] → vote: 👍

## Top Improvements (pick 1-3 to act on)
[callout: Decision] We will [improvement]. Owner: @name

## Action Items
[task] [improvement action] — @assignee — due [date]

Client / Partner Meeting (45 min)

# Meeting with [Company] — [Date]

**Type**: client | partner | prospect
**Their attendees**: [names and titles]
**Our attendees**: @alice @bob
**Related to**: [link to customer/partner entity]

## Context
- What's the relationship? [customer since X / partner on Y]
- What's the purpose of this meeting?
- What do we want to get out of it?

## Agenda
1. [Topic]
2. [Topic]
3. Next steps

## Notes
### [Topic 1]
- They said: ...
- We said: ...
- Key takeaway: ...

### [Topic 2]
- ...

## Commitments (what we promised them)
[callout: Commitment] We committed to [X] by [date]. Owner: @alice

## Commitments (what they promised us)
[callout: Commitment] They will [Y] by [date]. Follow up if not received.

## Internal Action Items (not shared with them)
[task] [action] — @assignee — due [date]

## Follow-up
- Send summary email to their team — @bob — today
- Next meeting: [date or "schedule in 2 weeks"]

Board Meeting (90 min)

# Board Meeting — [Quarter] [Year]

**Date**: [date]
**Board members**: [names]
**Company attendees**: [CEO, CTO, CFO, etc.]
**Location**: [in-person / virtual]

## Open Items from Last Board Meeting
[DataTable: tasks filtered by series="board", status != done]

## CEO Update (20 min)
- Company highlights since last meeting
- Key metrics: [MRR, users, runway, headcount]
- Strategic priorities for next quarter

## Financial Review (15 min)
- P&L summary
- Cash position and runway
- Budget vs actual
- Fundraising update (if applicable)

## Product Update (15 min)
- What shipped
- What's next
- Key product decisions needed

## Discussion Topics (30 min)
### [Strategic Topic 1]
- Context: ...
- Options: A, B, C
- Discussion: ...
- [callout: Decision] Board decided [X]

### [Strategic Topic 2]
- ...

## Board Resolutions
[callout: Resolution] Resolved: [formal decision if needed]

## Action Items
[task] [action] — @assignee — due [date]

## Executive Session (board only)
[not captured in shared notes]

## Next Board Meeting: [date]

Entity Schemas

{
  "Meeting": {
    "path": "@meetings/(id:nanoid)",
    "file": "[data].json",
    "fields": {
      "title": { "type": "string", "required": true },
      "type": { "type": "string", "required": true },
      "series": { "type": "string" },
      "date": { "type": "string", "required": true },
      "duration": { "type": "number" },
      "attendees": { "type": "array" },
      "facilitator": { "type": "string" },
      "noteTaker": { "type": "string" },
      "pageId": { "type": "string" },
      "status": { "type": "string", "default": "scheduled" },
      "actionCount": { "type": "number", "default": 0 },
      "openActions": { "type": "number", "default": 0 },
      "relatedEntityId": { "type": "string" },
      "relatedEntityType": { "type": "string" },
      "tags": { "type": "array" },
      "notes": { "type": "string" }
    },
    "refs": {
      "page": { "model": "Page", "field": "pageId", "type": "belongsTo" }
    },
    "oplog": true,
    "softDelete": true
  },
  "Decision": {
    "path": "@decisions/(id:nanoid)",
    "file": "[data].json",
    "fields": {
      "decision": { "type": "string", "required": true },
      "context": { "type": "string" },
      "meetingId": { "type": "string", "required": true },
      "date": { "type": "string", "required": true },
      "owner": { "type": "string" },
      "status": { "type": "string", "default": "active" },
      "revisitDate": { "type": "string" },
      "supersededBy": { "type": "string" },
      "tags": { "type": "array" },
      "notes": { "type": "string" }
    },
    "refs": {
      "meeting": { "model": "Meeting", "field": "meetingId", "type": "belongsTo" }
    },
    "oplog": true,
    "softDelete": true
  }
}

Action items use the built-in Task entity — no separate schema needed. Link tasks to meetings using the pageId field (the meeting note page) and the tags field for the series name. This means meeting actions show up in your regular task views too — no separate tracking system.

The Carry-Forward System

This is the most important part. Without carry-forward, meetings produce notes that nobody reads again. Here's how to make it automatic:

How carry-forward works:

1. DURING the meeting
   - Create action items using /task in the editor
   - Each task gets: title, assignee (@mention), due date
   - Tasks are real entities — they appear in the sidebar under "My Tasks"
   - Tag tasks with the meeting series (e.g., "standup", "1:1-alice-bob")

2. BETWEEN meetings
   - Assignees see their tasks in the normal task views
   - Tasks have status: todo → in_progress → done
   - No separate "meeting action" tracker needed

3. AT THE START of the next meeting
   - First section of every meeting note: "Open Actions from Last Meeting"
   - Embed a DataTable block filtered by:
     series = "this-series" AND status != "done"
   - Review each action:
     ✓ Done → mark complete right in the table
     → In progress → note the update, carry forward
     ✗ Blocked → discuss, reassign, or escalate
     ✗ Dropped → decide: still needed? If not, close it.

4. AFTER the meeting
   - New action items from this meeting automatically show up
     in the next meeting's carry-forward DataTable
   - The cycle continues without any manual tracking

From Meeting to Project

Sometimes a meeting produces something bigger than a one-off task — a new initiative, a multi-step project, or a workstream. Here's the escalation path:

Meeting Output → What to Create → Where It Lives

Single action item     → Task entity         → appears in My Tasks
  "Send the proposal"    assignee + due date    sidebar, task board

Related group of       → Project entity      → appears in Projects
actions                  with child tasks       sidebar, project board
  "Launch the feature"
  (needs: design, build,
   test, deploy, announce)

Major decision that    → Decision entity     → Decisions Log page
needs to be findable     with context           searchable DataTable
  "We're pivoting to
   enterprise pricing"

New recurring work     → New meeting series  → Recurring Meetings page
  "We need weekly         new sub-page          with its own carry-forward
   partner syncs"

Reference material     → Page (wiki)         → under relevant section
  "Here's the process     or sub-page of         linked from meeting note
   we agreed on"          relevant area

The key insight: every meeting output maps to an entity type that already exists in Based. You're not creating new systems — you're routing meeting outputs to the right place.

Decisions Log

One of the most valuable artifacts a team can have. "When did we decide to do X?" "Why did we choose approach A over B?" — these questions come up constantly, and the answers are buried in meeting notes nobody can find.

The Decisions Log is a DataTable over decisions/ entities. Every time a callout block tagged as a "Decision" appears in a meeting note, create a corresponding decision entity.

Decisions DataTable:
Columns: decision, context, date, meeting (link), owner, status

Status values:
  active        — currently in effect
  superseded    — replaced by a newer decision (link to it)
  revisiting    — under review, may change
  reversed      — we changed our mind (capture why)

Useful filters:
  - By tag: "pricing", "architecture", "hiring", "product"
  - By date range: "decisions made in Q1"
  - By status: "active decisions only"
  - By owner: "decisions Alice owns"

Meeting Types & Cadences

Recommended meeting cadences for a startup team:

Daily (15 min)
  Standup — What did I do, what will I do, any blockers

Weekly (30-60 min each)
  Team sync — Department-level priorities and updates
  1:1s — Manager + report, career growth + blockers
  Sprint planning — What we're building this week/sprint

Biweekly (60 min)
  Sprint retro — What went well, what to improve
  All-hands — Company-wide updates (can be monthly at <20 people)

Monthly (30-60 min)
  Investor update review — Review metrics before sending update
  Partner syncs — Check in with active partners

Quarterly (90 min)
  Board meeting — Formal governance + strategy
  OKR review — Score last quarter, set next quarter
  Strategy session — Zoom out on direction

Ad-hoc (as needed)
  Client meetings — Sales, onboarding, QBRs
  Partner meetings — Integration, co-marketing
  Incident postmortems — After outages or critical bugs
  Decision meetings — When a big call needs to be made

Making It Frictionless

The system only works if note-taking is fast. Here's how to reduce friction to near zero:

• Pre-create the page — For recurring meetings, create next week's note page at the end of this week's meeting. The carry-forward DataTable populates automatically.
• Use the slash menu — Type /task to create action items inline, no switching tools. /callout for decisions. @name for mentions.
• Template pages — Keep a template page for each meeting type. Duplicate it to start a new meeting. Agenda, structure, and carry-forward blocks come pre-built.
• Rotate the note-taker — Assign note-taking duty on a rotation. Everyone gets better at it, and nobody resents it.
• Close with 2 minutes of action review — Before ending, scroll to Action Items. Read each one out loud: "Alice ships the landing page by Friday. Bob sends the partner intro by Wednesday." Verbal confirmation from each assignee.
• Don't transcribe everything — Notes are not transcripts. Capture: key points, decisions, and actions. If someone said something insightful, paraphrase it in one line. The rest is noise.

Anti-Patterns

Common mistakes that kill meeting note effectiveness:

• Action items without assignees — "We should update the docs." Who? By when? If it doesn't have a name and a date, it won't happen.
• Action items without due dates — "Alice will look into pricing." By when? Without a deadline, it's a wish, not a commitment.
• Notes in a separate tool — If notes live in Google Docs and tasks live in Jira and decisions live in someone's head, nothing connects. Keep it in one place.
• Never reviewing previous actions — The carry-forward section at the top of every meeting exists for a reason. If you skip it, accountability disappears.
• Meetings without agendas — No agenda = no structure = no useful notes. Even a 3-bullet agenda written 10 minutes before is better than nothing.

Tips

• Use the series field on meeting entities to group recurring meetings. Filter your DataTable by series to see all standups, all 1:1s with a specific person, all retros.
• Link meeting entities to related entities using relatedEntityId. A client meeting links to the customer. A partner meeting links to the partner. This makes meetings findable from either direction.
• The Decisions Log is your institutional memory. When a new team member asks "why do we do it this way?", you can point to the exact meeting and context.
• For 1:1s, keep a "Running Topics" section at the bottom of the page. Between meetings, both people add topics as they come up. When the 1:1 starts, the agenda writes itself.
• Review the "All Meeting Actions" Kanban weekly. If the same person has 15 open actions, they're overloaded. If actions sit in "todo" for weeks, the meetings aren't working.

Related Templates

Based ships built-in templates that complement this playbook:

• Weekly Leadership Meeting — 30-min leadership pulse
• Functional Team Weekly — team-level sync template
• 1:1 Template — structured 1:1 with talking points
• Decision Log — track decisions with rationale