Comprehensive Notion Module

A comprehensive skill for building Notion-powered workflows — covering database design, page templates, relation structures, formula properties, API integration, and automation for personal productivity and team knowledge management.

When to Use This Skill

Choose Comprehensive Notion Module when you need to:

• Design Notion databases with relations and rollups
• Create page templates for recurring workflows
• Build connected databases for project management
• Integrate Notion with external tools via API
• Set up team knowledge bases with structured organization

Consider alternatives when:

• You need Obsidian vault management (use an Obsidian skill)
• You need Google Workspace integration (use a Google skill)
• You need project management beyond Notion (use a PM skill)

Quick Start

Copy
# Create a Notion database via API
claude "Create a Notion database for tracking feature requests with properties: Title, Status, Priority, Requester, Votes, and Linked Issues."

Copy
const { Client } = require("@notionhq/client");
const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function createFeatureRequestDB(parentPageId) {
  const db = await notion.databases.create({
    parent: { page_id: parentPageId },
    title: [{ type: "text", text: { content: "Feature Requests" } }],
    properties: {
      "Title": { title: {} },
      "Status": {
        select: {
          options: [
            { name: "New", color: "gray" },
            { name: "Under Review", color: "yellow" },
            { name: "Planned", color: "blue" },
            { name: "In Progress", color: "orange" },
            { name: "Shipped", color: "green" },
            { name: "Won't Do", color: "red" },
          ],
        },
      },
      "Priority": {
        select: {
          options: [
            { name: "Critical", color: "red" },
            { name: "High", color: "orange" },
            { name: "Medium", color: "yellow" },
            { name: "Low", color: "gray" },
          ],
        },
      },
      "Requester": { people: {} },
      "Votes": { number: { format: "number" } },
      "Created": { created_time: {} },
    },
  });
  console.log(`Database created: ${db.id}`);
  return db;
}

Core Concepts

Database Design Patterns

Pattern	Structure	Use Case
Simple tracker	Single DB with select properties	Todo lists, reading lists
Related databases	Multiple DBs with relations	CRM, project management
Hub-and-spoke	Central DB linked to satellite DBs	Content calendar
Kanban board	DB with board view + status select	Sprint planning
Knowledge base	Nested pages with DB backlinks	Wiki, documentation

Relations and Rollups

Copy
// Create related databases: Projects ↔ Tasks
async function createRelatedDatabases(parentPageId) {
  // Projects database
  const projectsDb = await notion.databases.create({
    parent: { page_id: parentPageId },
    title: [{ text: { content: "Projects" } }],
    properties: {
      "Name": { title: {} },
      "Status": { select: { options: [
        { name: "Active", color: "green" },
        { name: "Completed", color: "blue" },
      ]}},
      "Due Date": { date: {} },
    },
  });

  // Tasks database with relation to Projects
  const tasksDb = await notion.databases.create({
    parent: { page_id: parentPageId },
    title: [{ text: { content: "Tasks" } }],
    properties: {
      "Name": { title: {} },
      "Project": { relation: { database_id: projectsDb.id } },
      "Status": { checkbox: {} },
      "Assignee": { people: {} },
      "Due Date": { date: {} },
    },
  });

  // Add rollup to Projects (count of completed tasks)
  await notion.databases.update({
    database_id: projectsDb.id,
    properties: {
      "Tasks": { relation: { database_id: tasksDb.id } },
      "Completed Tasks": {
        rollup: {
          relation_property_name: "Tasks",
          rollup_property_name: "Status",
          function: "checked",
        },
      },
    },
  });
}

Formula Properties

Copy
## Common Notion Formulas

### Days Until Due
if(prop("Due Date") != null,
  dateBetween(prop("Due Date"), now(), "days"),
  null
)

### Priority Score (weighted)
(if(prop("Priority") == "Critical", 4,
  if(prop("Priority") == "High", 3,
    if(prop("Priority") == "Medium", 2, 1))) * prop("Votes"))

### Status Emoji
if(prop("Status") == "Shipped", "✅",
  if(prop("Status") == "In Progress", "🔵",
    if(prop("Status") == "Blocked", "🔴", "⚪")))

### Overdue Check
if(prop("Due Date") != null and prop("Due Date") < now() and !prop("Done"), "⚠️ OVERDUE", "")

Configuration

Parameter	Description	Example
api_key	Notion integration token	process.env.NOTION_API_KEY
workspace_id	Notion workspace identifier	"workspace-uuid"
parent_page	Parent page for new databases	"page-uuid"
template_style	Database template style	"kanban" / "table"

Best Practices

1. Design your database schema before creating it — Notion databases are easy to create but messy to restructure. Plan your properties, relations, and views on paper first. Changing a relation property after adding 200 records is tedious.

2. Use relations instead of duplicating data — If you store a client name as text in both a Projects and Invoices database, they'll inevitably get out of sync. Create a Clients database and relate to it from both.

3. Create saved views for common filters — Don't force users to filter manually each time. Create saved views: "My Tasks" (filtered to assignee=me), "Overdue" (filtered to due date < today), "This Sprint" (filtered to sprint property).

4. Use templates for recurring page structures — Meeting notes, project briefs, and weekly reports should use Notion templates that pre-populate the structure. This ensures consistency and saves setup time.

5. Keep the database property count under 15 — Databases with 30+ properties are overwhelming and slow. If you need that many fields, consider splitting into related databases.

Common Issues

Notion API rate limits slow down bulk operations — Notion limits API requests to ~3 per second. For bulk imports, add delays between requests and implement retry logic with exponential backoff.

Relations break when databases are moved — Moving a database to a different page can orphan relation properties. Plan your workspace structure before creating cross-database relations.

Formula properties can't reference related database fields — Notion formulas can only access properties on the current database. To compute values from related records, use rollups (sum, count, average) instead of formulas.