How eateamagon/testcoordinator works
What this project is (type + purpose)
From the file tree and README, this is a Google Apps Script (GAS) Web App (or HTML Service UI) intended to assist with “Testing Coordinator” workflows.
Key indicators:
• Code.gs → server-side Apps Script entry point / backend logic.
• index.html + javascript.html + stylesheet.html → GAS HTML Service UI split into template + client JS + CSS.
• Minimal README suggests a small internal tool, not a multi-service backend.
So your “system” is primarily: Browser UI ↔ Apps Script Web App (server) ↔ Google Workspace services (potentially Sheets/Drive/Gmail/Calendar, etc.).
Client/UI (runs in the user’s browser)
• index.html
• Likely the main HTML template rendered by doGet() in Code.gs.
• Contains layout placeholders and <script>/<?!= include(...) ?> style includes.
• javascript.html
• Client-side logic: DOM events, validation, calling server functions via google.script.run.
• stylesheet.html
• Styling.
Server/Backend (runs in Google Apps Script runtime)
• Code.gs
• Web entrypoint: typically doGet(e) (and possibly doPost(e)).
• Server-side functions called by the client (google.script.run.someFunction()).
• Integration with Google services (if present in code): SpreadsheetApp, DriveApp, GmailApp, etc.
Data stores / external dependencies (not in repo, but likely in runtime)
Even though not visible in the file tree, GAS apps almost always depend on one or more of:
• Google Sheets (as a database)
• Google Drive (files/templates)
• Gmail (notifications)
• Calendar (scheduling)
• PropertiesService (configuration)
• External HTTP APIs (via UrlFetchApp)
Before drawing, scan Code.gs and list:
Data operations
• Which Spreadsheet IDs? Which tabs? Reads/writes?
• Any Drive folders/files used?
Auth/permissions
• Does it run “as user accessing” or “as me” (deployment setting)?
• Any triggers (time-based, onEdit, etc.)?
External integrations
• UrlFetchApp.fetch() targets
• OAuth scopes / advanced services
Client (Browser)
• index.html (UI layout/template)
• javascript.html (client logic; calls server)
• stylesheet.html (styling)
Server (Apps Script runtime)
• Code.gs
• doGet() (renders UI)
• “API functions” (server functions callable from client)
• “Data Access” functions (Sheets/Drive operations)
Data/Services
• Google Sheets (if used)
• Drive (if used)
• Gmail (if used)
• PropertiesService (if used)
• doGet() → returns HTML (index.html plus includes)
• javascript.html → google.script.run.<serverFn> → Code.gs:<serverFn>
• Code.gs → SpreadsheetApp/DriveApp/... → Google services
• Return path: server function returns data → client success handler
Patterns to highlight explicitly:
• Thin client + server callbacks pattern (HTML Service + google.script.run RPC)
• Server-side integration layer (Apps Script services) acting as the “backend”
• Any Spreadsheet-as-DB pattern if present
RPC mechanism
• Call out google.script.run explicitly (this is the API layer).
Authorization
• If known, annotate “Runs as: user/me” and “Who has access: domain/anyone” because this strongly affects behavior and data access.
“Be detailed, don’t overthink it”: how to split into many components safely
Given the tiny repo, the best way to be “very detailed” is to subdivide by responsibility, even if everything is in one file:
• Web handler: doGet(e) / doPost(e)
• “Business logic” (coordination rules)
• “Data access layer” (all Sheets/Drive calls)
• “Notification layer” (Gmail/Chat/etc., if present)
• “Config” (PropertiesService/constants)
• UI event handlers
• Client validation
• RPC calls + success/failure handlers
• Client-side rendering / DOM updates