Cut Unused SaaS Costs with an Automated Google Sheets Tracker

May 05, 2026

The convenience of SaaS has a hidden cost: a chaotic, untracked sprawl of subscriptions silently draining your budget. Discover why manual spreadsheets are no longer enough to manage this invisible expense.

The High Cost of Unseen SaaS Sprawl

Software as a Service (SaaS) has revolutionized how we work. With a few clicks, teams can deploy powerful tools for everything from project management to graphic design. This accessibility is a double-edged sword. While it fuels productivity, it also creates a fertile ground for “SaaS Sprawl”—a chaotic, untracked, and costly accumulation of cloud-based software subscriptions across an organization. It’s the digital equivalent of a ghost fleet: countless ships on your payroll, sailing silently on your balance sheet, with no one at the helm. This sprawl isn’t just messy; it’s a significant and often invisible drain on your resources.

Why manual license tracking is inefficient and costly

For many organizations, the default “solution” for tracking SaaS is a spreadsheet. It starts simple enough: a few rows for your core tools, columns for renewal dates, owners, and costs. But this manual system quickly buckles under its own weight.

It’s a Time Sink: Someone, likely in IT or Finance, is tasked with the thankless job of chasing down department heads, cross-referencing credit card statements, and manually updating rows. This isn’t a one-time task; it’s a recurring cycle of low-value administrative work that pulls skilled people away from strategic initiatives.
It’s Riddled with Errors: Manual data entry is inherently prone to human error. A typo in a renewal date can lead to an unwanted auto-renewal of an expensive annual contract. A forgotten entry means a tool is flying completely under the radar. The spreadsheet becomes a document of questionable accuracy, making it unreliable for critical budget decisions.
It Lacks Real-Time Visibility: The data is only as current as its last update. By the time you conduct a quarterly review, you may have already wasted thousands on licenses for employees who left months ago. You’re always looking in the rearview mirror, reacting to costs instead of proactively managing them.
It Doesn’t Scale: A spreadsheet that’s manageable with 10 subscriptions becomes an unwieldy monster at 50 and a complete liability at 100+. As your company grows and teams adopt new tools, the manual tracker collapses, and chaos takes over.

Identifying the hidden drain of duplicate and unused subscriptions

The true cost of poor SaaS management isn’t just the administrative overhead; it’s the direct financial waste from redundant and abandoned licenses. This is where the real money vanishes.

Duplicate Subscriptions: Without a central approval process or source of truth, it’s incredibly common for different teams to purchase the same tool independently. The marketing team might have a premium plan for a design tool, while the product team signs up for their own separate, identical plan. You’re paying twice (or more) for the same capability.
“Zombie” Subscriptions: These are the licenses that keep charging long after they’ve served their purpose. Think of software purchased for a one-off project that ended six months ago, or licenses still active for former employees. These “zombie” accounts are pure financial deadweight, siphoning money from your budget every single month.
Underutilized Licenses: Perhaps the most insidious drain is paying for more than you need. A department might purchase a 50-seat license for a tool but only ever have 15 active users. Or you might be paying for an “Enterprise” tier packed with advanced features that no one on your team uses or even knows exist. This gap between what you pay for and what you actually use represents a massive opportunity for cost savings.

Fighting SaaS sprawl doesn’t mean you need to buy yet another SaaS tool to manage your other tools. The solution is likely already at your fingertips, embedded within the AC2F Streamline Your Google Drive Workflow you use every day. By intelligently combining a few core applications, you can build a powerful, automated system to reclaim control.

Imagine a workflow where:

Google Forms acts as the single, standardized gateway for all new software requests, ensuring you capture critical data from the start.
Google Sheets becomes your dynamic, central inventory—a single source of truth that is automatically updated, not manually curated.
[AI Powered Cover Letter [Automated Job Creation in Real Time Jobber and Google Sheets Integration from Gmail](https://votuduc.com/Automated-Job-Creation-in-Jobber-from-Gmail-p115606) Engine](https://votuduc.com/AI-Powered-Cover-Letter-Automated Quote Generation and Delivery System for Jobber-Engine-p111092) serves as the engine, the “magic glue” that connects everything. It can automatically send renewal reminders to tool owners, flag duplicate requests, and de-provision licenses based on employee offboarding triggers.

This isn’t just about building a better spreadsheet. It’s about shifting from a reactive, manual chore to a proactive, automated system. It’s a system that works for you, providing the real-time visibility and control needed to eliminate waste and make intelligent decisions about your software stack.

Solution Blueprint: The Automated License Tracker

Before we dive into the code, let’s map out the architecture of our solution. A solid blueprint is essential for any build, and this automated system is no different. We’re not just building a spreadsheet; we’re creating a dynamic, self-regulating system to provide clear visibility into license usage. At its heart, this solution is about connecting the right data source to the right platform using a bit of Automated Work Order Processing for UPS glue.

Core components: Apps Script, Admin SDK, and Google Sheets

Our tracker is built on three powerful, interconnected components, all living natively within the Automated Client Onboarding with Google Forms and Google Drive. ecosystem. This tight integration is what makes the solution so elegant and efficient—no third-party connectors or complex API authentications are required.

Google Sheets: The Command Center. This is more than just our destination; it’s our user interface, our database, and our dashboard all in one. We’ll structure a sheet to act as a master list of all licensed users. It will serve as the single source of truth, where raw data is transformed into actionable insights through sorting, filtering, and conditional formatting.
Genesis Engine AI Powered Content to Video Production Pipeline: The Automation Engine. This is the brains of the operation. Apps Script is a serverless scripting platform based on JavaScript that lets you extend and automate Automated Discount Code Management System applications. We’ll write a script that runs automatically on a schedule (say, every Monday morning). This script will be responsible for fetching the data, processing it, and updating our Google Sheet without any manual intervention.
Admin SDK (Reports API): The Data Source. How do we know if a user is active? We ask the source. The Automated Email Journey with Google Sheets and Google Analytics Admin SDK provides a set of APIs that allow for programmatic access to your organization’s data. We’ll specifically use the Reports API, which gives us access to crucial user activity events. The key piece of data we’ll pull is the lastLoginTime for each user, which tells us the last time they authenticated with their Google account. This is our primary metric for inactivity.

Data flow: mapping user activity to license usage

Understanding how data moves through the system is key to trusting its output. The flow is logical, linear, and fully automated once set up.

Trigger: Our process begins with a time-driven trigger in Apps Script. We configure this to run automatically on a recurring schedule (e.g., weekly or monthly).
Fetch Users: The script first calls the Admin SDK’s Directory API to get a complete list of all active, licensed users in your Automated Google Slides Generation with Text Replacement instance.
Query Activity: For each user, the script then makes a call to the Admin SDK’s Reports API, requesting their last login time and potentially other activity metrics (like last Gmail or Drive interaction).
Process & Compare: The script receives the activity data. It then calculates the number of days that have passed since each user’s last login. It compares this number against a predefined inactivity threshold you set (e.g., 90 days).
Update the Sheet: Finally, the script methodically updates the Google Sheet. It finds the row for each user and writes the latest Last Login Date, calculates Days Since Last Login, and updates a Status column to “Inactive” if the user has crossed the threshold.

This entire cycle runs in the background, ensuring the data in your Google Sheet is never stale.

The end goal: a self-updating master sheet with automated alerts

When the components and data flow work in concert, the result is a powerful, low-maintenance tool that directly impacts your bottom line.

The final product is a self-updating master sheet that acts as a living dashboard for license management. At a glance, you can see every licensed user, their last known activity date, and a clear, color-coded status indicating if they are active or flagged for review. No more manually exporting CSVs or cross-referencing multiple reports.

But we take it one step further with automated alerts. The same Apps Script that updates the sheet can be programmed to check if any new users were flagged as “Inactive” during its run. If so, it can automatically compose and send a summary email to a designated administrator or IT distribution list. This email can provide a high-level summary (“3 users have been flagged as inactive this week”) and a direct link to the sheet for immediate action. This proactive notification closes the loop, transforming the passive dashboard into an active cost-saving system that prompts you to take action precisely when it’s needed.

Building the Tracker: A Step-by-Step Guide

With our objective clear, let’s roll up our sleeves and build this thing. This guide will walk you through creating the Google Sheet, enabling the right permissions, writing the core script, and setting it all on autopilot.

Step 1: Structuring your master Google Sheet for data collection

Before we write a single line of code, we need a home for our data. A well-structured spreadsheet is the foundation of our entire system. It acts as both the database and the dashboard.

Create a new Google Sheet. Name it something descriptive, like “SaaS License Tracker”.
Rename the first tab to “Master_License_List”. While you could create separate tabs for each SaaS provider, starting with a single master list is simpler for our script to manage.
Set up your column headers. These headers are critical, as our script will reference them directly. Lay them out in the first row as follows:

| Header | Description | Example |

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

| SaaS_Provider | The name of the software service. | [Automated Order Processing Wordpress to Gmail to Google Sheets to Jobber](https://votuduc.com/Automated-Order-Processing-Wordpress-to-Gmail-to-Google-Sheets-to-Jobber-p649487) |

| User_Email | The unique identifier for the user, typically their email. | [email protected] |

| User_Name | The full name of the user. | Jane Doe |

| License_Type | The specific subscription tier. | Business Plus |

| Last_Activity_Date | The last recorded date of user activity. This is our key metric. | 2023-09-15 |

| Status | A field our script will update. | Active, Inactive - Review |

| Monthly_Cost | The per-user cost for the license type. | 18 |

| Last_Checked | A timestamp for when the script last updated this row. | 2023-10-26 04:01:15 |

Your initial sheet should look clean and simple, ready to be populated by our automation.

Step 2: Authorizing the necessary APIs in your Google Cloud Project

[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) is powerful because it can interact with other Google services and external applications. But to do so, it needs explicit permission. We grant this permission by enabling the necessary APIs in the associated Google Cloud Project.

Don’t worry, this is easier than it sounds. Every Apps Script project is backed by a Google Cloud project, often hidden by default.

From your new Google Sheet, navigate to Extensions > Apps Script. This opens the script editor in a new tab.
Click on the Project Settings (⚙️) icon in the left-hand navigation bar.
Under the “Google Cloud Platform (GCP) Project” section, click the project number link. This will open your project in the Google Cloud Console.
Once in the Cloud Console, use the search bar at the top to find and navigate to “APIs & Services”.
Click the ”+ ENABLE APIS AND SERVICES” button at the top of the screen.
You’ll now search for and enable the APIs we need. For this guide, we’ll focus on tracking Automated Payment Transaction Ledger with Google Sheets and PayPal activity, which requires two specific APIs:

Google Sheets API: Allows our script to read from and write to our spreadsheet.
Admin SDK API: Allows us to access administrative data, like user lists and last login times, from your Google Docs to Web account.

Search for each one by name, click on it, and hit the “Enable” button. When you add APIs for other services (e.g., Slack, Asana), you would manage their authentication here or within the script itself using API keys, but the principle of granting permission remains the same.

Step 3: Writing the core Apps Script to fetch subscription data

Now for the magic. We’ll write the JavaScript code that lives within Apps Script to automatically pull user data and populate our sheet. For this example, we’ll write a function to fetch all users from your SocialSheet Streamline Your Social Media Posting and their last login time.

Back in the Apps Script editor, replace any boilerplate code with the following:


// --- CONFIGURATION ---

const SHEET_NAME = 'Master_License_List';

const SAAS_PROVIDER_NAME = '[Speech-to-Text Transcription Tool with Google Workspace](https://votuduc.com/Speech-to-Text-Transcription-Tool-with-Google-Workspace-p133052)';

/**

* Main function to be executed by the trigger.

* It fetches user data and writes it to the Google Sheet.

*/

function mainDataFetch() {

const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SHEET_NAME);

if (!sheet) {

Logger.log(`Sheet named '${SHEET_NAME}' not found.`);

return;

}

// Clear existing Google Workspace data to prevent duplicates, keeping the header row.

clearExistingData(sheet, SAAS_PROVIDER_NAME);

let pageToken;

let allUsers = [];

// Use a loop to handle pagination for large user lists.

do {

const response = AdminDirectory.Users.list({

customer: 'my_customer', // 'my_customer' is a literal string for your own domain.

maxResults: 500,

pageToken: pageToken,

orderBy: 'email'

});

if (response.users && response.users.length > 0) {

allUsers = allUsers.concat(response.users);

}

pageToken = response.nextPageToken;

} while (pageToken);

Logger.log(`Found ${allUsers.length} total users.`);

if (allUsers.length === 0) {

return; // No users found, nothing to do.

}

// Prepare data for bulk writing to the sheet.

const rowsToWrite = allUsers.map(user => {

// The lastLoginTime is in ISO 8601 format, which Sheets understands.

const lastLogin = new Date(user.lastLoginTime);

// Handle cases where a user has never logged in.

const lastActivityDate = user.lastLoginTime === '1970-01-01T00:00:00.000Z' ? 'Never Logged In' : lastLogin;

return [

SAAS_PROVIDER_NAME,

user.primaryEmail,

user.name.fullName,

user.orgUnitPath, // We can use Org Unit as a proxy for License Type.

lastActivityDate,

'', // Placeholder for Status column

'', // Placeholder for Monthly_Cost column

new Date() // Last_Checked timestamp

];

});

// Write all the data to the sheet in one go for efficiency.

sheet.getRange(sheet.getLastRow() + 1, 1, rowsToWrite.length, rowsToWrite[0].length).setValues(rowsToWrite);

Logger.log(`Successfully wrote ${rowsToWrite.length} rows to the sheet.`);

}

/**

* Helper function to clear old data for a specific SaaS provider before writing new data.

*/

function clearExistingData(sheet, providerName) {

const dataRange = sheet.getDataRange();

const values = dataRange.getValues();

const rowsToDelete = [];

// Start from the end to avoid index shifting issues when deleting.

for (let i = values.length - 1; i > 0; i--) { // i > 0 to skip header

if (values[i][0] === providerName) { // Column 1 (index 0) is SaaS_Provider

sheet.deleteRow(i + 1);

}

}

}

What this script does:

It connects to the Master_License_List sheet.
It calls the AdminDirectory service (which we enabled in Step 2) to list all users.
It loops through every user, pulling their email, name, and lastLoginTime.
It formats this data into rows that match our sheet’s structure.
Finally, it writes all this data to the sheet in a single, efficient operation.

Step 4: Implementing logic to flag ‘inactive’ or ‘underutilized’ licenses

Collecting data is only half the battle. Now we need to analyze it to find cost-saving opportunities. We’ll write a second function that scans our sheet, identifies users who haven’t logged in for a while, and flags them for review.

Add this new function to your Apps Script file:


// --- CONFIGURATION ---

const INACTIVITY_THRESHOLD_DAYS = 30; // Flag users inactive for more than 30 days.

/**

* Analyzes the data in the sheet to flag inactive users.

*/

function analyzeAndFlagInactiveUsers() {

const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SHEET_NAME);

if (!sheet) {

Logger.log(`Sheet named '${SHEET_NAME}' not found.`);

return;

}

const dataRange = sheet.getDataRange();

const values = dataRange.getValues();

// Get header row to find column indices dynamically.

const headers = values[0];

const lastActivityIndex = headers.indexOf('Last_Activity_Date');

const statusIndex = headers.indexOf('Status');

if (lastActivityIndex === -1 || statusIndex === -1) {

Logger.log('Could not find "Last_Activity_Date" or "Status" columns.');

return;

}

const now = new Date();

const thresholdMillis = INACTIVITY_THRESHOLD_DAYS  *24*  60  *60*  1000;

// Loop through each row (skip header) to check status.

for (let i = 1; i < values.length; i++) {

const row = values[i];

const lastActivity = new Date(row[lastActivityIndex]);

// Check if the date is valid and not 'Never Logged In'

if (lastActivity instanceof Date && !isNaN(lastActivity)) {

const timeDifference = now.getTime() - lastActivity.getTime();

if (timeDifference > thresholdMillis) {

// This user is inactive. Update the status cell.

sheet.getRange(i + 1, statusIndex + 1).setValue('Inactive - Review');

} else {

sheet.getRange(i + 1, statusIndex + 1).setValue('Active');

}

} else {

// If the date is invalid or 'Never Logged In', flag for review.

sheet.getRange(i + 1, statusIndex + 1).setValue('Inactive - Review');

}

}

Logger.log('Activity analysis complete.');

}

/**

* A master function to run both fetching and analysis in sequence.

*/

function runTrackerUpdate() {

mainDataFetch();

analyzeAndFlagInactiveUsers();

}

This script reads the Last_Activity_Date for every user, calculates if it’s older than our INACTIVITY_THRESHOLD_DAYS (30 days, in this case), and updates the Status column accordingly.

Pro Tip: Use Google Sheets’ built-in Conditional Formatting (Format > Conditional formatting) to automatically highlight any row where the Status is “Inactive - Review”. This makes your savings opportunities jump right off the page.

Step 5: Setting up time-driven triggers for continuous monitoring

The final step is to make this entire process hands-free. We’ll set up a “trigger” that runs our script automatically on a schedule.

In the Apps Script editor, click the Triggers (⏰) icon in the left-hand menu.
Click the ”+ Add Trigger” button in the bottom-right corner.
Configure the trigger settings as follows:

Choose which function to run: Select runTrackerUpdate. This is our master function that handles both fetching and analysis.
Choose which deployment should run: Leave as Head.
Select event source: Choose Time-driven.
Select type of time-based trigger: Week timer is a good starting point to avoid excessive API calls.
Select day of the week: e.g., Every Monday.
Select time of day: Choose a low-traffic time, like 1am - 2am.

Click Save.

You will be prompted to authorize the script one last time. Once you do, that’s it! Your script will now run every week, updating your SaaS tracker with fresh data and automatically flagging accounts that need your attention. You’ve officially automated your SaaS license monitoring.

Measuring the ROI Beyond Direct Cost Savings

Cutting a check for an unused license is an obvious financial win, but the true return on investment for an automated SaaS tracker extends far beyond the balance sheet. The real value lies in transforming a chaotic, reactive process into a streamlined, strategic asset. When you stop playing whack-a-mole with subscriptions, you unlock powerful secondary benefits in visibility, security, and operational efficiency.

Achieving real-time visibility into your entire SaaS ecosystem

In most organizations, SaaS procurement is decentralized. The marketing team grabs a new social media tool, engineering signs up for a specialized monitoring service, and finance uses its own subscription for reporting. This leads to “SaaS sprawl”—a tangled, invisible web of applications that nobody truly owns or understands. You can’t manage what you can’t see.

An automated Google Sheets tracker acts as your single source of truth. By centralizing every subscription, owner, renewal date, and cost center into one dynamic dashboard, you replace guesswork with data-driven clarity.

Eliminate Redundancy: Suddenly, it becomes obvious that three different departments are paying for separate project management tools with overlapping features. You can now consolidate onto a single platform, simplifying workflows and leveraging volume discounts.
Optimize Spend: You can easily spot “shelfware”—software that is paid for but rarely used. By tracking usage metrics alongside costs, you can make informed decisions to downgrade plans or reallocate licenses to team members who actually need them.
Forecast with Confidence: Budgeting is no longer a frantic scramble through credit card statements. With all renewal dates and costs in one place, you can accurately forecast future SaaS spend and avoid surprise auto-renewals for expensive, forgotten tools.

This visibility shifts your posture from reactive cost-cutting to proactive spend optimization.

Enhancing security and compliance through automated offboarding

One of the most significant—and often overlooked—security vulnerabilities in a modern company is incomplete employee offboarding. When an employee leaves, they can walk away with active accounts for dozens of SaaS applications, from your CRM to your cloud storage. Each lingering account is a potential backdoor for data exfiltration or malicious activity.

Integrating your SaaS tracker into your offboarding process is a game-changer for your security posture.

Create a Master De-provisioning Checklist: The tracker provides an immediate, comprehensive list of every single SaaS tool a departing employee has access to. There’s no need to ask managers to “try and remember” what tools their team members used.
Reduce Your Attack Surface: By systematically de-provisioning every account, you shrink your organization’s attack surface and drastically reduce the risk of a breach from a disgruntled ex-employee or a compromised, forgotten account.
Simplify Audits: For companies subject to compliance standards like SOC 2 or GDPR, proving that you have a robust process for managing user access is critical. An automated tracker provides a clear, auditable trail, demonstrating that access is revoked in a timely and complete manner. This turns a stressful audit question into a simple report generation.

Reclaiming valuable IT hours spent on manual audits

Before automation, a quarterly SaaS audit is a dreaded, time-consuming ritual. It involves hounding department heads for spreadsheets, manually cross-referencing invoices with user lists, and spending hours trying to reconcile disparate data. This is low-value administrative work that pulls your skilled IT and finance teams away from strategic projects.

An automated tracker effectively makes the audit continuous and effortless. The system does the grunt work, freeing up your team to focus on analysis and action.

From Manual Labor to Strategic Oversight: Instead of spending 20 hours a quarter chasing data, your team can spend one hour analyzing a pre-populated dashboard. Their time is reallocated from data entry to high-impact activities like negotiating with vendors, identifying consolidation opportunities, and advising departments on better tool usage.
Empower Department Owners: By giving department heads clear visibility into their own team’s SaaS spend and usage, you empower them to take ownership. The IT team transitions from being the “SaaS police” to a strategic partner, helping teams get the most value from their software budget.

The ROI here isn’t just measured in the cost of a saved license; it’s measured in the opportunity cost of what your most valuable technical staff can now accomplish with their reclaimed time.

From Tracker to Strategic Asset Management

Your automated Google Sheet is more than just a glorified expense list. It’s the seedling of a robust SaaS management strategy. By moving beyond simple tracking, you can transform this sheet from a reactive cost-cutting tool into a proactive, strategic asset management hub. This evolution is about enriching your data, tailoring insights for your teams, and understanding the entire lifecycle of your software stack. Let’s explore how to elevate your tracker from a simple list to a command center for your company’s software assets.

Customizing the script for specific department needs

A central list of all SaaS tools is essential, but it can be overwhelming for department heads who only care about their team’s specific stack. True strategic value comes from delivering relevant information to the right people.

1. Create Department-Specific Views:

Instead of sending everyone the master sheet, create separate tabs for each department (e.g., “Marketing,” “Engineering,” “Sales”). Use Google Sheets’ powerful QUERY or FILTER functions to pull data dynamically from your master list into these department-specific views. This gives managers a clean, focused look at their team’s tools, costs, and renewal dates without any distracting noise.

2. Empower Department Ownership:

Add columns to your master sheet like Department Owner and Business Justification. This encourages accountability. When a renewal is approaching, the department head is already listed as the point of contact and has a clear justification on file for why the tool is needed.

3. Tailor Your Automated Alerts:

Modify your Google Apps Script to make your alerts smarter. Instead of sending every renewal notification to a single admin, the script can read the Department Owner column and email the relevant manager directly. This distributes the cognitive load of SaaS management and puts the renewal decision in the hands of the person who best understands the tool’s value.

Here’s a conceptual snippet of how you might modify your script’s notification function:


// A conceptual function to send targeted renewal alerts

function sendTargetedRenewalAlerts() {

const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("SaaS_Master_List");

const data = sheet.getDataRange().getValues();

// Assume column indexes are defined elsewhere

// e.g., const RENEWAL_DATE_COL = 4; const OWNER_EMAIL_COL = 5;

data.forEach(function(row) {

const renewalDate = new Date(row[RENEWAL_DATE_COL]);

const ownerEmail = row[OWNER_EMAIL_COL];

const thirtyDaysFromNow = new Date();

thirtyDaysFromNow.setDate(thirtyDaysFromNow.getDate() + 30);

// If renewal is within 30 days and an owner email exists...

if (renewalDate <= thirtyDaysFromNow && ownerEmail) {

const subject = "Upcoming SaaS Renewal: " + row[APP_NAME_COL];

const body = "Hi team, the subscription for " + row[APP_NAME_COL] + " is renewing on " + renewalDate.toLocaleDateString() + ". Please review its usage and confirm if we should proceed.";

// Send the email directly to the department owner

MailApp.sendEmail(ownerEmail, subject, body);

}

});

}

Integrating with other data sources for a holistic view

Your tracker knows what you should be spending, but integrating external data tells you what you’re actually spending and—more importantly—what value you’re getting.

Financial Data Integration: Connect your sheet to your accounting system (e.g., QuickBooks, Xero, Stripe). While a direct API integration using UrlFetchApp in Apps Script is possible for advanced users, a simpler start is to use a service like Zapier or Make.com. Create a workflow that adds a new row or updates an existing one in a separate “Actual Spend” tab in your sheet whenever a SaaS transaction occurs. You can then use VLOOKUP to compare the Contracted Cost in your master list with the Actual Spend, immediately flagging any discrepancies or price increases.
Usage Data Integration: This is the game-changer for identifying waste. The most valuable question you can ask is, “Are we even using this?” To answer it, tap into your Single Sign-On (SSO) provider logs (Google Workspace, Okta, Azure AD, etc.). Most providers allow you to export user activity logs.

Regularly export a report of user logins for the last 30 or 90 days.
Import this data into a new tab in your Google Sheet.
Use COUNTIF or VLOOKUP formulas to cross-reference your master list of licensed users against the login activity log.
This process quickly reveals “zero-login” licenses—seats you are paying for that have gone completely unused. These are the lowest-hanging fruit for immediate cost savings.

HR Data Integration: Connect your tracker to your HR system or even a simple employee roster. When an employee leaves the company, their departure can trigger a review of the SaaS licenses assigned to them. By cross-referencing your SaaS User list with your Active Employee list, you can instantly flag licenses assigned to former employees. This not only cuts costs but also closes a significant security gap.

Knowing when to scale from a sheet to a dedicated platform

Every great tool has its limits, and our Google Sheets tracker is no exception. It’s a phenomenal starting point and may be all a small organization ever needs. However, as your company grows, you’ll encounter triggers that signal it’s time to graduate to a dedicated SaaS Management Platform (SMP).

Trigger 1: The Scale Problem

When your list of SaaS apps grows beyond 50-75 applications or your employee count exceeds 100-150, the sheet starts to creak. Manual data entry, formula maintenance, and keeping track of dozens of department owners becomes a full-time job. The administrative overhead begins to cancel out the savings.

Trigger 2: The Security & Compliance Imperative

As your company matures, so do its security and compliance needs (e.g., SOC 2, GDPR, ISO 27001). A spreadsheet lacks the robust audit trails, role-based access controls, and automated de-provisioning workflows required to meet these standards. Managing sensitive vendor and user data in a spreadsheet becomes an unacceptable risk.

Trigger 3: The Need for Deep, Automated Insights

Manually exporting and cross-referencing SSO and finance logs is effective, but it’s time-consuming and provides only a snapshot in time. When you need real-time usage data, automated discovery of “shadow IT” (apps purchased by employees without approval), and proactive recommendations for optimizing license tiers, you’ve outgrown the capabilities of a spreadsheet.

Dedicated SMPs connect directly to your finance, HR, and SSO systems via APIs. They automate everything we’ve discussed—discovery, license reclamation, renewal management, and security monitoring—providing a level of insight and control that a spreadsheet simply cannot match. Your Google Sheet is the perfect first step to get your house in order; an SMP is the logical next step to professionalize and scale your SaaS management.

Take Control of Your SaaS Spend Today

The journey from SaaS chaos to clarity doesn’t require a six-figure investment in a dedicated management platform. It begins with a commitment to visibility and a pragmatic tool to enforce it. You now have the blueprint for a system that puts you back in the driver’s seat, transforming opaque, recurring charges into a clear, actionable inventory of your company’s digital toolkit.

Recap: The power of an automated, pragmatic approach

Let’s distill the core value of what we’ve built. This isn’t just another spreadsheet; it’s a dynamic command center for your software stack. By implementing the automated Google Sheets tracker, you have achieved several critical objectives:

Illuminated the Shadows: You’ve moved beyond anecdotal evidence and credit card statements. Every subscription, from the mission-critical platform to the forgotten single-user tool, is now documented in a single source of truth.
Eliminated Manual Toil: The real magic lies in automation. By piping in transaction data, you’ve created a system that largely maintains itself. This frees up valuable time from tedious data entry and allows you to focus on high-impact analysis and strategic decision-making.
Enabled Data-Driven Governance: With clear data on cost, ownership, renewal dates, and usage (where available), you can now ask the right questions. Is this tool delivering ROI? Do we have redundant applications? Can we consolidate licenses or negotiate a better enterprise deal? You’re no longer guessing; you’re analyzing.
Embraced Pragmatism Over Perfection: This solution delivers the essential benefits of a sophisticated Software Asset Management (SAM) tool—visibility and control—without the associated cost and implementation overhead. It’s a powerful, 80/20 solution that gets the job done right now.

Your next step: Building a scalable and efficient IT architecture

This tracker is not the final destination; it’s the foundational cornerstone of a more mature and cost-effective IT strategy. The visibility you’ve gained is the essential first step. Now, it’s time to build upon it.

Your immediate next step is to put this system into action. Clone the template, connect your data sources, and begin the process of reviewing every single tool. But don’t stop there. Use this newfound control as a launchpad for building a truly scalable operational framework:

Formalize the Process: Use the tracker to establish a formal procurement and approval process for all new software. If it’s not in the tracker, it doesn’t get approved. This prevents the uncontrolled sprawl from recurring.
Schedule Quarterly Reviews: Set a recurring calendar event for key stakeholders (e.g., IT, Finance, department heads) to review the SaaS tracker. Use these meetings to make decisive cuts, identify consolidation opportunities, and align software spend with strategic business goals.
Integrate Onboarding and Offboarding: Make the SaaS tracker a mandatory checkpoint in your employee lifecycle management. When a new employee joins, use the tracker to provision necessary licenses. More importantly, when an employee leaves, use it as a definitive checklist to de-provision access, immediately cutting costs and enhancing security.

By starting with this simple, automated sheet, you are laying the groundwork for a culture of accountability and efficiency. You are moving from a reactive cost center to a proactive, strategic partner in the business, ensuring every dollar spent on technology drives maximum value.

Vo Tu Duc

A Google Developer Expert, Google Cloud Innovator

Stop Doing Manual Work. Scale with AI.