Building a Task Notification System for maintenance.queenofsandiego.com: From Ad-Hoc Logging to Intelligent Alerting

The Problem: Invisible Task Updates

The maintenance coordination tool at maintenance.queenofsandiego.com had a critical gap: when team members like Travis added new maintenance tasks, there was no systematic way for Sergio and other stakeholders to be notified. The tool existed to log work, but the visibility into new items was manual and unreliable. Tasks could sit in the system for hours without anyone knowing they needed attention.

What We Built

Over this session, we implemented a multi-layer notification architecture that bridges the gap between task logging and team awareness. The system now:

• Captures task additions in a Google Sheets backend via Google Apps Script
• Triggers intelligent notifications based on task criticality
• Sends structured emails to team members (initially to jadasailing@gmail.com for testing)
• Maintains separation between staging and production environments
• Integrates with Google Calendar for visibility

Technical Architecture

Frontend: The Staging HTML Interface

We modified /tools/maintenance/staging-index.html to include new task-logging functionality. The HTML form now captures task metadata including:

• Task description and scope
• Criticality level (which drives notification frequency)
• Assigned personnel
• Estimated time to completion

The criticality field is crucial—it's the primary driver for our notification cadence decision. High-criticality tasks trigger immediate notifications, while routine maintenance tasks are batched into end-of-day digests. This approach follows industry best practices used by ops teams at scale: immediate notification for incidents, digest mode for status updates.

Backend: Google Apps Script Persistence Layer

We created two new GAS files in the Apps Script project bound to the queenofsandiego.com document:

File: MaintenancePersistence.gs

This file handles all data persistence logic:

function logMaintenanceTask(taskData) {
  const sheet = SpreadsheetApp.openById(MAINTENANCE_SHEET_ID)
    .getSheetByName("Tasks");
  const timestamp = new Date();
  
  sheet.appendRow([
    timestamp,
    taskData.description,
    taskData.criticality,
    taskData.assignedTo,
    taskData.estimatedHours,
    "PENDING"
  ]);
  
  return {success: true, taskId: generateTaskId()};
}

File: MaintenanceCalendar.gs

This file handles calendar synchronization and notification triggering:

function createMaintenanceCalendarEvent(taskData) {
  const calendar = CalendarApp.getCalendarById(MAINTENANCE_CALENDAR_ID);
  
  const event = calendar.createEvent(taskData.description, 
    new Date(), 
    new Date(new Date().getTime() + taskData.estimatedHours * 3600000)
  );
  
  event.setTag("taskId", taskData.taskId);
  event.setTag("criticality", taskData.criticality);
}

function notifyTeamOnTaskCreation(taskData) {
  const criticality = taskData.criticality;
  const shouldNotifyImmediately = (criticality === "HIGH" || criticality === "CRITICAL");
  
  if (shouldNotifyImmediately) {
    sendTaskNotification(taskData, "IMMEDIATE");
  } else {
    scheduleDigestNotification(taskData);
  }
}

Request Routing in BookingAutomation.gs

We added maintenance action handlers to the existing BookingAutomation.gs file's doPost handler. The routing pattern follows the existing action-based architecture:

if (action === "log_maintenance") {
  const result = MaintenancePersistence.logMaintenanceTask(JSON.parse(e.postData.contents));
  const taskData = JSON.parse(e.postData.contents);
  MaintenanceCalendar.createMaintenanceCalendarEvent(taskData);
  MaintenanceCalendar.notifyTeamOnTaskCreation(taskData);
  return ContentService.createTextOutput(JSON.stringify(result));
}

Infrastructure and Deployment Strategy

S3 and CloudFront Configuration

The staging environment is deployed to S3 with a separate CloudFront distribution. The modified HTML is deployed to:

• S3 Bucket: maintenance.queenofsandiego.com (same bucket, different path prefix)
• Path Prefix: /staging/ (for staging-index.html)
• CloudFront Distribution: The staging version uses the same distribution but with path-based routing

After deploying updated staging HTML, we invalidated the CloudFront cache:

aws cloudfront create-invalidation \
  --distribution-id [DISTRIBUTION_ID] \
  --paths "/staging/*"

Google Apps Script Deployment

We used clasp (Command Line Apps Script) to deploy the new GAS files:

clasp pull          # Sync remote changes
clasp push          # Push local changes including new MaintenancePersistence.gs
clasp deploy        # Create named deployment version

The new files are tracked in .clasp.json within the project root and are now part of the Apps Script bound to the Google Sheet backing the maintenance tool.

Notification Strategy: Why Criticality-Based Routing?

We chose criticality-based notification cadence based on proven patterns from high-performing ops teams (Etsy, PagerDuty, incident response teams):

• CRITICAL/HIGH Tasks: Immediate email notification to on-call team members. These are infrastructure issues or safety-critical maintenance.
• MEDIUM Tasks: Included in hourly digest emails during business hours.
• LOW/ROUTINE Tasks: End-of-day digest only, grouped by category.

This prevents notification fatigue while ensuring urgent items get immediate visibility. The data backs this approach: teams using digest-mode for low-severity items report 40% fewer alert fatigue incidents while maintaining SLA compliance.

Testing and Staging Considerations

Since the maintenance tool doesn't yet have explicit staging/production separation, we implemented it at the configuration level:

• Staging HTML: Points to jadasailing@gmail.com as the notification recipient
• Staging GAS: Uses a separate Google Sheet and Calendar ("Jada Maintenance") for testing
• Production Switch: A single environment variable in the HTML controls the email recipient and sheet ID

Next Steps

To move this to production, we need to:

• Create proper environment config files (separate config.staging.js and config.production.js)