Troubleshooting Triggers That Simply Don’t Fire

When a Google Apps Script trigger simply doesn’t fire, the execution engine is failing to initiate the script event. This silent failure is primarily caused by four structural disconnects: a simple onEdit trigger attempting to run elevated actions (like sending emails) without required authorization, an automated edit made by a script or API rather than a human user, a broken or renamed function target in the Installable Triggers menu, or an expired OAuth authorization token bound to the trigger owner’s account. Fixing un-triggered scripts requires checking the Apps Script Executions log, re-binding target functions, or upgrading simple triggers to installable triggers.

Fast-Fix: The 45-Second Solution

When a script trigger fails to respond to spreadsheet edits, form submissions, or scheduled events, open the Apps Script editor and inspect the Executions log to confirm event delivery. Verify that manual edits are being made, as simple onEdit functions ignore formula outputs or imports. If functions were renamed or user permissions changed, delete obsolete triggers, re-link them to the correct function, and execute a manual test run to re-authorize.

Quick Risk Snapshot

• Severity: Moderate to High (Silently halts automated workflows, background notifications, and data processing)
• Safe to Rely On Currently?: No (Automated business logic is inactive; manual execution is required until resolved)
• Primary Cause: Simple trigger permission limits or function name mismatches in installable trigger settings
• Secondary Cause: Non-human cell edits (API, formulas, third-party sync tools) bypassing simple onEdit listeners
• Rare Cause: Daily Apps Script trigger runtime quota depletion across the Google Workspace account

Low Risk vs. High Risk Diagnostic Paths

Determining whether your trigger issue is an isolated event or an organizational pipeline failure narrows your repair path:

• Single-Sheet Simple Trigger Failure (Low Risk): The issue is localized to one spreadsheet where a simple onEdit(e) function was written to perform an action requiring user consent (such as opening external files or emailing). Upgrading the function to an installable trigger resolves the issue immediately without affecting other files.
• Account-Wide or Time-Driven Pipeline Failure (High Risk): Time-driven triggers across multiple spreadsheets stop running simultaneously. This indicates that the account owning the triggers has reached Google’s daily trigger execution quotas, had its OAuth permissions revoked domain-wide, or was suspended. Fixing this requires transferring trigger ownership or optimizing script execution time.

How Google Apps Script Triggers Work

Google Apps Script uses an event-driven architecture to run code automatically when specific actions occur in Google Workspace.

Think of a trigger like an electrical pressure switch on an automated assembly line. When a specific physical event occurs, a worker presses a pedal (manual cell edit), a conveyor belt ticks forward (time interval), or a package drops onto a scale (form submission), the switch trips and completes a circuit, sending a signal to start the motor (executing your script function).

Google provides two distinct types of switches, each with different operational limits:

[ Spreadsheet Event Occurs ]
             │
             ├── Human UI Edit? ──> Simple Trigger (onEdit) ──> Standard Actions Only (No Mail/External APIs)
             │
             └── Automated/Scheduled/Form Action?
                         │
                         └── Requires Installable Trigger ──> Runs with Full Account Permissions

1. Simple Triggers (onEdit, onOpen): Built directly into the script code by function name. They trip automatically on standard user actions, but they operate under strict security sandboxes. They cannot access personal user data, call external APIs, or send emails. If a simple trigger encounters code that requires elevated permissions, the engine cuts power instantly, dropping the event without running the rest of the script.
2. Installable Triggers: Created explicitly via the Apps Script Triggers menu or programmatically via ScriptApp.newTrigger(). These triggers run under the authority of the user who configured them. They can perform elevated actions, catch form submissions, and run on time-based schedules, but they break if the function name changes or if the owner’s OAuth token expires.

Probability Breakdown: Root Causes of Un-Fired Triggers

Root Cause	Likelihood	Key Diagnostic Indicator
Simple Trigger Permission Ceiling	40%	Script uses function onEdit(e) and contains elevated services like MailApp, DriveApp, or SpreadsheetApp.openById().
Edit Source Mismatch (Formula/API Edit)	25%	Cell updates are driven by IMPORTRANGE, VLOOKUP, third-party extensions, or external API pushes rather than human typing.
Function Target Disconnect	15%	An installable trigger exists in the Triggers dashboard, but the underlying function name in the code editor was renamed or deleted.
Revoked or Expired OAuth Tokens	10%	The user who created the installable trigger changed their account password, left the company, or had security settings reset.
Trigger Quota Depletion	10%	The Workspace account exceeded the total daily trigger runtime limit (90 min/day for free accounts; 6 hours/day for Workspace).

Technical Troubleshooting: Step-by-Step Diagnostic Pathways

Path 1: Resolving Simple Trigger Restrictions

If your script uses function onEdit(e) or function onOpen(e) and fails to fire, check if the function attempts to access restricted services.

1. Review the function code for restricted Google services, including:
   • MailApp.sendEmail() or GmailApp.sendEmail()
   • DriveApp.getFileById() or external file access
   • UrlFetchApp.fetch() (external API calls)
2. If any restricted service is present, rename your function from onEdit(e) to a custom name like handleSheetEdit(e).
3. Open the Triggers tab (alarm clock icon in the left sidebar).
4. Click Add Trigger in the bottom right corner.
5. Configure the setup:
   • Choose which function to run: handleSheetEdit
   • Select event source: From spreadsheet
   • Select event type: On edit
6. Click Save and complete the OAuth authorization prompt. For further details on trigger permissions, see Why onEdit Triggers Fail (Simple vs. Installable).

Path 2: Diagnosing Automated vs. Human Edits

Simple and installable On edit triggers respond only to direct human actions inside the Google Sheets browser interface (typing in a cell, pasting text, checking a box).

• Formulas & Imports: Changes caused by recalculating formulas (=SUM(), =IMPORTRANGE(), =GOOGLEFINANCE()) do not register as edit events.
• Scripted Modifications: Edits made by another Apps Script function or an external REST API do not trip On edit triggers.
• Workaround: If you need code to execute when external data arrives, convert your script to a time-driven trigger (e.g., running every 5 or 15 minutes) or attach an On form submit trigger instead.

Path 3: Auditing Function Name Mismatches

When you create an installable trigger, Google Sheets stores a hard pointer to the exact string name of the target function.

1. Open the Apps Script editor and click the Triggers icon.
2. Examine the Function column for each listed trigger.
3. Compare the listed function name against your actual JavaScript code file.
4. If the function was renamed (e.g., processRow changed to processSheetRow), the trigger will fail silently or log an error stating “Cannot find function”.
5. Delete the orphaned trigger and re-create it using the new function name from the dropdown menu.

Path 4: Re-Establishing Broken OAuth Connections

Installable triggers execute using the stored credentials of the account that created them. If those credentials become invalid, the trigger stops firing.

1. In the Apps Script editor, select your target function from the top toolbar dropdown menu.
2. Click Run manually.
3. If an Authorization required prompt appears, complete the flow to refresh the account’s OAuth token.
4. If the original trigger owner was a former employee whose Workspace account was suspended, log in as a designated service account or active admin, open the script, and re-save the installable triggers to transfer ownership.
5. For additional OAuth troubleshooting, see How to resolve “Authorization failed” for Time Triggers and “Authorization was revoked” in long-running scripts.

What Increases the Risk

• Duplicating Spreadsheets with Custom Scripts: Copying a Google Sheet via File > Make a copy duplicates the underlying Apps Script code, but it does not copy installable triggers. You must manually re-create installable triggers in the new file.
• Multiple Workspace Account Logins: Having multiple Google accounts signed into the same browser session often leads to authorization mismatches during trigger setup. Use a clean browser profile when setting up triggers.
• Rapid-Fire Editing: Submitting dozens of edits per second (e.g., via bulk copy-pasting) can cause execution queuing delays, making it appear as though the trigger did not fire when it was actually rate-limited or delayed.

Consequence Timeline: Operational Friction Impact

• Immediate (0–15 Minutes): Edits made in the sheet do not calculate background logic. Users assume the sheet is calculating and continue entering data into unformatted or unverified cells.
• 1 Hour: Downstream data processing halts. Time-driven automation cycles skip scheduled execution windows.
• 24 Hours: Automated email notifications, external CRM syncs, and database record pushes fall completely out of alignment, requiring manual data reconciliation.

What This Is Confused With (Error Signal Breakdown)

Symptom / Signal	Root Mechanism	Difference from Un-Fired Triggers
Trigger Doesn’t Fire	Event Failure: The execution engine never starts the script; zero entries appear in the Executions log.	The script is never invoked by Google’s servers.
Trigger Fires but Fails Mid-Execution	Runtime Exception: The trigger fires correctly, but the script encounters a code syntax or reference error midway.	The Executions log shows a record marked with a red Failed status. See The Apps Script Debugging Master Guide.
“Authorization required” Loop	Auth Block: The trigger attempts to run, but an unhandled auth prompt blocks execution on every pass.	The trigger fires, but execution halts immediately at the authorization boundary. See Resolving “Authorization required” Loops (Triggers).
Form Submit Double-Posting	Duplicate Handlers: Both a simple onFormSubmit and an installable On form submit trigger are running simultaneously.	The trigger fires twice instead of failing to fire. See Why Your onFormSubmit Trigger is Double-Posting.

What To Do Right Now

1. Open the Apps Script editor (Extensions > Apps Script).
2. Click Executions in the left navigation panel. Check if trigger events are being registered.
3. If no executions appear, click Triggers and verify that an active trigger exists for your target function.
4. Select your function in the code editor and click Run manually. Fix any authorization or code syntax errors that pop up during manual execution.
5. If using a simple onEdit(e) trigger for advanced tasks, convert it to an installable trigger immediately.

Hard-Stop Triggers

• Account Suspended or Deleted: If the account that configured the installable trigger is deactivated, all triggers bound to that account stop permanently. An active user must take ownership of the script project and re-create the triggers.
• Daily Quota Ceiling Exceeded: If your Executions log displays “Service invoked too many times for one day: trigger execution time”, stop testing. All triggers are locked by Google until the 24-hour rolling quota resets. For quota management, see Resolving “Daily trigger quota reached” (90-min limit).

What an Admin Will Check

When auditing silent trigger failures across an enterprise Workspace domain, an IT administrator will check:

1. Workspace Admin Console Log Events: Inspecting Reporting > Audit and investigation > Apps Script log events to see if trigger executions were blocked by domain-level security policies.
2. Execution Quotas: Reviewing overall account runtime metrics in the Google Cloud Console associated with the Apps Script project.
3. Trigger Owner Status: Verifying whether the original trigger creator is still an active user with valid permissions to all target spreadsheets and connected Drive folders.

Typical Effort Range

• Simple to Installable Trigger Conversion: 2 to 5 minutes.
• Re-linking Renamed Functions or Re-authorizing Tokens: 2 to 5 minutes.
• Auditing Complex Trigger Execution Loops and Quotas: 15 to 30 minutes.

Related System Escalators

• To understand why simple edit triggers fail on restricted commands, see Why onEdit Triggers Fail (Simple vs. Installable).
• To fix permission mismatches inside trigger functions, read “Action not allowed” (Permissions Mismatch).
• To resolve OAuth authorization loops preventing triggers from running, consult Resolving “Authorization required” Loops (Triggers).
• To manage daily runtime execution limits, see Resolving “Daily trigger quota reached” (90-min limit).

Workspace Assessment

When a Google Apps Script trigger appears completely dead, the event signal is failing to bridge the gap between Google Sheets and the execution engine. By checking the Executions log first, ensuring that edit events stem from direct human interaction, matching function names precisely in the Triggers menu, and keeping OAuth credentials active, you can quickly diagnose why a trigger failed to fire and re-establish automated background execution.