Collaboration Tool

Notion

Overview

Notion is an all-in-one workspace and productivity tool that integrates documents, databases, and project management. It provides real-time editing, commenting, and task management features with rich templates and high customizability. Experiencing rapid growth for individuals and small teams, it enhanced chart features and Notion AI in 2024, introducing form functionality, website builder, and automation features. Differentiated with rich community templates and customizability, it's particularly popular in creative industries.

Details

Notion 2025 edition has evolved as a comprehensive collaboration platform supporting everything from personal to enterprise use. It enables teams to build unique workflows by freely combining pages, databases, blocks, and templates. It supports external system integration through Notion API and SDK, advanced data processing with Formula features, and complex database design with Relation functionality. Major 2024 updates include visual chart features, Notion Forms (form builder), Notion Sites (website creation), automation features (Automations), and significant AI assistant functionality enhancements. It optimizes team collaboration through version control, permission settings, and commenting features, while providing location-independent work environments through real-time synchronization and offline support.

Key Features

• Block-based Editing: Freely combine text, images, tables, code, formulas, and more
• Powerful Databases: Relation, Formula, filter, and sort functionality
• Real-time Collaboration: Simultaneous editing, commenting, and mention features
• Rich Templates: Project management, note-taking, CRM, and more
• API/SDK Integration: Programmatic access with JavaScript, Python, etc.
• AI Features: Automatic text generation, summarization, translation, data analysis support

Advantages and Disadvantages

Advantages

• Infinite customization possibilities through flexible block structure
• Unique approach integrating databases and documents
• Rich community templates and marketplace
• Intuitive and beautiful UI/UX with responsive design
• Powerful API/SDK for external system integration
• Real-time synchronization and cross-platform support
• AI features for productivity enhancement and content generation support
• Tiered pricing plans supporting small to large organizations

Disadvantages

• Initial learning cost and setup time due to high functionality
• Performance limitations when processing large amounts of data
• Offline functionality constraints (internet connection required)
• Usability challenges when designing complex workflows
• Limited enterprise-level security features
• Constraints in data export functionality and migration difficulty
• Advanced automation features only in paid plans
• Issues with Japanese search functionality and full-text search accuracy

Reference Links

• Notion Official Site
• Notion API Documentation
• Notion JavaScript SDK
• Notion Python SDK
• Notion Help Center
• Notion Templates

Usage Examples

Basic Setup and Workspace Creation

# Notion basic setup
# 1. Account creation: https://www.notion.so/signup
# 2. Workspace creation
# 3. API integration setup: https://www.notion.so/my-integrations
# 4. Database and page permission configuration

# Basic workspace structure example
Team Workspace/
├── Project Management/
│   ├── Task Database
│   ├── Project Roadmap
│   └── Sprint Planning
├── Knowledge Base/
│   ├── Technical Documentation
│   ├── FAQ
│   └── Process Management
└── Team Information/
    ├── Member Information
    ├── 1-on-1 Records
    └── Goal Management (OKR)

Notion API Basic Operations

// Notion JavaScript SDK basic configuration
const { Client } = require('@notionhq/client');

// Initialize Notion client
const notion = new Client({
  auth: process.env.NOTION_TOKEN, // Integration token
});

class NotionManager {
  constructor(token) {
    this.notion = new Client({ auth: token });
  }

  // Get page information
  async getPage(pageId) {
    try {
      const response = await this.notion.pages.retrieve({
        page_id: pageId,
      });
      return response;
    } catch (error) {
      console.error('Page retrieval error:', error);
      throw error;
    }
  }

  // Create new page
  async createPage(parentId, title, content) {
    try {
      const response = await this.notion.pages.create({
        parent: {
          type: 'page_id',
          page_id: parentId,
        },
        properties: {
          title: {
            title: [
              {
                text: {
                  content: title,
                },
              },
            ],
          },
        },
        children: content, // Array of blocks
      });
      return response;
    } catch (error) {
      console.error('Page creation error:', error);
      throw error;
    }
  }

  // Database query
  async queryDatabase(databaseId, filter = {}, sorts = []) {
    try {
      const response = await this.notion.databases.query({
        database_id: databaseId,
        filter: filter,
        sorts: sorts,
      });
      return response.results;
    } catch (error) {
      console.error('Database query error:', error);
      throw error;
    }
  }

  // Create database page
  async createDatabasePage(databaseId, properties) {
    try {
      const response = await this.notion.pages.create({
        parent: {
          database_id: databaseId,
        },
        properties: properties,
      });
      return response;
    } catch (error) {
      console.error('Database page creation error:', error);
      throw error;
    }
  }

  // Get blocks (page content)
  async getBlocks(blockId) {
    try {
      const response = await this.notion.blocks.children.list({
        block_id: blockId,
      });
      return response.results;
    } catch (error) {
      console.error('Block retrieval error:', error);
      throw error;
    }
  }

  // Append blocks
  async appendBlocks(blockId, children) {
    try {
      const response = await this.notion.blocks.children.append({
        block_id: blockId,
        children: children,
      });
      return response;
    } catch (error) {
      console.error('Block append error:', error);
      throw error;
    }
  }
}

// Usage example
const notionManager = new NotionManager(process.env.NOTION_TOKEN);

// Project task creation example
async function createProjectTask() {
  const taskProperties = {
    'Task Name': {
      title: [
        {
          text: {
            content: 'API Integration Implementation',
          },
        },
      ],
    },
    'Status': {
      select: {
        name: 'In Progress',
      },
    },
    'Priority': {
      select: {
        name: 'High',
      },
    },
    'Assignee': {
      people: [
        {
          id: 'user-id-here',
        },
      ],
    },
    'Due Date': {
      date: {
        start: '2025-01-15',
      },
    },
    'Estimated Hours': {
      number: 8,
    },
  };

  const newTask = await notionManager.createDatabasePage(
    'database-id-here',
    taskProperties
  );
  
  console.log('New task created:', newTask.url);
  return newTask;
}

Advanced Database Operations and Filtering

// Complex database query examples
class AdvancedNotionQueries {
  constructor(notion) {
    this.notion = notion;
  }

  // Get upcoming tasks
  async getUpcomingTasks(databaseId, days = 7) {
    const today = new Date();
    const targetDate = new Date();
    targetDate.setDate(today.getDate() + days);

    const filter = {
      and: [
        {
          property: 'Due Date',
          date: {
            on_or_before: targetDate.toISOString().split('T')[0],
          },
        },
        {
          property: 'Status',
          select: {
            does_not_equal: 'Completed',
          },
        },
      ],
    };

    const sorts = [
      {
        property: 'Due Date',
        direction: 'ascending',
      },
      {
        property: 'Priority',
        direction: 'descending',
      },
    ];

    return await this.notion.databases.query({
      database_id: databaseId,
      filter,
      sorts,
    });
  }

  // Task aggregation by team member
  async getTasksByAssignee(databaseId) {
    const allTasks = await this.notion.databases.query({
      database_id: databaseId,
    });

    const tasksByAssignee = {};
    
    allTasks.results.forEach(task => {
      const assignees = task.properties['Assignee']?.people || [];
      const status = task.properties['Status']?.select?.name || 'Unset';
      
      assignees.forEach(assignee => {
        const assigneeId = assignee.id;
        if (!tasksByAssignee[assigneeId]) {
          tasksByAssignee[assigneeId] = {
            name: assignee.name,
            tasks: { total: 0, completed: 0, inProgress: 0, pending: 0 },
          };
        }
        
        tasksByAssignee[assigneeId].tasks.total++;
        
        switch (status) {
          case 'Completed':
            tasksByAssignee[assigneeId].tasks.completed++;
            break;
          case 'In Progress':
            tasksByAssignee[assigneeId].tasks.inProgress++;
            break;
          default:
            tasksByAssignee[assigneeId].tasks.pending++;
        }
      });
    });

    return tasksByAssignee;
  }

  // Generate project progress report
  async generateProjectReport(databaseId, projectProperty = 'Project') {
    const tasks = await this.notion.databases.query({
      database_id: databaseId,
    });

    const projectStats = {};

    tasks.results.forEach(task => {
      const project = task.properties[projectProperty]?.select?.name || 'Uncategorized';
      const status = task.properties['Status']?.select?.name || 'Unset';
      const estimatedHours = task.properties['Estimated Hours']?.number || 0;

      if (!projectStats[project]) {
        projectStats[project] = {
          total: 0,
          completed: 0,
          inProgress: 0,
          pending: 0,
          totalHours: 0,
          completedHours: 0,
        };
      }

      projectStats[project].total++;
      projectStats[project].totalHours += estimatedHours;

      if (status === 'Completed') {
        projectStats[project].completed++;
        projectStats[project].completedHours += estimatedHours;
      } else if (status === 'In Progress') {
        projectStats[project].inProgress++;
      } else {
        projectStats[project].pending++;
      }
    });

    // Calculate completion rates
    Object.keys(projectStats).forEach(project => {
      const stats = projectStats[project];
      stats.completionRate = stats.total > 0 ? (stats.completed / stats.total * 100).toFixed(1) : 0;
      stats.hoursCompletionRate = stats.totalHours > 0 ? (stats.completedHours / stats.totalHours * 100).toFixed(1) : 0;
    });

    return projectStats;
  }
}

// Usage example
const advancedQueries = new AdvancedNotionQueries(notion);

// Get tasks due within 7 days
const upcomingTasks = await advancedQueries.getUpcomingTasks('task-database-id');
console.log('Upcoming tasks:', upcomingTasks.results.length);

// Generate team progress report
const projectReport = await advancedQueries.generateProjectReport('task-database-id');
console.log('Project progress:', projectReport);

Block Operations and Content Management

// Block operations helper class
class NotionBlockManager {
  constructor(notion) {
    this.notion = notion;
  }

  // Create rich text block
  createTextBlock(content, style = 'paragraph') {
    return {
      object: 'block',
      type: style,
      [style]: {
        rich_text: [
          {
            type: 'text',
            text: {
              content: content,
            },
          },
        ],
      },
    };
  }

  // Create header block
  createHeaderBlock(content, level = 1) {
    const headerType = `heading_${level}`;
    return {
      object: 'block',
      type: headerType,
      [headerType]: {
        rich_text: [
          {
            type: 'text',
            text: {
              content: content,
            },
          },
        ],
      },
    };
  }

  // Create code block
  createCodeBlock(code, language = 'javascript') {
    return {
      object: 'block',
      type: 'code',
      code: {
        caption: [],
        rich_text: [
          {
            type: 'text',
            text: {
              content: code,
            },
          },
        ],
        language: language,
      },
    };
  }

  // Create checklist block
  createChecklistBlock(items) {
    return items.map(item => ({
      object: 'block',
      type: 'to_do',
      to_do: {
        rich_text: [
          {
            type: 'text',
            text: {
              content: item.text,
            },
          },
        ],
        checked: item.checked || false,
      },
    }));
  }

  // Create table block
  createTableBlock(headers, rows) {
    const tableRows = [headers, ...rows].map(row => ({
      type: 'table_row',
      table_row: {
        cells: row.map(cell => [
          {
            type: 'text',
            text: {
              content: cell.toString(),
            },
          },
        ]),
      },
    }));

    return {
      object: 'block',
      type: 'table',
      table: {
        table_width: headers.length,
        has_column_header: true,
        has_row_header: false,
        children: tableRows,
      },
    };
  }

  // Add multiple blocks to page
  async addMultipleBlocks(pageId, blocks) {
    try {
      const response = await this.notion.blocks.children.append({
        block_id: pageId,
        children: blocks,
      });
      return response;
    } catch (error) {
      console.error('Block addition error:', error);
      throw error;
    }
  }

  // Create meeting minutes template
  async createMeetingMinutes(pageId, meetingData) {
    const blocks = [
      this.createHeaderBlock('Meeting Minutes', 1),
      this.createTextBlock(`Date: ${meetingData.date}`),
      this.createTextBlock(`Attendees: ${meetingData.attendees.join(', ')}`),
      
      this.createHeaderBlock('Agenda', 2),
      ...meetingData.agenda.map(item => this.createTextBlock(`• ${item}`)),
      
      this.createHeaderBlock('Decisions', 2),
      ...meetingData.decisions.map(item => this.createTextBlock(`• ${item}`)),
      
      this.createHeaderBlock('Action Items', 2),
      ...this.createChecklistBlock(meetingData.actionItems),
    ];

    return await this.addMultipleBlocks(pageId, blocks);
  }

  // Create project specification template
  async createProjectSpec(pageId, projectData) {
    const blocks = [
      this.createHeaderBlock(projectData.title, 1),
      
      this.createHeaderBlock('Overview', 2),
      this.createTextBlock(projectData.overview),
      
      this.createHeaderBlock('Purpose', 2),
      this.createTextBlock(projectData.purpose),
      
      this.createHeaderBlock('Tech Stack', 2),
      this.createCodeBlock(JSON.stringify(projectData.techStack, null, 2), 'json'),
      
      this.createHeaderBlock('Milestones', 2),
      this.createTableBlock(
        ['Milestone', 'Deadline', 'Assignee', 'Status'],
        projectData.milestones.map(m => [m.name, m.deadline, m.assignee, m.status])
      ),
    ];

    return await this.addMultipleBlocks(pageId, blocks);
  }
}

// Usage example
const blockManager = new NotionBlockManager(notion);

// Automatic meeting minutes generation
const meetingData = {
  date: '2025-01-08 10:00',
  attendees: ['Tanaka', 'Sato', 'Suzuki'],
  agenda: ['Project progress review', 'Next phase planning', 'Issue identification'],
  decisions: ['Implement API design changes', 'Decide next month release date'],
  actionItems: [
    { text: 'Update API design document', checked: false },
    { text: 'Create test plan', checked: false },
    { text: 'Report progress to client', checked: true },
  ],
};

await blockManager.createMeetingMinutes('page-id-here', meetingData);

Notion Automation and Workflow Integration

// Notion automation integration system
class NotionAutomation {
  constructor(notion) {
    this.notion = notion;
  }

  // Slack integration (using Webhook)
  async sendSlackNotification(webhookUrl, notionPageUrl, message) {
    const payload = {
      text: `Notion Update Notification: ${message}`,
      attachments: [
        {
          color: 'good',
          fields: [
            {
              title: 'Notion Page',
              value: `<${notionPageUrl}|Open Page>`,
              short: false,
            },
          ],
        },
      ],
    };

    try {
      const response = await fetch(webhookUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload),
      });

      if (!response.ok) {
        throw new Error(`Slack notification failed: ${response.statusText}`);
      }

      return await response.json();
    } catch (error) {
      console.error('Slack notification error:', error);
      throw error;
    }
  }

  // GitHub Issues synchronization
  async syncWithGitHub(githubToken, repoOwner, repoName, notionDatabaseId) {
    // Get issues from GitHub
    const githubResponse = await fetch(
      `https://api.github.com/repos/${repoOwner}/${repoName}/issues`,
      {
        headers: {
          Authorization: `token ${githubToken}`,
          Accept: 'application/vnd.github.v3+json',
        },
      }
    );

    const githubIssues = await githubResponse.json();

    // Get existing tasks from Notion database
    const notionTasks = await this.notion.databases.query({
      database_id: notionDatabaseId,
    });

    const existingIssueNumbers = new Set(
      notionTasks.results
        .map(task => task.properties['GitHub Issue']?.number)
        .filter(Boolean)
    );

    // Sync new Issues to Notion
    for (const issue of githubIssues) {
      if (!existingIssueNumbers.has(issue.number)) {
        await this.createTaskFromGitHubIssue(notionDatabaseId, issue);
      }
    }
  }

  async createTaskFromGitHubIssue(databaseId, issue) {
    const properties = {
      'Task Name': {
        title: [
          {
            text: {
              content: issue.title,
            },
          },
        ],
      },
      'GitHub Issue': {
        number: issue.number,
      },
      'URL': {
        url: issue.html_url,
      },
      'Labels': {
        multi_select: issue.labels.map(label => ({ name: label.name })),
      },
      'Status': {
        select: {
          name: issue.state === 'open' ? 'To Do' : 'Completed',
        },
      },
      'Assignee': issue.assignee ? {
        people: [
          {
            name: issue.assignee.login,
          },
        ],
      } : {},
    };

    return await this.notion.pages.create({
      parent: { database_id: databaseId },
      properties,
    });
  }

  // Generate periodic reports
  async generateWeeklyReport(databaseId) {
    const oneWeekAgo = new Date();
    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);

    const filter = {
      property: 'Last Updated',
      date: {
        on_or_after: oneWeekAgo.toISOString().split('T')[0],
      },
    };

    const recentTasks = await this.notion.databases.query({
      database_id: databaseId,
      filter,
    });

    const completedTasks = recentTasks.results.filter(
      task => task.properties['Status']?.select?.name === 'Completed'
    );

    const inProgressTasks = recentTasks.results.filter(
      task => task.properties['Status']?.select?.name === 'In Progress'
    );

    const report = {
      week: `${oneWeekAgo.toLocaleDateString()} - ${new Date().toLocaleDateString()}`,
      totalTasks: recentTasks.results.length,
      completedTasks: completedTasks.length,
      inProgressTasks: inProgressTasks.length,
      completionRate: ((completedTasks.length / recentTasks.results.length) * 100).toFixed(1),
      tasks: {
        completed: completedTasks.map(task => ({
          title: task.properties['Task Name']?.title[0]?.text?.content,
          assignee: task.properties['Assignee']?.people[0]?.name,
        })),
        inProgress: inProgressTasks.map(task => ({
          title: task.properties['Task Name']?.title[0]?.text?.content,
          assignee: task.properties['Assignee']?.people[0]?.name,
        })),
      },
    };

    return report;
  }
}

// Usage example
const automation = new NotionAutomation(notion);

// Weekly report generation and Slack notification
async function weeklyReportWorkflow() {
  const report = await automation.generateWeeklyReport('task-database-id');
  
  const message = `Weekly Progress Report
Completed Tasks: ${report.completedTasks} items
In Progress Tasks: ${report.inProgressTasks} items
Completion Rate: ${report.completionRate}%`;

  await automation.sendSlackNotification(
    process.env.SLACK_WEBHOOK_URL,
    'https://notion.so/your-workspace/reports',
    message
  );
}

// GitHub Issues synchronization
async function githubSyncWorkflow() {
  await automation.syncWithGitHub(
    process.env.GITHUB_TOKEN,
    'your-org',
    'your-repo',
    'notion-database-id'
  );
}

// Periodic execution setup (cron example)
// 0 9 * * 1 (Execute every Monday at 9am)
setInterval(weeklyReportWorkflow, 7 * 24 * 60 * 60 * 1000); // Every 7 days