How to Automate Employee Onboarding with Google Workspace

A new employee joins your business. Someone needs to collect their details, prepare documents, arrange orientation, notify the right people, share relevant resources and track what is still outstanding.

In a small organisation, these tasks are often handled through a mixture of email threads, spreadsheets, chat messages and memory. The process may work when one person manages everything. It becomes harder to maintain as the team grows or several people are involved in onboarding.

Google Workspace can help you create a more consistent process using tools your organisation may already have: Google Forms, Sheets, Drive, Calendar and Google Apps Script.

This guide explains how to design an employee onboarding workflow, what to automate and where human approval should remain part of the process.

What an automated onboarding workflow should achieve

Automation should not mean sending every new employee the same collection of links without context. A useful workflow makes sure the right information reaches the right people at the right time, while giving the organisation a clear record of progress.

A well-designed onboarding process should help you:

• Collect consistent information from new hires.
• Notify the people responsible for preparing their onboarding.
• Track required documents and activities.
• Schedule orientation and important first-week meetings.
• Provide access to the correct company resources.
• Identify outstanding tasks before the employee's start date.

Before building anything, map the current process. Identify who initiates onboarding, who approves it, which information is required and what must be completed before the employee starts.

Step 1: Map the process before choosing the tools

Start with the stages of onboarding, not with an automation script.

A simple workflow might look like this:

Decide which actions can happen automatically and which require a person to review or approve them.

For example, a form submission can notify HR automatically. It should not automatically grant access to sensitive company systems without an authorised approval step.

Step 2: Use Google Forms to collect onboarding information

Create a Google Form for the information your organisation genuinely needs.

Possible fields include:

• Employee's full name.
• Personal or preferred contact email, where appropriate.
• Job title and department.
• Reporting manager.
• Confirmed start date.
• Work location or working arrangement.
• Equipment or access requirements.
• Any required onboarding notes.

Avoid collecting unnecessary sensitive personal information through a general form. Decide who can access responses and how long the information needs to be retained.

In the form settings, review who can respond and whether respondents need to sign in. The right configuration depends on whether the form is completed by internal staff, the new hire or both.

Link the form to a Google Sheet so authorised HR or operations staff can review submissions in one place.

When the form is ready, connect it to a Google Sheet so authorised HR or operations staff can review submissions in one place.

Step 3: Turn the response Sheet into an onboarding tracker

The linked Google Sheet becomes the operational tracker. It should show the status of each onboarding activity, not just store the employee's submitted details.

Consider these columns:

Use dropdowns for status fields such as Not started, In progress, Waiting for approval, Completed and Not applicable. Consistent values make filtering and reporting easier.

Keep personal information in a restricted file. If a wider team only needs to see task status, create a separate operational view that does not expose unnecessary employee details.

Use Google Sheets dropdowns for consistent status values. This makes filtering, updating and reporting easier.

Step 4: Create a dedicated Drive folder structure

Prepare a consistent location for onboarding materials.

For example:

People Operations
└── Onboarding
    └── 2026
        └── Employee ID - Employee Name
            ├── 01 - Welcome and Orientation
            ├── 02 - Role and Team Resources
            ├── 03 - Policies and Procedures
            └── 04 - Completed Onboarding Records

The example is a starting point, not a universal folder structure. Adapt it to your organisation's records policy.

Store reusable documents, such as welcome guides and orientation agendas, in a controlled template location. Create an employee-specific folder only when the onboarding request has been approved.

Be deliberate about permissions. An employee's folder may contain confidential information, so do not assume that every member of the organisation should have access. Consider whether a restricted Shared Drive or another approved storage location is appropriate for the records.

Choose a storage location and permission structure that match your organisation’s records policy. Restrict access to confidential employee information.

Step 5: Use Google Calendar to coordinate the first week

A new employee's first week often includes several meetings: orientation, a manager introduction, team introductions, role training and policy briefings.

Create a standard first-week schedule that can be adapted for each role.

For example:

Use Calendar invitations to make meeting ownership and timing clear. Where the same sessions apply to every new hire, maintain reusable event details or templates.

Do not automatically invite a new employee to every internal meeting. Confirm that each event is relevant and that the attendee list is appropriate.

Use reusable event details or templates to reduce repetitive scheduling, while checking that each invitation is relevant to the employee.

Step 6: Automate notifications and follow-ups with Apps Script

Once the process and tracker are clear, Google Apps Script can connect the steps that would otherwise require someone to send repeated emails manually.

In this example, the automation does two things:

1. When a new Google Form response is submitted, it adds the employee's details to an onboarding tracker and emails the HR contact and task owner.
2. Every morning, it checks the tracker for follow-ups that are due. If an onboarding item is still open, it emails the assigned owner and records the date the reminder was sent.

The script sends notifications only. It does not create employee accounts, grant Drive access or approve onboarding requests. Keep those decisions with an authorised person.

Before you start

You need:

• A Google Form that collects onboarding details.
• A Google Sheet linked to that Form as its response destination.
• An additional tab in the same spreadsheet named Onboarding Tracker.
• Permission to edit the spreadsheet and create Apps Script triggers.

In the Form, create questions with these exact titles so the script can read the answers:

• Employee name
• Department
• Job title
• Manager
• Confirmed start date
• Assigned owner
• Owner email
• Follow-up date

The Owner email field should contain the work email address of the person responsible for the next onboarding action. The Follow-up date is the date by which that action should be checked.

In the Onboarding Tracker tab, put these headings in row 1. The spelling must match:

You can add other columns after these, but do not rename the headings used by the script.

The Google Apps Script

Open the linked response spreadsheet. Select Extensions → Apps Script. Delete the sample function in the editor and paste the code below.

Before saving, replace hr@example.com with the actual work email address that should receive onboarding notifications. You can also change the spreadsheet tab name in the configuration if yours is different.

const CONFIG = {
  TRACKER_SHEET_NAME: 'Onboarding Tracker',
  HR_EMAIL: 'hr@example.com',
  COMPLETED_STATUS: 'Completed',
  REMINDER_HOUR: 8
};

/**
 * Runs when a new Google Form response is submitted.
 * Adds a row to the tracker and notifies HR and the assigned owner.
 */
function onboardingFormSubmitted(e) {
  if (!e || !e.namedValues) {
    throw new Error(
      'This function must run from the spreadsheet Form-submit trigger. Do not run it manually.'
    );
  }

  const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
  const tracker = spreadsheet.getSheetByName(CONFIG.TRACKER_SHEET_NAME);

  if (!tracker) {
    throw new Error(
      'The tab "' + CONFIG.TRACKER_SHEET_NAME + '" was not found.'
    );
  }

  const answers = e.namedValues;
  const getAnswer = (questionTitle) => {
    const answer = answers[questionTitle];
    return answer && answer.length ? String(answer[0]).trim() : '';
  };

  const employeeName = getAnswer('Employee name');
  const department = getAnswer('Department');
  const jobTitle = getAnswer('Job title');
  const manager = getAnswer('Manager');
  const startDateText = getAnswer('Confirmed start date');
  const assignedOwner = getAnswer('Assigned owner');
  const ownerEmail = getAnswer('Owner email');
  const followUpDateText = getAnswer('Follow-up date');

  if (!employeeName) {
    throw new Error(
      'The Form response is missing the "Employee name" answer. Check the question title.'
    );
  }

  const headers = getHeaderMap_(tracker);
  const row = new Array(tracker.getLastColumn()).fill('');

  setCell_(row, headers, 'Employee name', employeeName);
  setCell_(row, headers, 'Department', department);
  setCell_(row, headers, 'Job title', jobTitle);
  setCell_(row, headers, 'Manager', manager);
  setCell_(row, headers, 'Start date', parseDate_(startDateText));
  setCell_(row, headers, 'Form received', new Date());
  setCell_(row, headers, 'Onboarding status', 'Not started');
  setCell_(row, headers, 'Assigned owner', assignedOwner);
  setCell_(row, headers, 'Owner email', ownerEmail);
  setCell_(row, headers, 'Follow-up date', parseDate_(followUpDateText));
  setCell_(row, headers, 'Last reminder sent', '');

  tracker.appendRow(row);

  const recipients = [CONFIG.HR_EMAIL, ownerEmail]
    .map(email => String(email || '').trim())
    .filter((email, index, list) =>
      email && list.indexOf(email) === index
    );

  if (recipients.length) {
    const subject = 'New employee onboarding: ' + employeeName;
    const body =
      'A new onboarding request has been submitted.\n\n' +
      'Employee: ' + employeeName + '\n' +
      'Department: ' + department + '\n' +
      'Job title: ' + jobTitle + '\n' +
      'Manager: ' + manager + '\n' +
      'Start date: ' + startDateText + '\n' +
      'Assigned owner: ' + assignedOwner + '\n' +
      'Follow-up date: ' + followUpDateText + '\n\n' +
      'Please review the request and complete the appropriate next steps.\n\n' +
      'Open the onboarding tracker: ' + spreadsheet.getUrl();

    MailApp.sendEmail({
      to: recipients.join(','),
      subject: subject,
      body: body
    });
  }
}

/**
 * Runs once each morning.
 * Emails owners when a follow-up date is due or overdue.
 * Sends no more than one reminder per row per calendar day.
 */
function sendOnboardingReminders() {
  const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
  const tracker = spreadsheet.getSheetByName(CONFIG.TRACKER_SHEET_NAME);

  if (!tracker || tracker.getLastRow() < 2) {
    return;
  }

  const values = tracker.getDataRange().getValues();
  const headers = getHeaderMap_(tracker);
  const today = new Date();
  today.setHours(0, 0, 0, 0);

  const required = [
    'Employee name',
    'Onboarding status',
    'Assigned owner',
    'Owner email',
    'Follow-up date',
    'Last reminder sent'
  ];

  required.forEach(header => {
    if (headers[header] === undefined) {
      throw new Error('Missing tracker column: ' + header);
    }
  });

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const employeeName = row[headers['Employee name']];
    const status = String(row[headers['Onboarding status']] || '').trim();
    const ownerName = row[headers['Assigned owner']];
    const ownerEmail = String(row[headers['Owner email']] || '').trim();
    const followUpDate = row[headers['Follow-up date']];
    const lastReminder = row[headers['Last reminder sent']];

    if (!employeeName || !ownerEmail || !(followUpDate instanceof Date)) {
      continue;
    }

    if (status.toLowerCase() === CONFIG.COMPLETED_STATUS.toLowerCase()) {
      continue;
    }

    const dueDate = new Date(followUpDate);
    dueDate.setHours(0, 0, 0, 0);

    if (dueDate > today) {
      continue;
    }

    if (lastReminder instanceof Date) {
      const lastReminderDate = new Date(lastReminder);
      lastReminderDate.setHours(0, 0, 0, 0);
      if (lastReminderDate.getTime() === today.getTime()) {
        continue;
      }
    }

    const subject = 'Onboarding follow-up due: ' + employeeName;
    const body =
      'Hello' + (ownerName ? ' ' + ownerName : '') + ',\n\n' +
      'This is a reminder that an onboarding follow-up is due for ' +
      employeeName + '.\n\n' +
      'Current status: ' + (status || 'Not specified') + '\n' +
      'Follow-up date: ' +
      Utilities.formatDate(
        dueDate,
        spreadsheet.getSpreadsheetTimeZone(),
        'dd MMM yyyy'
      ) + '\n\n' +
      'Please review the tracker and update the status when the task is complete.\n\n' +
      'Open the onboarding tracker: ' + spreadsheet.getUrl();

    MailApp.sendEmail({
      to: ownerEmail,
      subject: subject,
      body: body
    });

    tracker
      .getRange(i + 1, headers['Last reminder sent'] + 1)
      .setValue(new Date());
  }
}

/**
 * Creates a map of tracker heading names to zero-based column positions.
 */
function getHeaderMap_(sheet) {
  const headerRow = sheet
    .getRange(1, 1, 1, sheet.getLastColumn())
    .getValues()[0];

  const map = {};
  headerRow.forEach((heading, index) => {
    const name = String(heading || '').trim();
    if (name) map[name] = index;
  });

  return map;
}

/**
 * Writes a value into the correct position in the new tracker row.
 */
function setCell_(row, headers, heading, value) {
  if (headers[heading] === undefined) {
    throw new Error('Missing tracker column: ' + heading);
  }
  row[headers[heading]] = value;
}

/**
 * Converts a date answer into a spreadsheet date value.
 */
function parseDate_(dateText) {
  if (!dateText) return '';

  const date = new Date(dateText);
  if (isNaN(date.getTime())) {
    throw new Error('Could not read this date: ' + dateText);
  }
  return date;
}

Connect the script to Google Forms and Sheets

1. Save the project. Click the Save icon and give the Apps Script project a clear name, such as Employee Onboarding Notifications.

2. Create the Form-submit trigger. In Apps Script, open Triggers from the left sidebar and click Add Trigger. Choose:

• Function to run: onboardingFormSubmitted
• Deployment: Head
• Event source: From spreadsheet
• Event type: On form submit

Save the trigger.

3. Create the daily reminder trigger. Click Add Trigger again and choose:

• Function to run: sendOnboardingReminders
• Deployment: Head
• Event source: Time-driven
• Type of time-based trigger: Day timer
• Time of day: choose the morning window you prefer, such as 8 a.m. to 9 a.m.

Save the trigger. Google runs time-driven triggers within the selected time window, not necessarily at the exact minute.

4. Authorise the script. The first time a trigger runs, Google may ask the account that owns the script to authorise access to the spreadsheet and permission to send email. Review the requested permissions and approve them only if you trust the script and understand what it does. The triggers run under the account that created them, so use an organisation-controlled account with appropriate access and a continuity plan.

5. Test with fictional information. Submit the Form using a test employee name and an email address you control. Confirm that a new row appears in Onboarding Tracker and that the configured recipients receive the notification. Then set a test row's follow-up date to today, assign your own email as the owner and leave its status incomplete. Run sendOnboardingReminders once from the Apps Script editor to test the reminder. You may need to authorise the script first.

Do not test with real employee records until the workflow has been checked. After testing, delete the fictional test rows and confirm that the trigger list contains only the two intended triggers.

How to operate and maintain it

• Update Onboarding status in the tracker as work progresses. Use Completed when the onboarding item is finished. The reminder function skips rows marked Completed.
• Update Follow-up date when a task needs a new deadline.
• Keep Owner email accurate. The reminder goes to this address.
• The script sends at most one reminder per tracker row per day. It records the send date in Last reminder sent.
• Review the Apps Script Executions page if a notification fails. Check the trigger owner’s access, email quotas, column headings and recipient addresses.

The script is a starter workflow. It assumes the Form question titles and tracker column headings match the names above. If you change those names, update the script too. Google Workspace email sending is subject to account limits, and the account that owns the triggers must remain active and authorised.

Start with these notifications and reminders. Add account provisioning, folder creation or access changes only after the organisation has documented and approved the relevant security process.

Step 7: Keep approvals and access decisions under human control

Not every onboarding task should be automated end to end.

For example, a manager or authorised administrator should confirm:

• The employee's identity and approved start date.
• The correct account name and licence requirements.
• Which groups and shared resources are appropriate.
• Whether access to sensitive systems is justified.
• Whether the employee has completed required agreements or training.

A script can prepare a task, notify an approver or record a decision. It should not make access decisions based on incomplete or unverified form responses.

This distinction matters. Good automation reduces repetitive administration without removing accountability.

Step 8: Test the workflow before using it with a real employee

Build a test form response using fictional information. Check each stage from submission to completion.

Your test should confirm:

• The response appears in the correct Sheet.
• Required fields are captured correctly.
• Notifications go to the intended recipients.
• The tracker updates the correct row.
• Calendar invitations contain the correct dates and attendees.
• Folder creation, if automated, uses the correct location and permissions.
• Errors are recorded and can be investigated.
• Duplicate submissions do not create duplicate onboarding records.

Also test what happens if a field is missing, an email address is invalid or a task owner is unavailable.

Document who owns the automation and how it will be maintained. Apps Script projects, triggers and authorisations need ongoing ownership. Avoid making a critical business process dependent on an employee's personal account without a continuity plan.

A sample onboarding automation plan

You do not have to automate the entire process at once. A sensible first version could be:

This gives the organisation visibility without creating an unnecessarily complicated system.

Common mistakes to avoid

Automating before documenting the process. If the current process is unclear, automation will reproduce the confusion faster. Agree on responsibilities and approval steps first.

Collecting too much information. Only collect information needed for the onboarding purpose. Limit access to employee records.

Giving every stakeholder access to the full tracker. Managers may need task status without needing access to confidential personal details. Separate operational tracking from restricted records where appropriate.

Sending automated messages without testing. Incorrect dates, names or recipients can damage trust. Test with fictional records before launch.

Building a workflow nobody owns. Assign an owner for the Sheet, Form, script, triggers and documentation. Review the process when roles or policies change.

Final thoughts

Employee onboarding is a good example of where Google Workspace can do more than store documents and send emails. With a clearly designed process, Forms, Sheets, Drive, Calendar and Apps Script can work together to reduce repetitive follow-ups and make responsibilities visible.

Start with the process map and tracker. Automate notifications and reminders next. Keep account provisioning, sensitive access and approvals under the control of authorised people.

The goal is not to automate every action. It is to make sure important steps are completed consistently, with the right person accountable at each stage.

If you want to build practical confidence with Google Workspace tools and understand how they support real workplace processes, explore the FTHS Google Workspace Mastery Course.