Best Onboarding Automation Workflow for Remote Companies Using Slack Bots and Notion Templates

Automating employee onboarding for remote teams eliminates repetitive manual tasks, ensures consistency across hires, and helps new team members feel welcomed from day one. By combining Slack bots with Notion templates, you can create a workflow that guides employees through paperwork, introduces them to company culture, and provides easy access to essential resources—all without burdening your HR or operations team.

This guide walks through building a practical onboarding automation system using Slack’s API and Notion’s database capabilities. You’ll find code examples that work with existing tools, making this approach accessible for teams with moderate technical capacity.

Why Slack + Notion for Onboarding

Slack serves as the central communication hub for most remote companies, making it the natural place to deliver onboarding tasks and notifications. Notion excels at documentation, database management, and creating structured templates that can dynamically populate based on role or department.

The combination allows you to trigger actions in Slack (sending welcome messages, assigning tasks, creating channels) while storing all onboarding documentation, checklists, and resources in Notion. This separation keeps communication responsive while maintaining a permanent record of onboarding materials.

Setting Up Your Notion Onboarding Database

Create a dedicated Notion database to track each new hire’s progress through onboarding. This database becomes the source of truth for task completion and status.

// Notion API: Creating an onboarding database entry
const { Client } = require('@notionhq/client');
const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function createOnboardingEntry(employee) {
  const response = await notion.databases.create({
    parent: { database_id: process.env.NOTION_ONBOARDING_DB },
    properties: {
      'Name': { title: [{ text: { content: employee.name } }] },
      'Email': { email: employee.email },
      'Role': { select: { name: employee.role } },
      'Department': { select: { name: employee.department } },
      'Start Date': { date: { start: employee.startDate } },
      'Status': { status: { name: 'Not Started' } },
      'Slack Channel': { rich_text: [{ text: { content: employee.slackChannel } }] }
    }
  });
  return response;
}

This database should include properties for tracking document completion, training progress, and milestone achievements. Add a “Tasks” relation that connects to individual task items in a separate database.

Building the Slack Bot Workflow

Your Slack bot handles real-time communication and task delivery. We recommend using Bolt.js (Slack’s official Node.js framework) for building interactive bot experiences.

Welcome Message and Channel Creation

When HR adds a new employee to your system, the bot automatically creates a dedicated onboarding channel and sends a personalized welcome message.

// Slack Bot: Auto-create onboarding channel and welcome message
const { App } = require('@slack/bolt');
const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET
});

async function onboardEmployee(employee) {
  // Create dedicated onboarding channel
  const channel = await app.client.conversations.create({
    name: `onboarding-${employee.firstName.toLowerCase()}-${employee.lastName.toLowerCase()}`,
    is_private: false
  });

  // Invite the new hire
  await app.client.conversations.invite({
    channel: channel.channel.id,
    users: employee.slackUserId
  });

  // Send welcome message with onboarding checklist
  await app.client.chat.postMessage({
    channel: channel.channel.id,
    text: `Welcome to the team, ${employee.firstName}! 🎉`,
    blocks: [
      {
        type: 'header',
        text: { type: 'plain_text', text: `Welcome, ${employee.firstName}!` }
      },
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `We're excited to have you join us as *${employee.role}*. Here's your onboarding checklist:`
        }
      },
      {
        type: 'actions',
        elements: [
          {
            type: 'button',
            text: { type: 'plain_text', text: 'View Notion Checklist' },
            url: employee.notionPageUrl,
            style: 'primary'
          }
        ]
      }
    ]
  });
}

Scheduled Check-ins and Reminders

Automate follow-up messages at key intervals—day one, week one, and month one—to ensure new hires stay on track.

// Slack Bot: Scheduled check-in messages using scheduledMessages API
async function scheduleCheckIn(client, channelId, employee, dayNumber) {
  const checkInTimes = {
    1: 'Day 1: Getting Started',
    7: 'Week 1: Settling In',
    30: 'Month 1: Feedback Session'
  };

  const message = {
    channel: channelId,
    text: `Hi ${employee.firstName}! How's your onboarding going?`,
    blocks: [
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*${checkInTimes[dayNumber]} Check-in*\n\nHow are you feeling about your onboarding? Any blockers?`
        }
      },
      {
        type: 'actions',
        elements: [
          {
            type: 'button',
            text: { type: 'plain_text', text: '✅ All Good' },
            action_id: `checkin_ok_${dayNumber}`,
            value: employee.id
          },
          {
            type: 'button',
            text: { type: 'plain_text', text: '⚠️ Need Help' },
            action_id: `checkin_help_${dayNumber}`,
            value: employee.id
          }
        ]
      }
    ]
  };

  // Schedule for appropriate time (simplified - use cron in production)
  return client.chat.scheduleMessage({
    ...message,
    post_at: calculateFutureTimestamp(dayNumber)
  });
}

Integrating Notion Templates

Notion templates provide structured content for each onboarding phase. Create templates for different roles and departments, then dynamically assign them based on the new hire’s role.

Template Structure

Organize your Notion onboarding template with these key sections:

Welcome & Company Overview — Mission, values, and team structure
Role-Specific Setup — Tools, access, and first-week priorities
Documentation Checklist — Tax forms, contracts, benefits enrollment
Training Modules — Product knowledge, security practices, processes
Team Introductions — Key contacts, meeting rhythms, communication norms

// Notion API: Duplicate template for new employee
async function createEmployeeNotionPage(employee) {
  const templateId = getTemplateForRole(employee.role);

  const response = await notion.pages.create({
    parent: { page_id: process.env.NOTION_ONBOARDING_ROOT },
    properties: {
      'Name': { title: [{ text: { content: `${employee.name} - Onboarding` } }] },
      'Employee': { relation: [{ id: employee.notionDatabaseId }] }
    },
    children: [
      {
        object: 'block',
        type: 'heading_2',
        heading_2: {
          rich_text: [{ text: { content: 'Welcome to the Team!' } }]
        }
      },
      {
        object: 'block',
        type: 'paragraph',
        paragraph: {
          rich_text: [{ text: { content: `Hi ${employee.firstName}, welcome aboard!` } }]
        }
      }
    ]
  });

  return response;
}

Connecting the Pieces

The glue connecting Slack and Notion is a simple automation layer that listens for events in either system and triggers corresponding actions in the other.

// Main automation: Sync Notion task completion to Slack
app.action('complete_task', async ({ body, ack, client }) => {
  await ack();

  const taskId = body.actions[0].value;
  const task = await getNotionTask(taskId);

  // Update Slack message to reflect completion
  await client.chat.update({
    channel: task.slackChannelId,
    ts: task.slackMessageTs,
    text: `✅ ${task.title} - Completed`,
    blocks: [
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `✅ *${task.title}* - Completed by ${task.completedBy}`
        }
      }
    ]
  });

  // Trigger next task if dependent
  if (task.nextTaskId) {
    await notifySlackChannel(task.nextTaskId);
  }
});

Measuring Onboarding Success

Track key metrics to continuously improve your workflow:

Time to Productivity: Days from start to first meaningful contribution
Check-in Response Rate: How quickly new hires respond to automated messages
Task Completion Time: Average time to complete each onboarding milestone
New Hire Satisfaction: Weekly pulse survey scores during onboarding

Store these metrics in Notion alongside employee records, creating a data-driven approach to onboarding optimization.

Built by theluckystrike — More at zovo.one