Automate Operational Triage with Gemini and Google Sheets

May 05, 2026

Stop wasting valuable engineering hours on manual ticket triage. Here’s how to build an intelligent, automated workflow using generative AI and tools you already use every day.

Introduction: The End of Manual Ticket Sorting

In the relentless hum of modern digital operations, the first point of contact for any issue—be it a system alert, a user-submitted bug, or a security flag—is the ticket. This stream of unstructured data is the lifeblood of an SRE, DevOps, or IT support team. Yet, for most organizations, the initial handling of this stream remains a deeply manual, time-consuming, and error-prone ritual: sorting, categorizing, and assigning. This manual triage is the silent killer of efficiency, a bottleneck that slows response times and burns out your most valuable engineers. But what if we could fundamentally change this paradigm? What if we could teach our tools to understand, categorize, and prioritize this incoming flood, transforming a chaotic queue into an intelligent, automated workflow? This is not a distant future; it’s a present-day reality powered by generative AI, and you’re about to build it using tools you likely already use every day.

The Bottleneck Problem in Modern Operations

Every operations team knows the pain. A constant deluge of alerts and tickets arrives from a dozen different sources, each with its own format and level of detail. A senior engineer, whose expertise is desperately needed on a critical outage, instead spends the first 15 minutes of their day sifting through a queue of low-priority alerts, trying to separate the signal from the noise. This is the triage bottleneck.

This manual process is fraught with challenges:

High Cognitive Load: Engineers must constantly switch contexts, reading through disparate log snippets, user complaints, and cryptic system alerts to understand the core issue.
**Increased MTTR (Mean Time to Resolution): The time spent simply figuring out what a ticket is about and who should handle it is time not spent fixing the problem. This delay directly impacts service availability and user satisfaction.
Inconsistent Categorization: Triage is often subjective. The priority assigned to a ticket can vary depending on which team member is on duty, leading to inconsistent handling and a lack of reliable data for post-mortems and trend analysis.
Operational Toil: It’s repetitive, unfulfilling work that contributes directly to engineer burnout and prevents teams from focusing on proactive, high-impact projects.

In short, manual triage doesn’t scale. As systems grow more complex and the volume of data explodes, the bottleneck only tightens, throttling your team’s ability to respond effectively.

This is where generative AI, specifically Google’s Gemini models, enters the picture as a powerful new lever for [Automated Job Creation in Real Time Jobber and Google Sheets Integration from Gmail](https://votuduc.com/Automated-Job-Creation-in-Jobber-from-Gmail-p115606). We’re not talking about building a complex, bespoke machine learning pipeline that requires a dedicated data science team. We’re talking about leveraging a powerful, general-purpose reasoning engine through a simple API call, integrated directly within the familiar environment of AC2F Streamline Your Google Drive Workflow.

By combining the accessibility of Google Sheets as a data source, the event-driven power of Apps Script as the orchestrator, and the advanced natural language understanding of the Gemini API, we can create a robust, intelligent Automated Quote Generation and Delivery System for Jobber system with surprising ease. This approach democratizes AI, allowing operations teams to build sophisticated solutions without deep ML expertise. Google Sheets becomes more than a spreadsheet; it becomes a dynamic dashboard. Apps Script acts as the serverless glue, and Gemini provides the intelligence to make sense of the chaos.

What You Will Build: A Smart Triage System

In this article, you will build a practical, end-to-end automated triage system. Here’s a high-level overview of the final product:

The Intake: A new ticket or alert will be added as a new row in a designated Google Sheet. This could be populated manually, via a form, or through an integration with your monitoring or ticketing platform (e.g., using Zapier or a direct API).
The Trigger: An Apps Script trigger will automatically detect the new row and initiate our triage workflow.
The Intelligence: The script will package the unstructured text from the ticket (the description, title, logs, etc.) and send it to the Gemini API with a carefully crafted prompt.
The Analysis: Gemini will analyze the text and return a structured JSON object containing key insights, such as:

A concise, one-sentence* summary** of the issue.

A suggested* category** (e.g., Database, Frontend, Authentication, Infrastructure).

A recommended* priority level** (P1, P2, P3, P4).

A potential* assignee or team** based on the content.

The Action: The Apps Script will parse this response and automatically populate the corresponding columns in the Google Sheet with the structured, AI-generated data.

The result? Your messy, unsorted list of tickets will transform, in real-time, into an organized, prioritized, and actionable work queue. This system will serve as a powerful foundation that you can extend and adapt to your specific operational needs, finally breaking the bottleneck of manual triage.

System Architecture: A High-Level Overview

Before we dive into the code, let’s zoom out and look at the blueprint for our automated triage system. The beauty of this solution lies in its simplicity and the elegant way it orchestrates a few powerful, readily available Google services. Each component has a distinct role, and together they form a seamless pipeline from problem report to intelligent classification.

Think of the data flow like this: A user reports an issue via a form, which instantly appears in a spreadsheet. This event triggers a script that sends the issue description to Gemini for analysis. Gemini sends back a structured analysis, which the script then uses to update the spreadsheet. The result? A raw, unstructured report is transformed into an organized, prioritized, and actionable ticket in seconds.

Let’s break down each piece of the puzzle.

Component 1: Google Forms for Seamless Intake

The front door to our system is a simple Google Form. This is where team members, users, or other systems will report operational issues.

Role: The primary data entry point. It provides a standardized, user-friendly interface for capturing the initial, unstructured details of an incident.
Why it works: Forms are incredibly easy to create and share. We can design a form with essential fields like “Reporter’s Email,” “Affected Service,” and, most importantly, a large text area for “Please describe the issue in detail.” The key advantage is its native, real-time integration with Google Sheets—every submission automatically creates a new row, ready for processing.

Component 2: Google Sheets as Your Central Hub

This isn’t just a spreadsheet; it’s our dynamic database and single source of truth for all incoming operational issues.

Role: To act as the central repository and dashboard. It receives the raw data from Google Forms and is later updated with the structured analysis from Gemini.
Why it works: Google Sheets provides a familiar, collaborative interface where the entire process is transparent. We can see the initial submission and, moments later, see new columns like Triage Category, Assigned Priority, and AI Summary get populated. It serves as both the input queue for our script and the final, human-readable output.

Component 3: Gemini API for Intelligent Categorization

Here lies the magic. The Gemini API is the cognitive engine that brings intelligence to our Automated Work Order Processing for UPS.

Role: To analyze the unstructured text describing the issue and return structured, actionable data.
Why it works: A Large Language Model (LLM) like Gemini can understand context, nuance, and technical jargon far better than any keyword-based or regex-powered system. We will send it the raw issue description, and in return, we’ll ask it to provide:

A* Category** (e.g., Database, Networking, User Access).

A* Priority Level** (e.g., P1-Critical, P2-High, P3-Medium).

A concise one-sentence* Summary** of the problem.

This step transforms a vague problem statement into a clearly defined task.

Component 4: AI Powered Cover Letter Automation Engine: The Engine Connecting Everything

Genesis Engine AI Powered Content to Video Production Pipeline is the glue that binds all these services together. It’s the serverless, event-driven engine that orchestrates the entire workflow.

Role: To listen for new form submissions, communicate with the Gemini API, and update the Google Sheet.
Why it works: Apps Script lives natively within the Automated Client Onboarding with Google Forms and Google Drive. ecosystem, giving it privileged and straightforward access to Sheets. We’ll write a script that:

Is triggered automatically by the onFormSubmit event.
Reads the issue description from the newly created row in the Sheet.
Formats and sends this data in a request to the Gemini API.
Receives the structured JSON response from Gemini.
Parses the response and writes the category, priority, and summary back into the corresponding cells of the same row.

Step-by-Step Implementation Guide

Alright, let’s roll up our sleeves and build this thing. We’ll move from setting up the data-intake mechanism to wiring up the AI and finally, automating the entire flow.

Step 1: Preparing Your Google Sheets and Form

Before we can automate triage, we need a standardized way to collect operational issues. A Google Form linked to a Google Sheet is the perfect, no-cost solution.

Create a Google Form: Go to forms.new. Create a new form for submitting operational tickets. Keep it simple but effective. We recommend the following fields:

Submitter Email: (This can be collected automatically by Google Forms).
Service Affected: (e.g., A dropdown with API Gateway, Billing Service, Customer Database).
Urgency: (e.g., A multiple-choice question with Low, Medium, High, Critical).
Issue Description: (A paragraph text field for the user to describe the problem in detail. This is the primary input for Gemini).

Link to a Google Sheet:

In your Google Form, navigate to the “Responses” tab.
Click the green “Create Spreadsheet” icon.
Choose “Create a new spreadsheet” and give it a descriptive name like “Operational Triage Tickets”.

Enhance Your Google Sheet:

The linked Sheet will automatically have columns corresponding to your form questions (e.g., Timestamp, Submitter Email, Service Affected, Issue Description).
We need to add our own columns where the automation will write its results. Add the following columns to the right of the existing ones:
Triage Status (To track if the ticket is Pending, Analyzed, or Error).
AI Triage Category (e.g., Database, Networking, Authentication).
AI Suggested Priority (e.g., P1, P2, P3, P4).
AI Assigned Team (e.g., SRE-Core, DBA-Team, Security-Ops).
AI Analysis Notes (A column for any extra context Gemini provides).

Your final sheet structure should look something like this:

| :-------- | :-------------- | :--------------- | :---------------- | :------------ | :----------------- | :-------------------- | :--------------- | :---------------- |

| … | … | … | … | | | | | |

This structure gives us a clean separation between the raw user input and the AI-generated triage data.

Step 2: Acquiring Your Gemini API Key

To communicate with the Gemini model, you need an API key. This key authenticates your requests.

Navigate to Google AI Studio: Go to Google AI Studio.
Generate an API Key:

Sign in with your Google account.
On the left-hand menu, click “Get API key”.
Click “Create API key in new project”.
A new key will be generated for you. Copy it immediately and store it somewhere safe, like a password manager. Treat this key like a password; do not share it or commit it to a public repository.

Store the Key Securely in Apps Script:

Hardcoding secrets directly into your code is a major security risk. [Architecting Multi Tenant AI Workflows in Building Modular Agentic Apps Script with Gemini Function Calling](https://votuduc.com/architecting-multi-tenant-ai-workflows-in-google-apps-script-p-20260321290501) provides a PropertiesService for safely storing sensitive information like API keys.

Open your Google Sheet and go to Extensions > Apps Script.
In the script editor, click the “Project Settings” (gear icon) on the left.
Scroll down to “Script Properties” and click “Add script property”.

Enter GEMINI_API_KEY as the* Property and paste your copied API key as the Value**.

Click “Save script properties”.

Now your script can access the key securely without exposing it in the code itself.

Step 3: Writing the Core Apps Script Logic

This is where we’ll write the code that gets triggered on a form submission, prepares a prompt, and sends it to the Gemini API.

In your Apps Script editor, replace the placeholder myFunction code with the following. We’ll build this out in two parts.


// The main function that will be triggered by the form submission

function processFormSubmission(e) {

// 1. Setup and retrieve data

const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Form Responses 1"); // Adjust sheet name if necessary

const lastRow = sheet.getLastRow();

const range = e.range; // The range of cells affected by the event

const row = range.getRow();

// Set initial status to "Pending"

const statusColumn = 5; // Column E

sheet.getRange(row, statusColumn).setValue("Pending");

// Get the issue description submitted by the user

const issueDescriptionColumn = 4; // Column D

const issueDescription = sheet.getRange(row, issueDescriptionColumn).getValue();

// 2. Retrieve the secure API key

const geminiApiKey = PropertiesService.getScriptProperties().getProperty('GEMINI_API_KEY');

if (!geminiApiKey) {

sheet.getRange(row, statusColumn).setValue("Error: API Key not found.");

return;

}

// 3. Construct the prompt for Gemini

const prompt = `

You are an expert SRE (Site Reliability Engineer) responsible for triaging incoming operational tickets.

Your task is to analyze the following issue description and return a structured JSON object with your analysis.

The JSON object must have the following keys:

- "category": Classify the issue into one of the following: "Database", "Networking", "Authentication", "Application Logic", "Monitoring", "Security", "Infrastructure".

- "priority": Assign a priority level from "P1" (Critical), "P2" (High), "P3" (Medium), "P4" (Low).

- "team": Assign the ticket to the most appropriate team: "SRE-Core", "DBA-Team", "Security-Ops", "App-Dev-Backend".

- "summary": Provide a concise, one-sentence summary of the problem.

Analyze this issue description:

"${issueDescription}"

Return ONLY the JSON object and nothing else.

`;

// 4. Call the Gemini API

const geminiApiUrl = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=" + geminiApiKey;

const payload = {

"contents": [{

"parts": [{

"text": prompt

}]

}]

};

const options = {

'method': 'post',

'contentType': 'application/json',

'payload': JSON.stringify(payload)

};

try {

const response = UrlFetchApp.fetch(geminiApiUrl, options);

const responseText = response.getContentText();

// We will parse this response in the next step

parseAndRoute(responseText, sheet, row);

} catch (error) {

sheet.getRange(row, statusColumn).setValue("Error: API Call Failed");

Logger.log(error.toString());

}

}

Code Breakdown:

processFormSubmission(e): This function takes an event object e as an argument. When triggered by a form submission, this object contains information about the event, including the range of the new row.
Get Data: We identify the active sheet and the row that was just added. We immediately set the status to “Pending” to show that work is in progress.
Retrieve API Key: We safely fetch the API key from PropertiesService.
[Prompt Engineering for Reliable Autonomous Workspace Agents for Reliable Autonomous Workspace Agents](https://votuduc.com/prompt-engineering-for-reliable-autonomous-workspace-agents-p-20260319404106): This is the most crucial part. We give Gemini a clear role (expert SRE), a specific task (analyze and return JSON), and a strict output format. This “prompt engineering” drastically improves the reliability and consistency of the AI’s response.
API Call: We use Apps Script’s UrlFetchApp service to make a standard HTTPS POST request to the Gemini API endpoint, including our payload and options.
Error Handling: A try...catch block is used to gracefully handle potential network errors or issues with the API call itself, updating the status column accordingly.

Step 4: Parsing the Gemini Response and Routing Tickets

After the API call succeeds, we get a response from Gemini. Now we need to parse it, extract the structured data, and write it back to our Google Sheet.

Add the following parseAndRoute function to your script file, below the processFormSubmission function.


// Helper function to parse the Gemini response and update the sheet

function parseAndRoute(responseText, sheet, row) {

const statusColumn = 5;       // Column E

const categoryColumn = 6;     // Column F

const priorityColumn = 7;     // Column G

const teamColumn = 8;         // Column H

const notesColumn = 9;        // Column I

try {

// 1. Parse the full API response to get to the content

const jsonResponse = JSON.parse(responseText);

const content = jsonResponse.candidates[0].content.parts[0].text;

// 2. Clean up the content to ensure it's valid JSON

// Gemini sometimes wraps its JSON in ```json ... ```

const cleanedContent = content.replace(/```json/g, "").replace(/```/g, "").trim();

// 3. Parse the inner JSON object containing our triage data

const triageData = JSON.parse(cleanedContent);

// 4. Update the Google Sheet with the extracted data

sheet.getRange(row, categoryColumn).setValue(triageData.category || "N/A");

sheet.getRange(row, priorityColumn).setValue(triageData.priority || "N/A");

sheet.getRange(row, teamColumn).setValue(triageData.team || "N/A");

sheet.getRange(row, notesColumn).setValue(triageData.summary || "N/A");

// 5. Update the final status

sheet.getRange(row, statusColumn).setValue("Analyzed");

} catch (error) {

sheet.getRange(row, statusColumn).setValue("Error: Parsing Failed");

// Log the raw response for debugging

sheet.getRange(row, notesColumn).setValue("Raw Response: " + responseText);

Logger.log("Parsing Error: " + error.toString());

}

}

Code Breakdown:

Parsing the API Response: The Gemini API response has a specific structure. We first parse the main response, then navigate through it (candidates[0].content.parts[0].text) to find the actual text generated by the model.
Cleaning the Content: AI models can sometimes be a bit “chatty” and wrap their code/JSON output in Markdown blocks (like ```json). The cleanedContent line is a robust way to strip this out, ensuring we have a clean JSON string to parse.
Extracting and Updating: We parse the cleaned JSON string into a JavaScript object (triageData). Then, we use sheet.getRange().setValue() to populate the appropriate columns in our spreadsheet for the corresponding row. The || "N/A" provides a fallback in case a key is missing.
Final Status: We update the status to “Analyzed”, giving us a clear signal that the automation for this row is complete.
Robust Error Handling: The try...catch block here is vital. If Gemini returns malformed JSON or an unexpected response, it will catch the error, update the status to “Error: Parsing Failed”, and log the raw response in the notes column for easy debugging.

Step 5: Setting Up the onFormSubmit Trigger

You have the code, but it won’t run on its own. We need to create a trigger that automatically executes our processFormSubmission function every time a new response is submitted through the Google Form.

Open Triggers: In the Apps Script editor, click the “Triggers” icon (it looks like a clock) on the left-hand sidebar.
Add a New Trigger: Click the ”+ Add Trigger” button in the bottom-right corner.
Configure the Trigger: A configuration window will pop up. Set it up with the following options:

Choose which function to run: processFormSubmission
Choose which deployment should run: Head
Select event source: From spreadsheet
Select event type: On form submit

Save the Trigger: Click “Save”.

Authorization: The first time you save this trigger, Google will prompt you to authorize the script. This is a standard security step. You’ll need to:

Choose your Google account.
Click “Advanced” and then “Go to (your project name)“.
Review the permissions the script needs (like managing your spreadsheets and connecting to external services) and click “Allow”.

That’s it! Your trigger is now active. The entire system is live. Go ahead and submit a test entry through your Google Form and watch your Google Sheet populate with the AI-powered triage analysis within seconds.

Enhancing Your Automated Triage System

You’ve successfully built the core of an automated triage system. Raw tickets come in, Gemini analyzes them, and the results populate your Google Sheet. This is a massive leap forward in operational efficiency. But why stop there? A foundational system is a launchpad, not a destination. Let’s explore how to evolve this pipeline from a simple categorizer into a truly robust, intelligent, and resilient operational tool. We’ll add layers of logic, communication, and analytics that will not only save time but also provide invaluable insights into your operations.

Adding Automated Priority Assignment

Simply knowing which department a ticket belongs to is only half the battle. The next critical question is: “How urgent is this?” Manually setting priorities is often subjective and a significant bottleneck. We can delegate this cognitive task to Gemini as well, ensuring consistent and rapid priority assignment.

The key is to refine our prompt. Instead of just asking for a department, we’ll instruct the model to evaluate the ticket’s content for indicators of impact and urgency.

Implementation Strategy:

Define Priority Levels: First, establish a clear, non-ambiguous priority scale. A common one is:

P1 (Critical): System-wide outage, critical functionality blocked for all users, data loss.
P2 (High): Major functionality impaired for a subset of users, significant workaround required.
P3 (Medium): Minor feature not working, acceptable workaround exists.
P4 (Low): Cosmetic issue, inquiry, or a non-impactful bug.

Engineer the Prompt: Modify your existing prompt to ask for a priority level in addition to the department. You should provide the definitions as context to guide the model’s decision-making process.

Example Prompt:


Analyze the following operational ticket.

1.  **Assign a Department:** Choose from Engineering, Billing, Customer Support, or Infrastructure.

2.  **Assign a Priority:** Use one of the following levels based on the ticket's content:

- P1 (Critical): System-wide outage, critical functionality blocked.

- P2 (High): Major functionality impaired, significant user impact.

- P3 (Medium): Minor feature not working, a workaround exists.

- P4 (Low): Cosmetic issue or general inquiry.

Return your response as a JSON object with the keys "department" and "priority".

**Ticket Summary:** $&#x7B;summary&#x7D;

**Ticket Description:** $&#x7B;description&#x7D;

Update Your Apps Script: Adjust your script to parse the new priority field from the JSON response and write it to a dedicated “Priority” column in your Google Sheet. This simple addition transforms your sheet from a simple routing list into a prioritized work queue.

Implementing Email Notifications for Departments

A ticket sitting silently in a spreadsheet is a ticket that isn’t being worked on. The next enhancement is to proactively notify the correct team the moment a ticket is triaged. Google Apps Script makes this incredibly straightforward with its built-in MailApp service.

Implementation Strategy:

The logic is simple: once Gemini’s analysis is written to the sheet, trigger an email to the assigned department’s distribution list.

Create a Department-to-Email Map: In your Apps Script, define an object that maps the department names to their corresponding email addresses.


function sendNotification(rowData) &#x7B;

const emailMap = &#x7B;

'Engineering': '[email protected]',

'Billing': '[email protected]',

'Customer Support': '[email protected]',

'Infrastructure': '[email protected]'

&#x7D;;

const department = rowData.department; // e.g., "Engineering"

const recipient = emailMap[department];

if (!recipient) &#x7B;

console.error(`No email address found for department: ${department}`);

return;

&#x7D;

// ... construct and send email

&#x7D;

Construct a Dynamic Email: Create an informative email subject and body. Include key details from the ticket and a direct link to the row in the Google Sheet for easy access.


// ... inside the sendNotification function

const subject = `New [${rowData.priority}] Ticket Assigned: ${rowData.summary}`;

const body = `

A new ticket has been automatically triaged and assigned to your department.

- **ID:** ${rowData.ticketId}

- **Priority:** ${rowData.priority}

- **Summary:** ${rowData.summary}

Please review the full details and take ownership.

Link to Triage Sheet: ${SPREADSHEET_URL}#gid=${SHEET_GID}&range=A${rowData.rowNumber}

`;

MailApp.sendEmail(recipient, subject, body);

By integrating this step, you close the loop between detection and action, dramatically reducing response times and ensuring no ticket is ever missed.

Creating a Dashboard for Triage Analytics

Your Google Sheet is now accumulating a valuable dataset on your operational load. Don’t let it sit as raw data. By visualizing this information, you can uncover trends, identify hotspots, and make data-driven decisions about resource allocation.

The easiest way to start is by adding a new “Dashboard” tab directly within your Google Sheet.

Key Metrics to Track:

Ticket Volume by Department: A Pie Chart showing the distribution of tickets across teams. This can immediately highlight which teams are under the most pressure.
Formula: Use COUNTIF or QUERY to count occurrences of each department name.
Ticket Distribution by Priority: A Bar Chart showing the number of P1, P2, P3, and P4 tickets. Are you constantly fighting fires (P1s), or is the load more manageable?
Daily/Weekly Ticket Trend: A Line Chart plotting ticket volume over time. This helps you spot patterns, like an increase in tickets after a new feature release.

Implementation in Google Sheets:

Create a new sheet (tab) named “Dashboard”.
Use formulas to aggregate your data. For example, in cell A2, you could list “Engineering”, and in B2, use the formula: =COUNTIF('Triage Data'!C:C, A2) (assuming department is in column C of your main sheet).
Select your aggregated data and use Insert > Chart to create compelling visualizations.
Arrange these charts on your dashboard for an at-a-glance overview of your operational health.

For more advanced, interactive dashboards, you can connect your Google Sheet as a data source to Google Looker Studio. This free tool allows for more sophisticated filtering, date range controls, and easier sharing with stakeholders.

Error Handling and Fallbacks for API Failures

Any system that relies on an external API must be prepared for that API to fail. The Gemini API is highly reliable, but network issues, rate limits, or malformed requests can occur. A production-ready automation system must handle these failures gracefully instead of breaking silently.

Building a Resilient Script:

Use try...catch Blocks: This is the most fundamental concept in error handling. Wrap your API call (UrlFetchApp.fetch) within a try...catch block. If the API call fails for any reason (e.g., a 500 server error, a network timeout), the catch block will execute.


try &#x7B;

const response = UrlFetchApp.fetch(apiEndpoint, options);

// ... process the successful response

&#x7D; catch (e) &#x7B;

// The API call failed. Handle it.

console.error(`API call failed: ${e.toString()}`);

// ... update sheet with error status

&#x7D;

Update Status on Failure: Don’t let a failed triage attempt look the same as a pending one. In your catch block, write an explicit error status back to your Google Sheet. Create a “Status” column and update it to “Triage Failed: API Error”. This creates a clear signal for manual intervention.
Validate the Response: A successful API call (a 200 OK status) doesn’t guarantee a usable response. The model could, in rare cases, return malformed JSON or an empty body. Before you try to parse the JSON and access its properties, validate it. If parsing fails, update the status to “Triage Failed: Invalid Response”.
Create a Fallback Notification: For any ticket that ends up in a “Triage Failed” state, you need a fallback. You can write a separate function that periodically scans the sheet for these failures and sends a single summary email to an operations admin or a central triage channel. This ensures that even when the automation stumbles, a human is alerted to catch the ball.

Conclusion: From Bottleneck to Breakthrough

We’ve journeyed from a common operational pain point—the manual, time-consuming, and often inconsistent process of initial incident triage—to a streamlined, intelligent, and automated workflow. By integrating the analytical power of the Gemini API with the universal accessibility of Google Sheets, we’ve built more than just a clever script; we’ve engineered a foundational shift in how we approach operational health. The bottleneck of human-first analysis is now a breakthrough into AI-assisted operations, transforming a reactive chore into a proactive advantage.

Recap: The Value of Automated Operational Triage

Let’s distill the transformation we’ve achieved. The “before” state is one many of us know well: an alert fires, an on-call engineer is pulled from deep work, and the race begins to manually parse logs, correlate metrics, and form a hypothesis—all while the clock is ticking. This process is prone to human error, cognitive bias, and burnout.

The solution you’ve built fundamentally changes this dynamic, delivering tangible value across several key axes:

Unprecedented Speed: Gemini performs its initial analysis in seconds, not minutes. This initial classification—identifying the affected service, summarizing the error, and suggesting a severity level—provides the on-call team with a critical head start, drastically reducing Mean Time to Acknowledgment (MTTA) and kicking off the resolution process faster.
Rock-Solid Consistency: The system removes the “it depends who’s on-call” variable. Every alert receives the same structured, methodical initial analysis based on the logic defined in your prompt. This standardization is crucial for reliable operations and for training new team members.
Reduced Cognitive Load: By handling the repetitive, first-pass analysis, the system shields engineers from the relentless noise of low-priority or redundant alerts. This combats alert fatigue and frees up your most valuable resource—your team’s brainpower—to focus on solving novel, complex problems rather than triaging routine ones.
A Living Database of Incidents: Your Google Sheet is no longer just a passive log. It’s an auto-populated, structured dataset of every operational event, complete with AI-generated summaries and classifications. This becomes an invaluable resource for post-mortems, trend analysis, and identifying systemic weaknesses in your infrastructure.

Ultimately, this isn’t just about saving a few minutes per alert. It’s about creating a more resilient, efficient, and data-driven operational culture.

Ready to Scale Your Architecture

The framework we’ve constructed is a powerful and practical starting point, but its true potential lies in its extensibility. Think of this project as the cornerstone of a much larger intelligent automation strategy. As you get comfortable with the workflow, consider these next steps to scale your architecture from a helpful tool to an indispensable operational co-pilot:

Enrich the Context: Pipe more data sources into your prompt. Instead of just log snippets, include relevant metrics from Prometheus, recent deployment information from your CI/CD pipeline, or related alerts from PagerDuty. The richer the context you provide Gemini, the more nuanced and accurate its analysis will be.
Introduce Automated Actions: Move beyond analysis and into automated remediation. Based on Gemini’s classification, your system could trigger subsequent actions via API calls:
Low Severity: Automatically create a low-priority Jira ticket with the analysis pre-filled.
Known Error: Trigger a predefined runbook, like restarting a specific Kubernetes pod or clearing a cache.
High Severity: Immediately escalate to the senior engineering channel in Slack with a full summary and a link to a pre-generated investigation dashboard.
Graduate Your Datastore: For high-throughput systems, Google Sheets may become a bottleneck. The next logical step is to pipe the structured output into a more robust analytics platform like Google BigQuery. This unlocks the ability to perform complex SQL queries, build Looker Studio dashboards to visualize incident trends, and even train custom ML models on your operational data.
Implement a Human-in-the-Loop Feedback System: Add columns to your sheet for engineers to rate the accuracy of Gemini’s triage (Helpful, Partially Correct, Incorrect). This feedback loop is priceless. It allows you to iteratively refine your prompts and measure the direct impact of your changes, creating a system that learns and improves over time.

You’ve taken the first, most important step. You’ve proven that large language models can be pragmatically applied to solve real-world operational challenges. Now, the path is open to you to build upon this foundation, experiment relentlessly, and continue transforming your team’s operational capabilities.

Vo Tu Duc

A Google Developer Expert, Google Cloud Innovator

Stop Doing Manual Work. Scale with AI.

Hi, I'm Vo Tu Duc (Danny), a recognised Google Developer Expert (GDE). I architect custom AI agents and Google Workspace solutions that help businesses eliminate chaos and save thousands of hours.

Want to turn these blog concepts into production-ready reality for your team?

Book a Discovery Call

Introduction: The End of Manual Ticket Sorting

System Architecture: A High-Level Overview

Step-by-Step Implementation Guide

Enhancing Your Automated Triage System

Conclusion: From Bottleneck to Breakthrough