Implementation Guide: Auto-schedule tutoring sessions and send reminders based on student calendars

Hardware Procurement

Client Workstation (Existing)

All tutors, administrators, students, and parents access the scheduling system via a modern web browser. No dedicated hardware is needed for the SaaS-based deployment path.

Software Procurement

Prerequisites

• Client has an active internet connection of 25 Mbps or greater at their primary location
• Client owns a registered domain name with DNS management access (e.g., via GoDaddy, Cloudflare, or Namecheap) for creating a booking portal subdomain such as book.clienttutoring.com
• Client has or is willing to purchase Google Workspace Business Standard licenses for all tutors and at least one admin user (minimum 2 seats)
• Client has or is willing to create a Stripe business account for payment processing (required by TutorCruncher for invoicing and session payments)
• Client provides a complete list of all tutors with: full name, email address, phone number, subjects taught, and weekly availability windows
• Client provides a list of all active students with: full name, parent/guardian name, parent email, parent phone number, enrolled subjects, and preferred session frequency
• Client confirms whether any students are under 13 years of age (triggers COPPA compliance requirements for parental consent workflows)
• Client identifies their primary calendar provider (Google Calendar or Microsoft Outlook) — this guide assumes Google Calendar; see alternatives section for Microsoft 365
• Client designates at least one internal administrator who will serve as the platform admin and primary MSP contact
• MSP technician has access to the client's DNS management panel to create CNAME/A records for the booking subdomain
• MSP has a Twilio account (master account) with sub-account capability for client isolation, or client creates their own Twilio account
• If the tutoring center works with any school districts, the client must provide copies of existing Data Processing Agreements (DPAs) or identify districts requiring new DPAs
• Client confirms their state of operation for state-specific student privacy law compliance (particularly relevant for California SOPIPA, New York Education Law §2-d, and similar statutes)

Installation Steps

Step 1: Create and Configure TutorCruncher Account

Sign up for TutorCruncher at the Essentials tier (or higher based on client size). This is the central hub for all tutoring operations — scheduling, student management, tutor profiles, and invoicing. During initial setup, configure the company profile, timezone, currency, and branding (logo, colors) to match the client's identity.

Step 2: Configure Tutor Profiles and Availability

Create individual tutor accounts in TutorCruncher and configure each tutor's availability schedule, subjects, hourly rates, and service types (in-person, online, group). This availability data drives the auto-scheduling engine — students can only book during windows where a qualified tutor is available.

Step 3: Configure Student and Parent Accounts

Import or manually create student profiles in TutorCruncher. Each student record links to a parent/guardian contact for billing and communications. For students under 13, mark the account to trigger COPPA-compliant workflows (parent-only communications, no direct student data collection).

Option A: Bulk import via CSV

Option B: Manual entry

Step 4: Connect Stripe Payment Processing

Integrate TutorCruncher with the client's Stripe account to enable automatic invoicing when sessions are scheduled and payment collection. This is critical for the auto-scheduling workflow — when a session is booked, an invoice is automatically generated and the parent can pay via the client portal.

Step 5: Set Up Google Workspace and Calendar API Access

Configure Google Workspace for all tutors and create a Google Cloud project with Calendar API enabled. This allows bidirectional calendar synchronization — when a session is booked in TutorCruncher, it automatically appears on the tutor's and student's Google Calendar, and vice versa.

A. Google Workspace Setup (if not already provisioned)

B. Google Cloud Console — API Setup

gcloud projects create tutoring-scheduler-prod --name='Tutoring Scheduler'

gcloud services enable calendar-json.googleapis.com --project=tutoring-scheduler-prod

Step 6: Create Twilio Account and Configure SMS

Set up a Twilio sub-account (or standalone account) for the tutoring client, purchase a local phone number, and configure messaging services for SMS reminder delivery. Using a sub-account under the MSP's master Twilio account enables centralized billing and management.

Account SID: ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Auth Token: (from Console > Account > API Keys, or main dashboard)
Messaging Service SID: MGxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
From Number: +1XXXXXXXXXX

Step 7: Configure Twilio SendGrid for Email Reminders

Set up SendGrid for transactional email delivery including booking confirmations, email reminders, cancellation notices, and weekly schedule digests. Configure sender authentication (SPF, DKIM, DMARC) to ensure emails land in inboxes rather than spam folders.

Step 8: Configure Make.com Automation Workspace

Set up the Make.com workspace that will serve as the automation orchestration layer. This connects TutorCruncher events to Google Calendar, Twilio SMS, and SendGrid email. Create the Make.com account, connect all services, and establish the core data routing.

Step 9: Build Core Scheduling Automation Workflow (Make.com Scenario 1: New Booking)

Create the primary Make.com scenario that fires when a new tutoring session is booked. This workflow syncs the session to both tutor and student Google Calendars, sends an immediate booking confirmation email, and schedules SMS and email reminders at 24-hour and 1-hour intervals before the session.

• Path A: Google Calendar Sync
• Module 2A-1: Google Calendar - Create Event (Tutor Calendar) — Calendar ID: tutor_email, Summary: 'Tutoring: {{student_name}} - {{subject}}', Start: {{session_date}}T{{session_time}}, End: {{session_date}}T{{session_end_time}} (calculated: start + duration), Description: 'Student: {{student_name}}\nSubject: {{subject}}\nType: {{session_type}}', Location: {{location_or_meetlink}}, Reminders: default, Color: 10 (green)
• Module 2A-2: Google Calendar - Create Event (Student/Parent Calendar) — Calendar ID: parent_email, Summary: 'Tutoring with {{tutor_name}} - {{subject}}', Start/End: same as above, Description: 'Tutor: {{tutor_name}}\nSubject: {{subject}}\nLocation: {{location_or_meetlink}}'
• Path B: Immediate Confirmation Email
• Module 2B-1: SendGrid - Send Email (Dynamic Template) — To: {{parent_email}}, Template ID: [booking_confirmation template ID], Dynamic data: tutor_name, student_name, session_date, session_time, subject, location
• Path C: Schedule SMS Reminder (24h before)
• Module 2C-1: Tools - Set Variable — reminder_24h_time = {{session_date}}T{{session_time}} minus 24 hours
• Module 2C-2: Tools - Sleep (delay until 24h before) — NOTE: For production, use Make.com Scheduling instead of Sleep module
• Module 2C-3: Twilio - Send SMS — To: {{parent_phone}}, From: {{messaging_service_sid}}, Body: 'Reminder: {{student_name}} has tutoring with {{tutor_name}} tomorrow at {{session_time}}. Subject: {{subject}}. Reply STOP to opt out.'
• Path D: Schedule SMS Reminder (1h before) — Similar structure to Path C with 1-hour offset
• Path E: Schedule Email Reminder (24h before)
• Module 2E-1: SendGrid - Send Email (reminder_24h template) — Scheduled send time: session_time minus 24 hours
• Path F: Log to Data Store
• Module 2F-1: Data Store - Add Record — Store: ScheduledSessions, Fields: appointment_id, tutor, student, date, time, status='confirmed'

Step 10: Build Reminder Dispatcher Workflow (Make.com Scenario 2: Timed Reminders)

Create a separate Make.com scenario that runs on a 15-minute interval schedule, queries the session data store for upcoming sessions, and dispatches reminders at the appropriate times. This is more reliable than Sleep-based delays and handles edge cases like cancellations.

Step 11: Build Cancellation and Rescheduling Workflow (Make.com Scenario 3)

Handle the lifecycle of session changes — when a tutoring session is cancelled or rescheduled in TutorCruncher, this workflow updates Google Calendar events, sends cancellation/rescheduling notifications, and suppresses pending reminders for cancelled sessions.

Make.com Scenario: 'Session Update Handler' — Trigger: Webhook (from TutorCruncher appointment.updated and appointment.cancelled)

Path A: Cancellation (event_type = 'appointment.cancelled')

Path B: Rescheduling (event_type = 'appointment.updated', datetime changed)

Step 12: Configure Booking Portal and Website Integration

Set up the client-facing booking portal where students and parents can self-schedule tutoring sessions. TutorCruncher provides an embeddable booking widget and a hosted booking page. Configure a custom subdomain (book.clientdomain.com) pointing to the booking portal for a professional appearance.

<!-- TutorCruncher Booking Widget -->
<div id='tutorcruncher-widget'></div>
<script src='https://secure.tutorcruncher.com/widget/[CLIENT_ID]/booking.js'></script>

book.clientdomain.com CNAME secure.tutorcruncher.com

Step 13: Set Up Make.com Data Store for Session Tracking

Create the Make.com Data Store that persists session data between scenarios. This data store acts as the central record of all scheduled sessions and their reminder status, enabling the timed Reminder Dispatcher (Scenario 2) to function correctly.

# appointment_id is the primary key (from TutorCruncher). session_datetime
# uses ISO 8601 format. session_type accepts '1-on-1' or 'group'. status
# accepts 'confirmed', 'cancelled', or 'completed'. All reminder_* fields
# default to false.

{
  "appointment_id": "text",
  "tutor_name": "text",
  "tutor_email": "text",
  "student_name": "text",
  "parent_email": "text",
  "parent_phone": "text",
  "subject": "text",
  "session_datetime": "date",
  "session_duration_minutes": "number",
  "session_type": "text",
  "location": "text",
  "google_event_id_tutor": "text",
  "google_event_id_student": "text",
  "status": "text",
  "reminder_24h_sms_sent": "boolean",
  "reminder_1h_sms_sent": "boolean",
  "reminder_24h_email_sent": "boolean",
  "reminder_1h_email_sent": "boolean",
  "created_at": "date",
  "updated_at": "date"
}

Step 14: Configure Error Handling and Monitoring

Set up comprehensive error handling across all three Make.com scenarios and configure alerting so the MSP is notified of failures. This ensures that missed reminders or failed calendar syncs are caught and resolved quickly — critical for a system that directly affects student experience.

Step 15: Implement FERPA and COPPA Compliance Controls

Configure access controls, data handling procedures, and consent mechanisms to ensure the system complies with FERPA, COPPA, and applicable state student privacy laws. This step is non-negotiable for any tutoring business serving K-12 students.

TutorCruncher Access Controls

Execute Data Processing Agreements (DPAs)

COPPA Consent for Under-13 Students

Data Retention Policy

Step 16: Build Weekly Schedule Digest Workflow (Make.com Scenario 4)

Create an automated weekly email that sends each tutor and each parent a summary of their upcoming week's tutoring sessions. This provides a consolidated view and catches any scheduling issues before the week begins.

Custom AI Components

TutorCruncher Webhook Receiver and Normalizer

Type: integration

A Make.com webhook receiver module configuration that accepts incoming webhook payloads from TutorCruncher, validates the event type, extracts and normalizes session data into a standard format used by all downstream automation scenarios. This is the entry point for all scheduling events.

Make.com Custom Webhook Configuration

Step 1: Create Webhook in Make.com

Step 2: Register Webhook in TutorCruncher

Step 3: Data Structure Definition

After receiving the first test webhook, define the data structure in Make.com:

{
  "event_type": "appointment.created",
  "data": {
    "id": 12345,
    "status": "confirmed",
    "datetime_start": "2025-07-15T15:00:00-04:00",
    "datetime_end": "2025-07-15T16:00:00-04:00",
    "service": {
      "id": 101,
      "name": "Math Tutoring - 1 on 1",
      "duration": 60
    },
    "contractor": {
      "id": 201,
      "first_name": "Jane",
      "last_name": "Smith",
      "email": "jane@clientdomain.com",
      "phone": "+15551234567"
    },
    "client": {
      "id": 301,
      "first_name": "John",
      "last_name": "Doe",
      "email": "parent@example.com",
      "phone": "+15559876543"
    },
    "student": {
      "first_name": "Billy",
      "last_name": "Doe"
    },
    "location": "Room 3B",
    "online_link": "https://meet.google.com/abc-defg-hij",
    "notes": "Focus on algebra chapter 5"
  }
}

Step 4: Normalizer Module (Set Multiple Variables)

After the webhook module, add a Tools > Set Multiple Variables module with the following variable mappings:

• appointment_id → {{data.id}}
• event_type → {{event_type}}
• tutor_name → {{data.contractor.first_name}} {{data.contractor.last_name}}
• tutor_email → {{data.contractor.email}}
• student_name → {{data.student.first_name}} {{data.student.last_name}}
• parent_email → {{data.client.email}}
• parent_phone → {{data.client.phone}}
• session_date → {{formatDate(data.datetime_start; "YYYY-MM-DD")}}
• session_time → {{formatDate(data.datetime_start; "h:mm A")}}
• session_datetime_iso → {{data.datetime_start}}
• session_end_iso → {{data.datetime_end}}
• duration_minutes → {{data.service.duration}}
• subject → {{data.service.name}}
• location → {{ifempty(data.online_link; data.location)}}
• is_online → {{if(data.online_link; true; false)}}

Step 5: Router Module

Add a Router after the normalizer that branches based on event_type. Each route connects to its respective downstream scenario via Make.com's scenario-linking or inline modules.

• Route 1: Filter event_type = appointment.created → New Booking Pipeline
• Route 2: Filter event_type = appointment.updated → Update Handler
• Route 3: Filter event_type = appointment.cancelled → Cancellation Handler
• Route 4: Filter event_type = appointment.completed → Completion Logger

Smart Reminder Scheduler with Deduplication

Type: workflow A Make.com scenario that runs every 15 minutes to dispatch SMS and email reminders for upcoming sessions. It includes deduplication logic to prevent double-sends, handles timezone-aware time comparisons, and respects cancellation status to suppress reminders for cancelled sessions.

Scenario Settings

• Schedule: Every 15 minutes
• Max executions: 1 (sequential, no parallel runs)
• Error behavior: Resume (don't stop on individual send failures)

Module Chain

Module 1: Data Store — Search Records

• Data Store: ScheduledSessions
• Filter: status EQUALS 'confirmed' AND session_datetime GREATER THAN {{now}} AND session_datetime LESS THAN {{addHours(now; 25)}}
• Limit: 100 records per execution
• Sort: session_datetime ASC

Module 2: Iterator

• Iterate over search results from Module 1

Module 3: Router (4 parallel paths with filters)

Path A: 24-Hour SMS Reminder

Filter condition:

reminder_24h_sms_sent EQUALS false
AND session_datetime GREATER THAN {{addHours(now; 23)}}
AND session_datetime LESS THAN {{addHours(now; 25)}}

Module A1 — Twilio: Send SMS

• To: {{parent_phone}}
• Messaging Service SID: MGxxxxxxxx

Reminder: {{student_name}} has {{subject}} tutoring tomorrow at {{session_time}} with {{tutor_name}}. 
📍 {{location}}
Need to cancel or reschedule? Reply HELP or call [tutoring center phone].
Reply STOP to opt out of SMS reminders.

Module A2 — Data Store: Update Record

• Key: {{appointment_id}}
• Set: reminder_24h_sms_sent = true, updated_at = {{now}}

Path B: 1-Hour SMS Reminder

Filter condition:

reminder_1h_sms_sent EQUALS false
AND session_datetime GREATER THAN {{addMinutes(now; 45)}}
AND session_datetime LESS THAN {{addMinutes(now; 75)}}

Module B1 — Twilio: Send SMS

Starting soon! {{student_name}}'s {{subject}} session with {{tutor_name}} begins in ~1 hour at {{session_time}}.
📍 {{location}}

Module B2 — Data Store: Update Record

• Set: reminder_1h_sms_sent = true

Path C: 24-Hour Email Reminder

Filter condition:

reminder_24h_email_sent EQUALS false
AND session_datetime GREATER THAN {{addHours(now; 23)}}
AND session_datetime LESS THAN {{addHours(now; 25)}}

Module C1 — SendGrid: Send Email (v3 API)

• To: {{parent_email}}
• From: reminders@clientdomain.com
• Template ID: d-xxxxxxxxxxxx (reminder_24h template)

{
  "student_name": "{{student_name}}",
  "tutor_name": "{{tutor_name}}",
  "session_date": "{{formatDate(session_datetime; 'dddd, MMMM D, YYYY')}}",
  "session_time": "{{session_time}}",
  "subject": "{{subject}}",
  "location": "{{location}}",
  "cancel_url": "https://book.clientdomain.com/reschedule/{{appointment_id}}"
}

Module C2 — Data Store: Update Record

• Set: reminder_24h_email_sent = true

Path D: 1-Hour Email Reminder

Same structure as Path C with 1-hour time window and reminder_1h template.

Operations Budget

• Per execution (15-min interval): 1 search + N iterations + up to 4N send+update operations
• Worst case for 200 sessions/month: ~800 reminder operations/month
• Well within Make.com Core plan's 10,000/month limit

Timezone Handling

• All session_datetime values stored in ISO 8601 with timezone offset
• Make.com's now function respects the scenario's timezone setting
• Set scenario timezone to match client's primary timezone in Scenario Settings > Timezone

Google Calendar Bidirectional Sync Manager

Type: integration Manages creation, update, and deletion of Google Calendar events for both tutors and students/parents. Stores Google Calendar event IDs for future reference (updates, cancellations). Handles timezone conversion and generates Google Meet links for online sessions.

Implementation

Google Calendar Sync — Make.com Module Configuration

Prerequisites

• Google Calendar connection authenticated in Make.com (OAuth 2.0)
• Each tutor's Google Calendar ID = their Google Workspace email address
• Parent/student calendar access: either shared calendar or events sent via email invitation

Create Event Module Configuration

For Tutor Calendar

Make.com Module: Google Calendar > Create an Event

Calendar ID: {{tutor_email}}
Event Title: Tutoring: {{student_name}} — {{subject}}
Start Date & Time: {{session_datetime_iso}}
End Date & Time: {{session_end_iso}}
Timezone: America/New_York (or client timezone)
Description: 
  Student: {{student_name}}
  Subject: {{subject}}
  Session Type: {{session_type}}
  Notes: {{notes}}
  ---
  Auto-scheduled by [Client Business Name]
Location: {{location}}
Color: 10 (Basil/Green — visually distinguishes tutoring from personal events)
Reminders:
  - Method: popup, Minutes: 30
  - Method: popup, Minutes: 5
Conference Data (for online sessions):
  Create Request:
    Request ID: tutor-session-{{appointment_id}}
    Conference Solution Key: hangoutsMeet
  (This auto-generates a unique Google Meet link)
Attendees:
  - Email: {{parent_email}} (sends calendar invitation to parent)

For Student/Parent Calendar

Module: Google Calendar > Create an Event
Calendar ID: {{parent_email}}
Event Title: Tutoring with {{tutor_name}} — {{subject}}
Color: 7 (Peacock/Teal)
(Same fields as tutor event, no attendees needed)
Store output Event ID as `google_event_id_student`

Update Event Module Configuration

Module: Google Calendar > Update an Event
Calendar ID: {{tutor_email}}
Event ID: {{google_event_id_tutor}} (retrieved from Data Store)
Start Date & Time: {{new_session_datetime_iso}}
End Date & Time: {{new_session_end_iso}}
(Other fields: update only changed values)
Send Notifications: Yes (sends update notification to attendees)

Delete Event Module Configuration

Module: Google Calendar > Delete an Event
Calendar ID: {{tutor_email}}
Event ID: {{google_event_id_tutor}}
Send Notifications: Yes (notifies parent of cancellation)

Conflict Detection (Pre-booking Validation)

Before creating a new event, add a conflict check. This prevents double-bookings that could occur if a tutor manually adds events to their Google Calendar outside of TutorCruncher.

Module: Google Calendar > List Events
Calendar ID: {{tutor_email}}
Time Min: {{session_datetime_iso}}
Time Max: {{session_end_iso}}
Single Events: true

Recurring Session Generator

Type: workflow Automates the creation of recurring tutoring sessions. When a student enrolls for weekly tutoring, this workflow generates individual session records for the next 4 weeks (configurable) based on a recurring pattern, creates corresponding calendar events, and refreshes the series as sessions are completed.

Implementation

Make.com Scenario: Recurring Session Generator

Trigger

• Webhook — TutorCruncher recurring appointment series created
• Manual trigger by admin with parameters

Input Parameters

{
  "student_name": "Billy Doe",
  "parent_email": "parent@example.com",
  "parent_phone": "+15559876543",
  "tutor_email": "jane@clientdomain.com",
  "tutor_name": "Jane Smith",
  "subject": "Math Tutoring",
  "recurrence_pattern": "weekly",
  "day_of_week": "Tuesday",
  "start_time": "15:00",
  "duration_minutes": 60,
  "location": "Room 3B",
  "series_start_date": "2025-07-15",
  "generate_weeks_ahead": 4,
  "series_id": "recurring-301-201"
}

Module Chain

Module 1: Tools — Set Multiple Variables

Calculate the dates for the next N sessions:

week_1_date = {{series_start_date}}
week_2_date = {{addDays(series_start_date; 7)}}
week_3_date = {{addDays(series_start_date; 14)}}
week_4_date = {{addDays(series_start_date; 21)}}

Module 2: Tools — Create Array

[
  {"session_date": "{{week_1_date}}", "week_number": 1},
  {"session_date": "{{week_2_date}}", "week_number": 2},
  {"session_date": "{{week_3_date}}", "week_number": 3},
  {"session_date": "{{week_4_date}}", "week_number": 4}
]

Module 3: Iterator — Loop through session dates

Module 4: Google Calendar — List Events (Conflict Check)

• Check tutor calendar for existing events at this date/time
• If conflict found → Skip this date, log to error sheet

Module 5: Data Store — Add Record (if no conflict)

appointment_id: {{series_id}}-W{{week_number}}
session_datetime: {{session_date}}T{{start_time}}:00
duration_minutes: {{duration_minutes}}
status: confirmed
(all other fields from input parameters)
(all reminder flags: false)

Module 6: Google Calendar — Create Event

Create calendar event per Step 9 / Calendar Sync component.

Module 7: SendGrid — Send Series Confirmation Email

Only after all iterations complete — use Aggregator.

• Subject: Recurring {{subject}} sessions scheduled!
• Body: Lists all scheduled dates with times

Auto-Refresh Logic

Create a companion scenario that runs weekly (Sunday night):

Handling Holidays/Breaks

• Maintain a 'blackout dates' array in Make.com Variables
• During generation, check each date against blackout dates
• Skip blackout dates and optionally notify parent
• MSP updates blackout dates at client's request or per school calendar

Blackout dates example:

["2025-11-27", "2025-12-25", "2025-12-31"]

No-Show and Attendance Tracker

Type: workflow

Tracks session attendance and automates follow-up for no-shows. After each scheduled session time passes, if the tutor hasn't marked attendance in TutorCruncher, the system sends a prompt to the tutor and, if no-show is confirmed, sends a follow-up message to the parent to reschedule.

Implementation

Make.com Scenario: Attendance and No-Show Handler

Trigger: Schedule — Every 30 minutes

Module 1: Data Store — Search Records

Filter sessions that should have started 15+ minutes ago but less than 4 hours ago:

status EQUALS 'confirmed'
AND session_datetime LESS THAN {{addMinutes(now; -15)}}
AND session_datetime GREATER THAN {{addHours(now; -4)}}

Module 2: TutorCruncher API — Check Appointment Status

GET https://secure.tutorcruncher.com/api/appointments/{{appointment_id}}/
Authorization: token [API_KEY]

Parse response for status field:

• completed → Session attended
• awaiting_report → Session likely happened, tutor needs to submit report
• confirmed → Session time passed but no status update (potential no-show)

Module 3: Router

Path A: Session Completed

Filter: TutorCruncher status = 'completed' OR 'awaiting_report'

• Data Store: Update status = 'completed'
• No further action needed

Path B: Potential No-Show (status still 'confirmed' 15+ min after start)

Filter: TutorCruncher status = 'confirmed'

To: {{tutor_phone}}
Body: Hi {{tutor_name}}, your {{session_time}} session with {{student_name}} ({{subject}}) appears unconfirmed. Please update the session status in TutorCruncher. If the student didn't attend, mark as no-show. Reply HELP for assistance.

Path C: Confirmed No-Show

Template: no_show_follow_up
Subject: Missed tutoring session — let's reschedule
Dynamic data:
  student_name, tutor_name, session_date, session_time, subject
  reschedule_url: https://book.clientdomain.com

To: {{parent_phone}}
Body: Hi, {{student_name}} missed their {{subject}} session today at {{session_time}}. To reschedule, visit {{reschedule_url}} or reply to this message.

Spreadsheet: No-Show Tracker
Row: [date, student_name, tutor_name, subject, session_time, parent_contacted]

Monthly No-Show Report

Create a companion scenario (monthly trigger) that:

Testing & Validation

Client Handoff

Client Handoff Deliverables

Training Sessions (2 sessions, 1 hour each)

Session 1: Administrator Training

• How to add new tutors and set their availability in TutorCruncher
• How to add new students and link to parent contacts
• How to view and manage the master schedule
• How to handle cancellations and rescheduling
• How to view booking analytics and no-show reports
• How to update blackout dates (holidays, school breaks) — send list to MSP
• How to access the error log Google Sheet and what to escalate vs. handle internally
• Stripe payment dashboard overview and refund process

Session 2: Tutor Training

• How to log into TutorCruncher and view their schedule
• How to update their availability (block time off, change recurring hours)
• How tutoring sessions appear on their Google Calendar
• How to mark sessions as completed or no-show
• What automated messages parents receive (so tutors know what to expect)
• Who to contact for scheduling issues (admin) vs. technical issues (MSP)

Documentation Package

Success Criteria to Review Together

Maintenance

Ongoing MSP Maintenance Responsibilities

Weekly (15 minutes)

• Review Make.com error log Google Sheet for any failed sends or API errors
• Verify Reminder Dispatcher scenario executed on schedule (check Make.com > Scenarios > Execution History)
• Check Twilio account balance if prepaid (ensure sufficient SMS credits for the coming week)
• Review no-show tracker for any systemic issues

Monthly (1 hour)

• Run Make.com operations usage report: verify usage is within plan limits, forecast growth
• Review Twilio SMS delivery reports: check for bounce rates, carrier filtering, opt-out trends
• Review SendGrid email deliverability stats: bounce rate, spam complaints, open rates
• Check Google Calendar API quota usage in Google Cloud Console (should be far below limits)
• Apply any available updates to Make.com scenario modules (Make.com sometimes updates module versions)
• Test all webhook connections by triggering a test booking through the full pipeline
• Generate and send monthly report to client: sessions scheduled, reminders sent, no-show rate, system uptime

Quarterly (2 hours)

• Comprehensive compliance review: verify DPAs are current, review data retention policy adherence, audit access controls in TutorCruncher
• Renew or rotate API keys and tokens (TutorCruncher API key, Twilio Auth Token, SendGrid API key) per security best practice
• Review and update Make.com Data Store: archive old records, optimize queries
• Capacity planning: assess if client growth requires upgrading Make.com plan, adding Twilio numbers, or scaling SendGrid tier
• Review tutoring platform subscription: assess if client needs higher TutorCruncher tier, branch add-ons, etc.
• Test disaster recovery: verify that if one service goes down (e.g., Twilio outage), the remaining services continue functioning independently

Annual (4 hours)

• Full system audit: test every workflow end-to-end, verify all integrations are functional
• Vendor contract and pricing review: check for price changes, new features, or better alternatives
• Compliance re-certification: update DPAs if vendor terms have changed, review for new state-level student privacy laws
• Client business review: assess if automation scope should expand (e.g., add billing automation, progress reports, parent satisfaction surveys)
• Update documentation package with any changes made during the year

SLA Considerations

• Response time for workflow failures: 4 business hours (detected via automated error alerts)
• Resolution time for critical issues (no reminders sending): 8 business hours
• Resolution time for non-critical issues (cosmetic, reporting): 2 business days
• Planned maintenance window: Sundays 2:00-6:00 AM (client timezone) for any updates requiring downtime
• Uptime target: 99.5% for the overall scheduling and reminder pipeline (dependent on upstream SaaS providers)

Escalation Path

Cost of Ongoing Managed Service

Alternatives

All-in-One Platform: TutorBird (Solo/Small Operations)

For solo tutors or small centers with 1-5 tutors, use TutorBird ($14.95/month + $4.95/additional tutor) as a single platform that includes built-in scheduling, Google Calendar sync, SMS reminders, payment processing, and a website builder. This eliminates the need for Make.com, Twilio, and SendGrid entirely since TutorBird handles reminders natively.

General-Purpose Scheduling: Calendly Teams + Zapier

Use Calendly Teams ($16/user/month) as the scheduling front-end with Zapier Professional ($19.99/month) connecting to Google Calendar, Twilio, and SendGrid. Calendly provides an excellent booking UX and native calendar conflict detection, while Zapier handles the reminder orchestration. No tutoring-specific management platform is used.

Self-Hosted: Cal.com + n8n Community Edition

Deploy Cal.com (open-source scheduling) and n8n (open-source workflow automation) on a client-owned VPS or on-premises server. All data stays under the client's direct control. Uses PostgreSQL for data storage, Docker for containerization, and Nginx/Caddy for reverse proxy with SSL.

Microsoft 365 + Power Automate Ecosystem

For clients already invested in Microsoft 365, use Outlook Calendar (instead of Google Calendar), Microsoft Bookings (built into M365 Business Standard and above) for scheduling, and Power Automate for workflow orchestration connecting to Twilio/SendGrid. Microsoft Bookings provides a free booking page with calendar sync built-in.