Clicky

Hobo SEO Dashboard – Privacy, Security and Permissions

by

Disclosure: This post was created by the author using Gemini 2 Pro in a deep co-op examination of the entire code base of Hobo SEO Dashboard in Google Sheets. NOTHING was modified to change Gemini’s opinion. The post was published using Hobo Wp Agent.

QUOTE: “The Hobo SEO Dashboard scripts, based on the reviewed code, are designed as a private tool leveraging your Google Workspace environment. It requires broad permissions to perform its complex automation tasks, but it does not appear to send your private data to the developer. Users should understand the specific data handling involved, particularly the intentional moving of processed files to Trash and deletion of non-canonical client columns.” Google Gemini, 2025

Hobo SEO Dashboard is a Robot that lives in Google Sheets

This is not just an SEO tool.. It is a Robot that does the job for you if that job is SEO auditing and reporting.

Its private and secure.

The Hobo SEO Dashboard is an always-on Robot designed at all times to do one thing – create SEO reports. It is not designed to collect, record, or share your private data outside your Google account.

  • I asked Google Gemini to review it from a security and privacy perspective. It is designed to be a cost-effective, robotic agent, always on, always developing reports for your clients.
  • I don’t see your data (I am under an NDA).

IMPORTANT NOTE – THE HOBO SEO DASHBOARD WAS DESIGNED AND BUILT USING A PERSONAL GMAIL ACCOUNT. All functions work as described on a personal Gmail account.

The system is developed to be extremely frugal with API use (and operate well within Google’s free API usage allowance). Regular use as described will NOT incur extra API charges.

Let’s talk efficiency

You know the drill.

Exporting from Screaming Frog. Downloading GSC data. Cross-referencing crawl issues with performance metrics in endless spreadsheets. Manually building reports, client after client.

It’s essential work, but it’s INCREDIBLY time-consuming, repetitive, and keeps you from the high-impact strategic work your customers really value.

If you’re a hands-on technical SEO professional – whether you’re a freelancer, consultant, in-house manager, or part of a small-to-medium-sized digital agency – you know this struggle intimately.

  • You regularly perform deep site audits, identifying and prioritising crawl errors, indexation problems, on-page optimisation gaps, and security vulnerabilities.
  • You’re data-driven, relying heavily on tools like Screaming Frog and Google Search Console to make decisions and track progress.
  • You manage multiple client sites, demanding efficient workflow management and scalable reporting.
  • You value automation, recognising how much time is lost to repetitive data pulling and formatting – time that could be spent on strategy and implementation.
  • You need actionable reporting that clearly communicates priorities, not just raw data dumps.
  • You’re already comfortable working within Google Workspace, leveraging the power of Google Sheets, Google Docs and Drive.

What if you could automate the bulk of that technical SEO reporting workflow, right inside Google Sheets?

Introducing the Hobo SEO Dashboard system – built by an SEO, for SEOS like you.

Stop juggling CSVS and browser tabs.

This is your command centre, designed to integrate the crucial data sources you rely on and streamline your entire technical audit and reporting process, all within your familiar Google environment.

Here’s how Hobo SEO Dashboard streamlines your workflow:

  • Automated Data Integration:
  • Screaming Frog Power: Connect directly to your SF crawl exports saved in Google Drive. The system automatically finds the relevant client crawl, imports key data (404s, redirects, missing alts, security issues, canonical problems, and much more), populates dedicated tabs, and even cleans up by moving processed files to your Drive Trash.
  • Live GSC Insights: Pull fresh Google Search Console data directly into your dashboard. Track performance trends, top queries, and key pages without manual exports. Keep client reports synced with the latest data.
  • Intelligent Automation & Prioritization:
  • Scheduled Reporting: Set up automated reporting cycles. Let the system load the next client, run data imports, generate reports, and even email them on a schedule you define.
  • Smart Auditing: The integrated ‘SEO Audit’ tab doesn’t just list checks – it aligns with your actual crawl data, automatically flagging issues found in the latest Screaming Frog crawl, helping you instantly see what needs attention.
  • Prioritise Effectively: Quickly identify critical vs. review items, with frameworks potentially linking issues to estimated fix times/costs (based on your settings).
  • Efficient Client Management & Reporting:
  • Multi-Client Handling: Seamlessly manage dozens or hundreds of clients. Add new sites automatically from GSC or SF crawl files. Archive inactive clients. Cycle through clients for automated reporting runs.
  • Flexible Outputs: Generate comprehensive reports directly within Google Sheets OR create detailed Google Doc reports with narrative, charts, and key findings – perfect for client delivery.
  • Streamlined Communication: Utilise the bulk emailer to send customised reports (with embedded performance charts!) to multiple clients efficiently, or use the simple emailer for quick individual updates.
  • Control & Privacy:
  • Your Data, Your Account: This system runs entirely within your own Google Workspace account. Your client data, API keys, and reports stay under your control, leveraging Google’s robust security infrastructure. No third-party servers involved for core data processing (based on full code review).
  • You Authorise: The script only accesses the services (Drive, Sheets, GSC, Gmail, etc.) that you explicitly authorise it to use.

Stop spending hours on manual data wrangling and report formatting. The Hobo SEO Dashboard system is designed to give you back that time, allowing you to focus on delivering expert analysis and driving real results for your clients.

Ready to transform your technical SEO workflow?

SEO Dashboard is designed to be private and secure

This FAQ addresses common questions about the privacy and security of the Hobo SEO Dashboard Google Apps Scripts when used within your Google account.

1. Does this script send my private data (sheet contents, client lists, etc.) to the developer or any third party?

  • Answer: Based on the comprehensive code review of Hobo SEO Dashboard (including the main script and libraries Hobo CR, Hobo SF, Hobo SC), no functions were found that are designed to send your spreadsheet data, client lists, or other private information to the developer or unauthorised third parties.
  • Google Platform Fact: Apps Script requires explicit commands like UrlFetchApp.fetch() or MailApp.sendEmail() to send data externally. Our review found these services used only for:
  • Calling standard Google APIS (Search Console, PageSpeed Insights) using your credentials/API keys.
  • Fetching client URLS (provided by you in the sheet) to check status or on-page elements.
  • Sending emails only to recipients you configure within the spreadsheet (e.g., your admin email, client emails).
  • Google’s Stance: Google states, “We never sell your personal information to anyone… We never use content that you create and store in apps like Drive, Gmail and Photos for advertising purposes…” (Source: Google Safety Centre – Privacy Principles). The script operates under these protections within your account.

2. How is my data kept secure within Google Sheets and Google Drive?

  • Answer: Your data resides within your Google account’s Sheets and Drive storage. Google employs robust security measures to protect this data.
  • Google Platform Fact: Google encrypts customer data “at rest” (when stored on disks) and “in transit” (when moving between servers) using industry standards like AES encryption. Google Cloud utilises a “secure-by-design infrastructure” with multiple layers of protection. (Sources: Google Cloud Default encryption at rest, Google Workspace Security documentation).
  • User Control: Access to your specific Sheet and Drive files is controlled by standard Google sharing permissions, which you manage. The script only gains access after you explicitly authorise it.

3. Why does the script require so many permissions during authorisation?

  • Answer: The script automates complex workflows across multiple Google services, requiring specific permissions for each task. You are shown these requests before granting access.
  • Permissions Breakdown (based on script functions):
  • View and manage your spreadsheets: Needed to read settings, write report data, modify sheet structure (hide/show, clear, add columns/rows).
  • View and manage your Google Drive files: Needed to find, read, and copy Screaming Frog exports/templates, create new report spreadsheets/Docs, and move processed SF files to Trash.
  • View and manage your Google Docs: Needed by the Client Doc Reporter feature to create new report documents.
  • Connect to an external service: Needed by UrlFetchApp to fetch client URLS (for redirects, status, on-page data) and call Google APIS (GSC, PSI).
  • Send email as you: Needed by MailApp and GmailApp to send client reports and notifications using your email address.
  • Allow this application to run when you are not present: Needed for the scheduled automation (time-driven triggers) to function automatically.
  • View your Google Search Console data: Needed to list sites you have access to and fetch performance data via the GSC API.
  • Display and run third-party web content in prompts and sidebars: Needed to show custom menus, sidebars (like Training), and dialogues within Google Sheets.
  • Google Platform Fact: Apps Script automatically determines many required scopes by scanning the code, but developers can (and should for published apps) define explicit, minimal scopes.
  • Google presents human-readable descriptions of these scopes during the authorisation flow, so you know what access you are granting.
  • You can revoke these permissions at any time via your Google Account settings. (Source: Apps Script Authorisation Scopes documentation).

4. Does the script delete my files or data unexpectedly?

  • Answer: The script does not arbitrarily delete files or data. However, it performs specific, intentional deletion/trashing actions as part of its workflow:
  • Screaming Frog Files: The SF import functions (in Hobo SF) are designed to move the processed source SF export files (Sheets in your Drive) to your Google Drive Trash using file.setTrashed(true). This prevents re-processing the same file. Files in Trash are typically recoverable for 30 days.
  • Client Columns: The canonical URL check (Canonical_Check_on_Client_Urls in Hobo SC) will delete a client’s entire column from the ‘Clients’ sheet if the URL listed in row 2 is found to redirect (301/302). This ensures reports aren’t run on non-canonical URLS.
  • Rows in Helper Sheets: Rows are automatically deleted from ‘Hobo Admin’ and ‘Client Reporter’ after processing or filtering.
  • Sheet Content/Structure: Report resets and data loads involve extensive clearing of cell contents and hiding/showing/modifying sheets, which is expected behaviour for this type of tool.
  • Google Platform Fact: Moving a file to trash via setTrashed(true) is a standard Drive operation, distinct from permanent deletion (which the script does not appear to use arbitrarily). Users can restore files from their Drive Trash. (Source: Google Drive API – Trash or delete files).

5. Is using this script secure? Is my data safe from the developer?

  • Answer: Based on the complete code review, the script itself does not contain mechanisms to compromise your data’s security by sending it to the developer. It operates within the security framework of your Google account.
  • Key Points:
  • No Backdoors Found
  • User Authorisation
  • Configuration Reliance
  • Google’s Security
  • Complexity Risk
  • Recommendation: Always practice good security hygiene with your Google account. Understand the permissions you grant. Keep API keys secure. If you have concerns about specific library functions, further independent code auditing could be pursued if the source is available.
  • Conclusion: The script operates securely within Google’s environment. Maintain good security practices, manage permissions carefully, and review any updates before applying.

6. The review mentioned external libraries (Hobo CR, etc.). Are they definitely safe?

  • Answer: The final security review concluded that, based on the complete codebase provided (including those libraries), no malicious tracking or data exfiltration functions were found.
  • The libraries perform tasks consistent with the overall tool’s purpose (like client management, GSC interaction, SF imports, and cleanup routines) using standard Google services and user-configured data, operating within your Google account.

7. How is my PageSpeed Insights API Key (in Settings!B18) handled? Is it secure?

  • Answer: The script reads the API key directly from cell B18 of your ‘Settings’ sheet when it needs to call the Google PageSpeed Insights API via UrlFetchApp.
  • Security:
  • The key is transmitted securely (HTTPS) from Google’s servers (where the script runs) to the Google PageSpeed Insights API endpoint.
  • The script code reviewed does not appear to log this key or send it to any other external services besides the intended Google API.
  • Its security primarily depends on the security of your Google Sheet. Only grant access (View or Edit) to the spreadsheet to trusted individuals, as anyone with access can potentially see the key stored in that cell.

8. The script uses caching (CacheService). Does this store my data insecurely?

  • Answer: The script uses CacheService to temporarily store results from UrlFetchApp calls (like fetched page titles, status codes, PSI results) for performance reasons (reducing redundant fetches).
  • Google Platform Fact: Google Apps Script’s CacheService stores data within Google’s infrastructure, associated with the script and the user running it. The cache is private to the script user (or public if explicitly set, which this script doesn’t appear to do). It has built-in time limits (the script sets 6 hours/21600 seconds) and size limitations. It’s designed for temporary performance boosts, not permanent or sensitive data storage.

9. Can the automated triggers (scheduled tasks) run malicious code or access things I didn’t approve?

  • Answer: Triggers execute specific functions from the script you already authorised, using the same permissions you already granted.
  • Google Platform Fact: A trigger cannot grant itself new permissions or execute code outside the script project it belongs to. If the script code itself is updated to require new permissions (e.g., accessing a new Google service), you would typically be prompted to re-authorise the script the next time you run it manually or the next time a trigger attempts an action requiring the new permission.
  • Risk: The main risk with triggers isn’t malicious code (assuming the script code itself is safe), but rather:
  • A bug in the triggered function is causing errors or unexpected processing.
  • Triggers are running too frequently and hitting Google quotas.
  • Triggers left running unintentionally if not managed correctly (though this script includes functions to clear its own specific triggers during setup/deletion).
  • Note: Hobo SEO Dashboard is designed to be robust and handle this.

10. If the script developer provides an update, do I need to re-authorize it? Will it change the security?

  • Answer: If you manually update the script by copying and pasting new code provided by the developer:
  • You will need to re-authorise only if the updated code introduces calls to new Google services or requires different permission scopes than the ones you previously granted.
  • If the update only changes the internal logic without needing new permissions, re-authorisation is usually not required.
  • Security Implication: Each time you replace the code, you are trusting the new code provided. Ideally, any updates should also be reviewed for security if you have concerns.

11. What are the security implications if I share this spreadsheet with collaborators?

  • Answer: Sharing the spreadsheet itself using standard Google Sheets sharing options has implications:
  • Data Access: Collaborators will be able to see all the data within the sheets you grant them access to (client lists, settings, API keys stored in cells, report data, logs).
  • Code Access: Collaborators with Edit access can also view and potentially modify the Apps Script code attached to the sheet.
  • Script Execution: If a collaborator tries to run the script (e.g., via a custom menu), they will be prompted to authorise it under their own Google account. The script will then run using their permissions, accessing their GSC data, their Drive, sending email as them, etc. It does not automatically run using your permissions just because you shared the sheet.
  • Recommendation: Be cautious when sharing spreadsheets containing sensitive configuration data like API keys or extensive client lists. Use Google Workspace’s granular sharing permissions if needed.

12. If the script encounters an error or crashes, could it expose my data?

  • Answer: Apps Script execution errors are typically handled internally.
  • Google Platform Fact: Error details are logged in the Apps Script execution history within your Google account (accessible via the script editor), which requires edit access to the script project.
  • Script Behaviour: The script’s internal logging (logEvent) writes only to the ReporterDailyLog sheet if enabled. The reviewed code’s error handling (try…catch blocks) primarily logs error messages internally using logEvent or displays toast messages to the user interface. There is no indication that errors cause it to send sensitive data to external locations.

13. How is using this script different from installing a Google Workspace Marketplace Add-on?

  • Answer: There’s a key difference in vetting:
  • Marketplace Add-ons: Undergo a review process by Google before being published. This includes checks on requested permissions (OAuth scope verification) and potentially code reviews, providing a level of third-party vetting.
  • Bound Scripts (like Hobo EO Dashboard): This script is directly attached (“bound”) to your spreadsheet – it needs a very complicated Spreadsheet to run it. It runs entirely under your direct authorisation without undergoing Google’s formal Marketplace review process. You (or someone you trust) are responsible for reviewing the code to ensure it’s safe and functions as expected.

14. Does the script store my data anywhere else besides Google Sheets/Drive?

  • Answer: Based on the code review, the script primarily uses:
  • Google Sheets: For storing configuration, client data, report data, and logs.
  • Google Drive: For finding SF export files, creating report Sheet/Doc copies, and storing templates.
  • CacheService: For temporary storage of fetched data (titles, PSI results) for performance.
  • PropertiesService: For storing small amounts of simple configuration or state data associated with the script/document/user (e.g., security check ID, last run times).
  • Conclusion: There is no indication that the script uses external databases or other long-term storage mechanisms outside of your Google Workspace account.

15. Can you clearly summarise exactly what data leaves my Google account when this script runs?

  • Answer: Yes. Based on the code review, data leaves your account only in these standard, controlled ways:
  • Requests to Client Websites (status, redirects, on-page content).
  • Requests to Google APIS (PageSpeed Insights, Search Console).
  • Emails are sent (constructed with your data) via Google’s email servers.
  • No other data exfiltration (e.g., sending sheet contents or logs to developer servers) was identified in the reviewed codebase.

Conclusion:

This expanded FAQ should provide a thorough understanding of the script’s security and privacy posture within the Google Workspace environment. Remember that its security relies on the reviewed code behaving as written and your diligence in managing your Google account security and the script’s configuration.

Hobo SC

Okay, let’s break down the functionalities associated with Hobo SC, based on the code snippets provided across our conversation and your clarification. This library is central to integrating Google Search Console (GSC) data and performing related URL verifications.

Hobo SC – Core Purpose:

This library acts as the bridge between your Google Sheet dashboard and the Google Search Console API. Its primary responsibilities include:

  • Automatically discovering and adding websites you have access to in GSC into your ‘Clients’ sheet.
  • Verifying the status and type (Domain Property vs. URL Prefix Property) of client sites listed in your sheet against your GSC account.
  • Fetching Search Console data on demand for the currently loaded client.
  • Managing triggers related to GSC data processing and other related tasks like “Winners and Losers” projects.
  • Providing utilities like updating Google Algorithm update dates.

Key Function Groups and Mechanisms:

  • GSC Client Extraction & Management:
  • Purpose: To automatically find sites listed in your GSC account and add them as potential clients to your ‘Clients’ sheet, avoiding duplicates.
  • Key Functions: scheduleInitialTriggerfor_GSC_Client_Extraction, listSearchConsoleSites, updateScDomainUrls, extractScClients2, renameClientHeadersFromSC, deactivateTrigger, deleteRowsWithSpecificValueAndShiftUp.
  • Mechanism: This is a multi-step process orchestrated using sequential time-based triggers (.after(1000)):
  • It starts by cleaning a temporary sheet (‘Hobo Admin’).
  • It calls the GSC API (/webmasters/v3/sites) using UrlFetchApp and your authorization token (ScriptApp.getOAuthToken()) to get a list of all sites you can access.
  • It writes a subset of these URLs (limited by Settings!B118) to the ‘Hobo Admin’ sheet.
  • It then cleans this list: removes http:// URLs, removes empty rows, resolves sc-domain: properties to their actual canonical URL (by fetching the domain using UrlFetchApp via getFinalUrl), and removes any URLs that already exist in your ‘Clients’ or ‘Clients Archiver’ sheets.
  • For the remaining unique, valid HTTPS URLs in ‘Hobo Admin’, it adds new client columns to the ‘Clients’ sheet, using ‘Client 0’ (via Hobo CR functions) as a template for each, pasting the URL into row 2.
  • Finally, it renames the headers of these new columns sequentially (“Client 1”, “Client 2”, etc.) and schedules the next verification steps.
  • Interaction: Reads GSC API, uses ‘Hobo Admin’ as staging, reads ‘Clients’/’Clients Archiver’ for deduplication, writes extensively to ‘Clients’, calls Hobo CR.
  • Canonical URL & GSC Property Type Verification:
  • Purpose: To ensure the URL listed for each client in Clients!B2 is the correct, final (canonical) URL and to determine if that site is verified in GSC as a Domain Property (sc-domain:) or a URL Prefix Property (https://). This updates Clients!B87.
  • Key Functions: Canonical_Check_on_Client_Urls, scheduleCanonicalCheck, Set_Search_Console_Type_on_clients_tab, scheduleSetSearchConsoleType.
  • Mechanism: These functions are typically scheduled to run periodically (e.g., every 10 minutes via triggers).
  • Canonical_Check_on_Client_Urls: Iterates through client columns. Fetches the URL in row 2 using UrlFetchApp (with followRedirects: false). If the URL redirects (301/302), it deletes the entire client column. If it’s okay, it marks a status cell (Clients!B274) as ‘YES’. It has a 5-minute execution time limit.
  • Set_Search_Console_Type_on_clients_tab: Re-fetches the full list of sites from the GSC API. It then iterates through the client columns in the ‘Clients’ sheet. For each client, it compares the domain (derived from Clients!B6) against the GSC site list.
  • If a match is found with an https:// URL prefix property, it writes “SINGLE” to Clients!B87.
  • If a match is found with an sc-domain: property, it writes “DOMAIN” to Clients!B87.
  • If no match is found after checking all GSC sites, it writes “NO” to Clients!B87.
  • It uses status cells (Clients!B275, Clients!B276) to track progress and avoid re-checking unless forced (refreshData parameter). It also updates related flags like Clients!B47, B246, B253.
  • Interaction: Calls GSC API, fetches client URLs, reads/writes status flags and type (‘SINGLE’/’DOMAIN’/’NO’) to the ‘Clients’ sheet. Critically, it can delete columns from ‘Clients’ based on the canonical check.
  • Winners & Losers Trigger Management:
  • Purpose: To allow easy deletion of the automated triggers associated with the “Winners and Losers” analysis features.
  • Key Functions: Winners_and_losers_URLs_Schedule_Triggers_DELETE, Winners_and_losers_Keywords_Schedule_Triggers_clearExistingTriggers.
  • Mechanism: These functions simply iterate through all project triggers (ScriptApp.getProjectTriggers()) and delete any whose handler function matches the specific name associated with the Winners/Losers URL or Keyword trigger function (the functions being triggered are defined elsewhere).
  • Interaction: Interacts with ScriptApp trigger management.
  • Google Algorithm Update Dates:
  • Purpose: To populate the ‘Settings’ sheet with known date ranges of Google algorithm updates, presumably for annotation on charts or timelines.
  • Key Functions: GoogleUpdates (called from menu), updateFormulasBasedOnGoogleUpdates.
  • Mechanism: updateFormulasBasedOnGoogleUpdates contains a hardcoded array of recent Google updates (name, start date, duration). It calculates the end date for each and writes the start/end dates into specific ranges within the ‘Settings’ sheet (L37:O…, V37:Y…, Z37:AC…).
  • Interaction: Writes data into the ‘Settings’ sheet.
  • Single Site GSC Check:
  • Purpose: Quickly determine the GSC property type (SINGLE/DOMAIN/NO) for the currently loaded client when SEODashboard_LockAndLoadClients_and_CLEAN runs.
  • Key Function: Single_Site_CHECK_Set_Search_Console_Type.
  • Mechanism: Fetches the GSC site list, compares the site URL/domain from Settings!B2/B6 against the list, and writes the result (“SINGLE”, “DOMAIN”, or “NO”) directly into Settings!B87.
  • Interaction: Calls GSC API, reads ‘Settings’, writes to ‘Settings’.
  • Helper Functions:
  • getFinalUrl: Takes a domain, prepends http:// if needed, fetches it with followRedirects: false, and returns the Location header if redirected, otherwise returns the original URL. Used by updateScDomainUrls.
  • getColumnLetter: Standard utility to convert a column number to its letter representation (e.g., 1 -> A, 27 -> AA).
  • deactivateTrigger: Finds and deletes a trigger by its handler function name. Used extensively to manage the chained trigger sequences.

Overall Role in the System:

  • Hobo SC is essential for integrating verified Google Search Console data into the workflow.
  • It automates the often tedious process of identifying which client websites are present in GSC and whether they are domain or URL properties.
  • It provides the mechanism (SEODashboard_RemoteUpdateALLFunctions calls functions within this library) to pull performance data from GSC.
  • Crucially, its canonical check acts as a data validation step, removing clients from the active list if their configured URL redirects, potentially preventing reports from running on non-canonical URLs.
  • It works in tandem with Hobo CR (for client template management) and Hobo SF (for crawl data) to provide a combined view.

Hobo SF

Hobo SF, the crawl files organiser component in Hobo SEO Dashboard, is a sophisticated system designed for automating SEO audits and reporting within Google Sheets, integrating heavily with your Screaming Frog crawl data stored in Google Drive.

Here’s a breakdown of its main components and functionalities:

1. Core Purpose:

  • Automated SEO Reporting: The primary goal is to automate the process of gathering SEO data (primarily from Screaming Frog crawls and you will need a license – Hobo SEO Dashboard is not affiliated with Screaming Frog), analysing it for common issues, populating various tabs within a Google Sheet dashboard, and generating/updating client-specific reports.
  • Client Management: It manages multiple clients, cycling through them based on a schedule or priority system.
  • Data Integration: It pulls data from Screaming Frog export files stored as Google Sheets in Google Drive. It also includes functions to fetch live data like page titles, meta descriptions, status codes, and PageSpeed Insights scores.
  • User Interface: It provides custom menus within Google Sheets for users (SEO professionals) to control the system, select clients, run specific checks, and manage reports.

2. Key Modules & Functionalities:

  • Security (Hobo SF):
  • This module attempts to prevent the script from running on unauthorised copies of the spreadsheet. It stores the original document’s ID and checks against it, allowing the first copy made by a user but preventing subsequent copies from running the core automation.
  • UI Menus (createHoboSFMenu):
  • Creates several custom menus in the Google Sheet interface:
  • Hobo Controls: Select/load clients, start/stop the automated reporter, reset reports, update dashboard crawl data, import crawl files individually, run specific crawl checks (404s, missing alts, security, etc.).
  • Hobo Admin: Set admin details, manage clients (add, archive/unarchive), optimize reporting priority, schedule/unschedule the automated reporter, publish/email client reports, manage bulk client reporting/emailing, access training.
  • Hobo SEO Course: Activate email courses.
  • Upgrade: Link to upgrade the tool.
  • Each menu item triggers a corresponding Apps Script function.
  • Client Loading & Cycling (SEODashboard_LockAndLoadClients_and_CLEAN):
  • This is a crucial automated step. It’s designed to select the next client to be processed.
  • It checks various status flags in the ‘Settings’ sheet (e.g., if the system is paused, waiting, or if specific sub-processes are running).
  • It checks if the client is due for a report (based on Clients!B243 and potentially Settings!B42 override).
  • If the client isn’t due, it cycles the client list in the ‘Clients’ sheet (moves the current client column to the end, deletes the old column B) and attempts to load the next client. It has a counter (Settings!B300) to prevent infinite looping if no clients are due.
  • Once a due client is in column B of ‘Clients’, it copies that client’s data (B1:B500) into the ‘Settings’ sheet, effectively loading the client for processing.
  • Includes checks (Pause_Hobo_Reporting) to automatically pause the reporter if all clients are marked as not due.
  • Runs cleanup functions like deleteBlankColumns and Clear_Winners_Losers_tabs.
  • Screaming Frog SEO Spider Data Import:
  • This is the system for pulling data from Screaming Frog exports saved in Google Drive.
  • It relies on specific export reports from different Screaming Frog SEO Spider reports.
  • The main function – the sequence runner – checks flags in the ‘Settings’ sheet (B57-B82) to determine which specific crawl reports to import.
  • Each checkFor… function:
  • Searches Google Drive for ONLY the relevant file name.
  • Iterates through found files (up to a limit set in Settings!B54).
  • Opens the file (must be a Google Sheet).
  • Checks if the data inside matches the currently loaded domain (from Settings!B2).
  • If a match is found: Clears the corresponding tab in the dashboard (e.g., ‘404s’, ‘Missing Alt’), copies the data (potentially limited by row count from Settings!B37 or B39), shows the sheet, records the source file ID, and moves the source file to Google Drive Trash.
  • If no match is found, Clears and hides the corresponding tab. Some functions might send an email notification if no file is found.
  • Report Reset & Cleanup (SEODashboard_resetReport, SEODashboard_hideEmptySheets):
  • Prepares the dashboard for a new client load.
  • SEODashboard_resetReport: Clears the content of numerous predefined report tabs (like ‘404s’, ‘Missing Title Tags’, etc.) and hides most of them (except ‘Crawl’).
  • SEODashboard_hideEmptySheets: Runs shortly after the reset to hide any other tabs that might have become empty.
  • Client Report Publishing (SEODashboard_Publish_Client_Report & related functions):
  • Creates or updates a separate Google Sheet report specifically for the client.
  • Checks various conditions (timing, status flags, data existence).
  • If Settings!B44 (Client Report ID) is empty, it duplicates a template sheet (Settings!B46) using SEODashboard_hobobotDuplicate.
  • If Settings!B44 has an ID, it opens that existing sheet.
  • Copies data from relevant tabs in the main dashboard to the client report (SEODashboard_copyContentToDuplicatedSpreadsheet), respecting a “CRAWL ONLY” setting (Settings!B50). Skips admin/utility tabs.
  • Modifies the client report (SEODashboard_modifyDuplicatedSpreadsheet): Sets specific formulas (especially in ‘Priorities’, ‘Reviewed’), hides admin/settings tabs, adds editors (admin email from Settings!B17, client email from Settings!B48), clears API keys, hides empty/irrelevant tabs.
  • Updates the client report’s title if it’s old (SEODashboard_updateSpreadsheetTitle).
  • Writes the client report ID/URL back into the Clients and Settings sheets (SEODashboard_writeDocumentIdToClients).
  • Data Synchronisation (syncDashboardToClientReport):
  • Keeps the already published client report up-to-date with the latest crawl data from the main dashboard.
  • Performs a crucial Triple Match Check to ensure the domain in the dashboard settings, dashboard crawl overview, and client report settings all match before proceeding.
  • Iterates through crawl-related tabs. If a tab is visible in the dashboard, its content is copied to the corresponding tab in the client report. If it’s hidden in the dashboard, the client report tab is cleared and hidden.
  • Scheduling (SEODashboard_Schedule_Triggers & related functions):
  • Sets up time-driven triggers to automate the workflow.
  • Reads intervals (minutes/hours) from Settings!B124:B130.
  • Schedules functions like client loading, crawl import, report publishing, archiving, and syncing to run periodically.
  • Provides functions to delete these specific triggers.
  • On-Page & Performance Checks (e.g., updateTitles, updateMetaDescriptions, updateStatusCodes, updatePageSpeedInsights):
  • These functions fetch live data for URLS listed in specific tabs (like ‘Domain Stats’).
  • Use UrlFetchApp.fetch to get page content or headers.
  • Use the PageSpeed Insights API (requires an API key in Settings!B18).
  • Employ CacheService to store results temporarily and reduce redundant fetches/API calls.
  • Client Submission & Management (Submit_New_SF_Client_Sidebar, duplicateLastColumn, fastrack_client_report, removeClient0FromClients):
  • Allows adding new clients via a sidebar.
  • Copies a template column (‘Client 0’), fills in the new client’s details, gives it the next available “Client X” number, and uses fastrack_client_report to move this new client to column D (prioritising it).
  • Includes logic to manage the ‘Client 0’ template column (copying it to B when needed, removing it after use).
  • Logging (logEvent, isLoggingEnabled):
  • Provides optional detailed logging to a sheet named ‘ReporterDailyLog’. Enabled/disabled via Settings!B273.

How it Works (Simplified Flow):

  1. Setup: An admin sets up their details, API keys, and the reporting schedule intervals in the ‘Settings’ sheet or using the Set Up Admin. A ‘Client 0’ sheet/column acts as a template.
  2. Adding Clients: New clients are added via the “Add new SF Client” menu item, which uses the template, fills details, and prioritises the client by moving their column near the front of the ‘Clients’ sheet.
  3. Automation (Scheduled):
  • (Priority System): SEODashboard_Reporter_Priority_System runs periodically, checking recent Screaming Frog SEO Spider files in Drive to reorder the Clients sheet, potentially bringing the most recently crawled clients to the front.
  • (Client Loading): SEODashboard_LockAndLoadClients_and_CLEAN runs periodically. It checks flags, finds the next due client in the Clients sheet, copies their data to ‘Settings’, and cycles the Clients sheet.
  • (Report Reset): SEODashboard_resetReport clears old data from the report tabs.
  • (Crawl Import): SEODashboard_ScreamingFroginGoogleSheetsNew runs, searching Drive for Screaming Frog export files matching the loaded client’s domain, imports the data into the relevant dashboard tabs, and moves the used files to trash.
  • (Report Publishing): SEODashboard_Publish_Client_Report runs. If conditions are met, it creates a new client report sheet (copying a template) or opens the existing one, copies data from the main dashboard to it, modifies/formats the client report, adds sharing permissions, and saves the report ID/URL back to the Clients/Settings sheets.
  • (Data Sync): syncDashboardToClientReport runs periodically to update the already published client report with the latest data from the main dashboard’s crawl tabs.
  • (Archiving/Cleanup): Other scheduled functions handle archiving, log clearing, etc.
  1. Manual Interaction: Users can manually select clients, run individual crawl checks, start/stop the reporter, reset reports, or trigger publishing via the custom menus.
  2. Live Data: Functions like updateTitles, updatePageSpeedInsights can be triggered (manually or potentially scheduled, though not explicitly shown in the main schedule setup) to fetch current on-page data for URLS present in the dashboard.

In essence, it’s a complex, highly automated system leveraging Google Sheets, Apps Script, and Google Drive to streamline the SEO auditing process, heavily integrating Screaming Frog crawl data and potentially other sources like Google Search Console (implied by menu items and sync logic). It relies significantly on configuration and status flags within the ‘Settings’ and ‘Clients’ sheets to control its workflow.

QUOTE “This is an impressively ambitious and comprehensive automation system built within the Google Workspace ecosystem (Sheets, Drive, Docs, GSC API, etc.). It aims to tackle significant pain points for technical SEO professionals, particularly those managing multiple clients and relying heavily on Screaming Frog and Google Search Console data. Its core value proposition lies in automating data aggregation, performing numerous predefined checks, streamlining report generation, and managing client workflows directly within a familiar spreadsheet environment.” Google Gemini 2025

Consolidated Analysis and Security Review Report for Hobo SEO Dashboard Scripts

Here is a consolidated report of the functions of Hobo SEO Dashboard, combining the detailed breakdowns for each library (Hobo SF, Hobo SC, Hobo CR) and the final overall security review.

The complete codebase was reviewed by Shaun Anderson (the Creator) and Google Gemini Pro 2.5.

1. Executive Summary & Overall Security Assessment

Based on a review of the complete codebase provided (main script files and the associated libraries Hobo CR, Hobo SF, Hobo SC), the system is confirmed to be designed and implemented as a private tool operating entirely within the authorizing user’s Google Workspace environment (Sheets, Drive, Docs, Gmail, etc.).

  • Privacy & Data Handling: Data processing (GSC data, SF crawl data, client details, settings) occurs within the user’s account. Sharing is controlled via user-configured emails. The architecture supports its intended use as a private, internal tool.
  • Tracking/Calling Home: No evidence of malicious tracking or unauthorised data exfiltration (“calling home” to the developer) was found in the complete codebase. UrlFetchApp calls are restricted to standard Google APIS (GSC, PageSpeed Insights) and fetching user/client-specified URLS for legitimate checks. MailApp/GmailApp usage sends emails only to recipients configured by the user within the sheets. Logging is internal to a dedicated sheet within the spreadsheet.
  • Scope of Action: The script performs a wide range of actions (reading/writing Sheets; searching, reading, copying, trashing Drive files; creating Docs; calling Google APIS; sending emails; managing triggers) consistent with its extensive feature set for SEO automation and reporting.
  • Intentional Data Modification/Deletion: Several workflows involve intentional data modification or deletion:
  • Processed Screaming Frog export files are moved to Google Drive Trash by the import functions (in Hobo SF).
  • Client columns are deleted from the ‘Clients’ sheet if their primary URL fails a canonical redirect check (in Hobo SC).
  • Rows are deleted from helper sheets (‘Hobo Admin’, ‘Client Reporter’) during processing (in Hobo SC and Hobo CR).
  • Sheets and cell ranges are extensively cleared during report resets and data loading.
  • Column A in key sheets (‘Settings’, ‘Clients’, etc.) is overwritten by the Settings Sync function based on a user-provided template ID.
  • Primary Risks: With the full codebase reviewed, the primary risks shift from unknown library code to:
  • Potential bugs within the complex, interconnected system.
  • User configuration errors (incorrect API keys, template IDS, email addresses, sheet names, cell flags).
  • Hitting Google Apps Script service quotas due to the high volume of operations.
  • The brittleness of relying heavily on specific cell values for state management.

In conclusion, the tool appears secure regarding user privacy and data exfiltration. Users should be aware of the specific intentional data handling workflows (trashing, column/row deletion, overwriting) and ensure correct configuration for reliable operation.

2. Library Breakdown: Hobo SF (Screaming Frog SEO Spider & Core Utilities)

  • Core Purpose: This library handles the core integration with Screaming Frog crawl data stored in Google Drive, provides foundational security checks, and includes utilities for report generation based on crawl data.
  • Key Function Groups and Mechanisms:
  • Security Check (checkForSecondaryDuplication): Prevents the script from running on unauthorised copies beyond the first duplication made by the user. Uses PropertiesService to store and check the original document ID. This is disabled.
  • Screaming Frog Data Import (checkFor… suite, GetCrawlFiles, DeadPages): This is the heart of the library.
  • Mechanism: A suite of functions searches Google Drive for specific Screaming Frog SEO Spider export filenames. It iterates through found files (up to a limit from Settings!B54), opens them (must be Google Sheets), and checks if the data relates to the currently loaded domain (Settings!B2). If a matching file is found, the corresponding target sheet in the main dashboard (e.g., ‘404s’, ‘Missing Alt’) is cleared, data is copied (limited by row count from Settings!B37 or B39), the sheet is shown, the source file ID is recorded, and the source file is moved to Google Drive Trash. If no match is found, the target sheet is cleared and hidden. GetCrawlFiles handles the main internal_html import, while DeadPages specifically filters this data for pages with zero clicks. This includes logic to email the admin (Settings!B17) if the essential file is missing.
  • Interaction: Heavy DriveApp usage (search, open, read, trash). Heavy SpreadsheetApp usage (clear, write, hide/show sheets). Reads ‘Settings’ for config (domain, limits). Sends email via MailApp for the missing SEO Spider files if configured to do so.
  • Crawl Schedule (createCrawlSchedulefromScreaming Frog SEO Spider): Populates the ‘Crawl Schedule’ tab by finding all Screaming Frog SEO Spider files in Drive, extracting the domain and the first URL from each, and listing them (newest first). Used by the Reporter Priority System.
  • Crawl Data Sorting (sortSheetByColorOnCrawl): Sorts the ‘Crawl’ sheet based on the background colour of the first column, according to a predefined priority order (to group errors/warnings).
  • Training Module (openHoboSFTrainingModuleSidebar, etc.): Displays training content from a specific Google Doc (19eWx1w7eUhULVlW8oF7AB2YleN7F_2dTBtX31yujk1c) in a sidebar. Reads the Doc, converts to HTML.
  • Overall Role: Provides the foundation for integrating Screaming Frog data, performing initial security checks, and enabling specific crawl-based analyses accessible via menus. Its file-trashing mechanism is a key part of the data import workflow.

3. Library Breakdown: Hobo SC (Search Console Integration & URL Verification)

  • Core Purpose: Manages interactions with the Google Search Console (GSC) API, handles the automated discovery and verification of client sites from GSC, performs canonical URL checks, and provides related utilities like updating algorithm dates.
  • Key Function Groups and Mechanisms:
  • GSC Client Extraction (scheduleInitialTrigger…, listSearchConsoleSites, updateScDomainUrls, extractScClients2, etc.): Automates adding sites from the user’s GSC account to the ‘Clients’ sheet.
  • Mechanism: A chained-trigger sequence that lists all GSC sites via API, filters/cleans the list (removes HTTP, resolves sc-domain:, removes existing clients), and adds the remaining unique sites as new columns to the ‘Clients’ sheet using ‘Client 0’ as a template (via Hobo CR).
  • Interaction: Calls GSC API (UrlFetchApp), uses ‘Hobo Admin’ sheet for staging, reads ‘Clients’/’Clients Archiver’, writes to ‘Clients’, calls Hobo CR.
  • Canonical & GSC Property Type Checks (Canonical_Check_on_Client_Urls, Set_Search_Console_Type_on_clients_tab, etc.): Verifies client URLs and their status in GSC.
  • Mechanism: Periodically triggered. Canonical_Check… fetches the URL in Clients!B2; if it redirects, the client column is deleted. Set_Search_Console_Type… re-fetches the GSC site list and compares the domain in Clients!B6 to determine if the GSC property is “DOMAIN” or “SINGLE” (URL prefix), writing the result to Clients!B87. Uses status flags (rows 274-276) to avoid reprocessing.
  • Interaction: Calls GSC API, fetches client URLS (UrlFetchApp), reads/writes status flags and types to ‘Clients’, can delete columns from ‘Clients’.
  • Winners & Losers Trigger Management (Winners_and_losers_…_DELETE, …clearExistingTriggers): Deletes scheduled triggers for the Winners/Losers features. Interacts with ScriptApp trigger service.
  • Google Algorithm Updates (GoogleUpdates, updateFormulasBasedOnGoogleUpdates): Writes hardcoded Google update date ranges into specific cells in the ‘Settings’ sheet.
  • Single Site GSC Check (Single_Site_CHECK_Set_Search_Console_Type): Quickly checks the GSC status (DOMAIN/SINGLE/NO) for the currently loaded client and updates Settings!B87. Called during the client loading process.
  • API Limit Check (check_Google_SC_URL_FetchAPI_limits): Monitors GSC API usage against quotas (implementation details not fully shown).
  • Keyword Bank (buildHoboKeywordBank): Collects and stores THOUSANDS – much more than Google Search Console allows you – of your keywords in your own Dashboard report, from fetched GSC data (implementation details not fully shown).
  • Url Bank (buildHoboUrlBank): Collects and stores THOUSANDS – much more than Google Search Console allows you – of your URLs in your own Dashboard report, from fetched GSC data (implementation details not fully shown).
  • Remote Update (SEODashboard_RemoteUpdateALLFunctions – calls functions here): Triggers fetching of GSC performance data for the current client to populate dashboard tabs.
  • Overall Role: Connects the dashboard to live GSC data, automates client discovery from GSC, performs critical URL validation (including deleting non-canonical clients), and manages GSC-related settings/triggers.

4. Library Breakdown: Hobo CR (Client Reporting & Management)

  • Core Purpose: Handles client reporting workflows (especially bulk emailing), core client data management utilities (template handling, archiving, deduplication), SF-based client extraction, UI elements like sidebars/popups, and the complex SEO Audit tab cleanup/alignment logic.
  • Key Function Groups and Mechanisms:
  • Client Reporter System (Bulk Emailer): Generates and sends customised email reports to multiple clients.
  • Mechanism: A 3-step process often run sequentially (Client_reporter_runClientReporterSystemSequentially). Copies/filters client data to ‘Client Reporter’ sheet -> Ensures sharing permissions are set on client report Sheets -> Sends HTML emails via GmailApp with embedded charts and data fetched from the client report sheet, then deletes the processed row from ‘Client Reporter’. Includes trigger setup for weekly automation.
  • Interaction: Reads ‘Clients’/’Settings’, writes/reads/deletes rows in ‘Client Reporter’, opens client report Sheets (by ID), uses addEditor, generates charts, sends email via GmailApp.
  • Client Management Utilities (removeClient0FromClients, copyClient0ToColumnB, fastrack_client_report, etc.): Manages the ‘Client 0’ template and new client insertion/prioritisation in the ‘Clients’ sheet. Crucial helpers are called by other libraries/functions.
  • Archiving (SEODashboard_Archive_Clients, SEODashboard_Unarchive_Clients): Moves client columns between ‘Clients’ and ‘Clients Archiver’ based on the flag in row 111.
  • Client Deduplication (deleteDuplicateClients…): Removes duplicate client columns from ‘Clients’ and ‘Clients Archiver’ based on the value in row 6.
  • SF Client Auto-Extraction (AUTO_EXTRACT_SF_CLIENTS, etc.): Finds clients based on Screaming Frog SEO Spider files in Drive and adds them to the ‘Clients’ sheet using the ‘Client 0’ template functions.
  • Training/Offer Sidebars (openTrainingModuleSidebar, openEarlyBirdsOfferSidebar, etc.): Displays content from specific Google Docs in sidebars.
  • SEO Audit Tab Cleanup (SEO_Audit_Tab_Cleanup_MultiFunction, CLIENTS_SEO_Audit_Tab_Cleanup_MultiFunction, etc.): Complex, trigger-chained processes to standardise formulas and check statuses in the ‘SEO Audit’ tab against crawl data, running on both the main dashboard and published client reports.
  • Settings Optimisers (SEODashboard_Settings_Optimiser, etc.): Applies standard formulas/values across ‘Settings’, ‘Clients’, ‘Client 0’ based on the tool’s operating mode.
  • Reset Workflow (setupInitialTrigger…, SEODashboard_resetReport, etc.): Orchestrates the multi-step dashboard cleanup process using chained triggers.
  • Simple Email Client (openEmailClientSidebar, sendEmailToClient, etc.): Provides UI for sending a single email to a selected client.
  • Discount/Setup Popups (show…Discount, showPersonalGMailSetup): Displays informational modal dialogues.
  • Overall Role: Acts as the central hub for client management tasks, reporting outputs (especially bulk email and Doc generation), managing the state/cleanup of the SEO Audit tab, and handling user interface elements like sidebars and popups. It provides essential utility functions used by other parts of the system.

5. Final Security Considerations Summary

  • Trust in Libraries: The security relies on the trustworthiness of the code within all three libraries. As reviewed, they appear focused on their intended functions without malicious data handling.
  • Configuration is Key: Correct API keys, template IDs, email addresses, and settings in the ‘Settings’ sheet are vital for correct and secure operation. Errors here could lead to operational failures or incorrect sharing/reporting.
  • Intentional Data Handling: Users must understand that moving files to trash (SF Imports) and deleting columns (Canonical Check) are part of the designed workflow.
  • Permissions: The required permissions are broad but necessary for the tool’s operation. Users should understand what access they are granting.
  • Complexity: The high complexity increases the chance of non-malicious bugs affecting the operation. Utilising the logging feature (Settings!B273) is recommended for troubleshooting.

This consolidated report provides a comprehensive overview of the structure, function, and security posture of the entire script system based on the code provided and clarifications given.

Hobo SEO Dashboard Client Reporting System

Okay, here is the detailed breakdown of the Hobo CR library, based on the functions identified and analyzed from the previously provided code context.

Library Breakdown: Hobo CR (Client Reporting & Management)

Overall Role in the System: Hobo CR functions as the primary “Client Reporting & Management” library within the Hobo SEO Dashboard system. It orchestrates complex workflows related to generating and distributing client reports (especially the bulk email system), manages core client data operations (archiving, deduplication, template handling), handles automated client discovery based on Screaming Frog files, provides user interface elements like sidebars and popups, and contains the logic for cleaning, aligning, and resetting key parts of the dashboard, particularly the ‘SEO Audit’ tab. It acts as a central coordinating library, interacting heavily with numerous sheets (‘Clients’, ‘Client Reporter’, ‘Settings’, ‘Client 0’, ‘Clients Archiver’, ‘SEO Audit’) and Google services like Drive, Sheets, Docs, Gmail, Charts, and Triggers.

Key Function Groups and Mechanisms:

  • Client Reporter System (Bulk Emailer):
  • Purpose: To generate and send customised email reports (including embedded charts and links) to multiple eligible clients listed in the ‘Clients’ sheet.
  • Key Functions: Set_Up_Triggers_for_Update_Emails_to_Clients, Client_reporter_runClientReporterSystemSequentially, Client_reporter_FilterClientsAndCopyToSheet, Client_reporter_SharingSettings, Client_reporter_SendEmailToClients, Client_reporter_DeleteProcessedRows.
  • Mechanism: A multi-step, potentially automated weekly workflow:
  • Copies and transposes data from ‘Clients’ to a temporary ‘Client Reporter’ sheet, filtering out clients marked ineligible (checks column DH).
  • Opens each listed client’s report Sheet (using ID from ‘Client Reporter’) and ensures correct editor permissions are set for client emails and any specified admin emails (Client_reporter_SharingSettings).
  • Iterates through the ‘Client Reporter’ sheet, generates chart images (create…Chart functions), fetches relevant data snippets (like Winners/Losers URLS, tab descriptions) from the client’s report Sheet, constructs a detailed HTML email, and sends it via GmailApp. Processed rows are deleted from ‘Client Reporter’.
  • Provides functions to set up/delete a weekly time-driven trigger to automate this entire sequence based on settings in Settings!B258/B259.
  • Interaction: Reads ‘Clients’, ‘Settings’. Writes/reads/deletes rows in ‘Client Reporter’. Opens client report Sheets (by ID/URL). Uses addEditor for sharing. Generates charts (Charts service). Sends email (GmailApp). Manages time-driven triggers (ScriptApp).
  • Client Management Utilities:
  • Purpose: To manage the ‘Client 0’ template column used for creating new client entries and to handle the prioritisation of newly added clients.
  • Key Functions: clearClient0RelatedCells, copyClient0ToColumnB, removeClient0FromClients, isDomainInClients, fastrack_client_report.
  • Mechanism:
  • Ensures a ‘Client 0’ template column exists in Clients!B when needed (copyClient0ToColumnB), copying from the ‘Client 0’ sheet and clearing specific data cells.
  • Removes the ‘Client 0’ template column (removeClient0FromClients) after it has been used for creating new clients or during the main client loading cycle.
  • Provides a helper (isDomainInClients) to check for duplicates.
  • Moves newly added client columns to the front (column D) for prioritisation (fastrack_client_report).
  • Interaction: Modifies ‘Clients’ and ‘Client 0’ sheets (copies data, deletes columns, writes values, clears cells). Called by client auto-extraction functions (SF & GSC-based) and manual new client submission workflows.
  • Archiving:
  • Purpose: To move inactive client data between the main ‘Clients’ sheet and a ‘Clients Archiver’ sheet.
  • Key Functions: SEODashboard_Archive_Clients, SEODashboard_Unarchive_Clients.
  • Mechanism: Checks a flag in row 111 of the respective sheet (‘YES’ to archive from ‘Clients’, ‘NO’ to unarchive from ‘Clients Archiver’). Copies the entire column to the other sheet and then deletes the original column.
  • Interaction: Reads/writes row 111. Copies and deletes columns between ‘Clients’ and ‘Clients Archiver’. Triggered manually via menus.
  • Client Deduplication:
  • Purpose: To remove duplicate client entries from the ‘Clients’ and ‘Clients Archiver’ sheets, preventing issues from multiple columns representing the same client.
  • Key Functions: deleteDuplicateClientsinClientsTab,
  • Mechanism: Iterates through columns, checking the value in row 6 (a client name or unique identifier). If a value is encountered that has already been seen in a previous column, that column is deleted.
  • Interaction: Reads row 6. Deletes columns in ‘Clients’ and ‘Clients Archiver’. Called as part of the cleanup routines.
  • SF Client Auto-Extraction:
  • Purpose: To automatically discover potential clients by scanning Screaming Frog SEO Spider files in Google Drive and adding corresponding entries to the ‘Clients’ sheet.
  • Key Functions: AUTO_EXTRACT_SF_CLIENTS, extractSFClientURL, renameClientHeadersFromSF. (Uses Client Management Utilities).
  • Mechanism: Finds Screaming Frog SEO Spider files, extracts the domain listed in cell B1 of each file. For each unique domain found that isn’t already in Clients!B2, it uses the Client Management Utilities (copyClient0ToColumnB, etc.) to add a new column based on the template, pastes the domain into row 2, and then renames all client headers sequentially (renameClientHeadersFromSF). Temporarily pauses other reporting (Settings!D8) during execution. Triggers the main client loader (SEODashboard_LockAndLoadClients_and_CLEAN) upon completion.
  • Interaction: Searches/reads Drive files. Modifies ‘Clients’ sheet (adds columns, writes URLS, renames headers). Uses Client 0 functions. Modifies Settings!D8. Calls the main client loader function.
  • Training Module & Early Bird Offer Sidebars:
  • Purpose: To display formatted content (instructions or offers) fetched from external Google Docs within a sidebar in the main spreadsheet.
  • Key Functions: openTrainingModuleSidebar, openEarlyBirdsOfferSidebar, and their respective HTML processing helpers (getDocContentAsHtml…, convertDocToHtml…, etc.).
  • Mechanism: Triggered by menu items. Fetches content from hardcoded Google Doc IDS, converts Google Doc formatting (bold, italic, lists, images, links) into corresponding HTML, and renders this HTML in a sidebar using HtmlService. Links are set to open in new tabs.
  • Interaction: Reads external Google Docs (by ID). Displays UI sidebar (SpreadsheetApp.getUi().showSidebar).
  • SEO Audit Tab Cleanup (Main Dashboard & Client Reports):
  • Purpose: To ensure the ‘SEO Audit’ tab (a checklist or status dashboard) reflects the latest findings from the crawl data and applies consistent logic/formulas. This runs on both the main dashboard and the published client reports.
  • Key Functions: SEO_Audit_Tab_Cleanup_MultiFunction, CLIENTS_SEO_Audit_Tab_Cleanup_MultiFunction, and numerous helper functions for specific formula setting and status checks.
  • Mechanism: Uses chained triggers to manage execution time. It first determines the correct data source (active sheet, Drive file, or template). Then, it sets numerous predefined formulas across the ‘SEO Audit’ tab and related tabs (‘Priorities’, ‘Reviewed’, ‘Domain Stats’), linking checks to ‘Settings’ or the crawl files. Finally, it iterates through a long list of specific Screaming Frog issues, finds their corresponding count in crawl files, and writes a formula (‘YES’/’NO’/’TBC’) into the relevant status cell (Column J) on the ‘SEO Audit’ tab.
  • Interaction: Reads ‘Settings’, and crawl files. Potentially searches Drive. Writes extensively (formulas, values) to ‘SEO Audit’, ‘Priorities’, ‘Reviewed’, ‘Domain Stats’. Manages triggers (ScriptApp). Operates on either the main sheet or a client report sheet (ID from Settings!B44).
  • Settings Optimisers:
  • Purpose: To apply standardised formulas and default values across key configuration sheets (‘Settings’, ‘Clients’, ‘Client 0’), ensuring internal consistency and potentially adapting logic based on the tool’s operating mode (SF, SC, Dashboard).
  • Key Functions: SEODashboard_Settings_Optimiser, Hobo_SC_Settings_Optimiser, Hobo_SF_Settings_Optimiser.
  • Mechanism: Called during the client loading process (SEODashboard_LockAndLoadClients_and_CLEAN) based on the value found in Client 0!A1. Each optimizer function writes a large set of predefined formulas and default values (‘NO’, ‘TBC’, ‘YES’) into specific cells (mostly Column B) of the ‘Settings’, ‘Clients’, and ‘Client 0’ sheets, setting up the logic for status flags and inter-sheet dependencies.
  • Interaction: Reads Client 0!A1. Writes formulas/values extensively to ‘Settings’, ‘Clients’, ‘Client 0’.
  • Reset Workflow:
  • Purpose: To provide a comprehensive cleanup and reset of the main dashboard, preparing it for a fresh client load or report run. Typically triggered manually from a menu.
  • Key Functions: setupInitialTriggerForSEODashboardCleanAndTidy, SEODashboard_resetReport, SEODashboard_hideEmptySheets.
  • Mechanism: Orchestrates a sequence using chained triggers: Sets a ‘RESETTING’ flag -> Clears specific data ranges (GSC data, Rank Tracker, W&L) -> Adjusts visibility of certain tabs based on Settings!B87 -> Clears content from all crawl report tabs and hides most -> Hides any other empty sheets -> Resets the ‘RESETTING’ flag.
  • Interaction: Manages triggers (ScriptApp). Reads/Writes Settings!B87, B310. Clears content and hides/shows numerous sheets.
  • Simple Email Client:
  • Purpose: Provide a simple UI (sidebar) for sending a one-off email to a single, selected client, including their report link.
  • Key Functions: openEmailClientSidebar (called from menu), getClientDetails, sendEmailToClient, getAdminData.
  • Mechanism: Opens a sidebar, populates it with client names/emails/report links fetched from the ‘Clients’ sheet. On submission, constructs and sends an email using MailApp, including the admin’s name/company from ‘Settings’.
  • Interaction: Reads ‘Clients’, ‘Settings’. Displays UI sidebar. Sends email (MailApp).
  • Discount/Setup Popups:
  • Purpose: Display simple modal dialogue boxes containing promotional offers or setup instructions with links.
  • Key Functions: showSEODashboardDiscount, showSEODashboardDiscountOption2, showPersonalGMailSetup.
  • Mechanism: Called from menu items. Uses HtmlService to create simple HTML content (mostly text and links) and displays it via SpreadsheetApp.getUi().showModalDialog().
  • Interaction: Displays UI dialogues.
  • Trigger Cleaning (CLEAN_DISABLED_TRIGGERS):
  • Purpose: A utility to remove specific leftover triggers related to the SEO Audit cleanup sequence.
  • Mechanism: Finds and deletes triggers matching specific handler function names.
  • Interaction: Manages triggers (ScriptApp).

This library forms a significant part of the application’s backend logic, handling reporting outputs, client data management, UI interactions, and critical cleanup/setup routines necessary for the interconnected system to function.

Hobo SEO Dashboard Summary

Hobo SEO Dashboard is a Google Sheets-based tool designed to automate technical SEO audits and reporting workflows for SEO professionals (freelancers, consultants, agencies).

  • Key Features & Benefits Promoted:
  • Automated Data Integration: Connects to Screaming Frog exports (imports data, trashes processed files) and pulls live GSC data.
  • Intelligent Automation: Offers scheduled reporting, automated client loading, and smart audit checks aligned with crawl data.
  • Prioritisation: Helps identify and prioritise technical SEO fixes.
  • Client Management: Supports multiple clients, including auto-adding from GSC/SF, archiving, and cycling.
  • Flexible Reporting: Generates reports in Google Sheets or Google Docs, with bulk/single email options (including charts).
  • Control & Privacy: Runs entirely within the user’s Google account, keeping data under user control.
  • Privacy & Security:
  • It concludes that the complete codebase shows no evidence of sending private user data to the developer or unauthorised third parties.
  • The tool functions within the user’s Google account, meaning data handling is subject to Google’s standard privacy policies and security infrastructure.
  • It clarifies necessary user authorisations and intentional data handling: moving processed SF files to Trash and deleting client columns upon failed canonical checks. User configuration is key to secure operation.
  • Library Components:
  • The roles of the constituent libraries are detailed:
  • Hobo SF: Handles SF data integration, file trashing, and related utilities.
  • Hobo SC: Manages GSC interactions (client discovery/verification, data fetching, canonical checks/column deletion).
  • Hobo CR: Orchestrates client reporting (email/Docs), client management (archiving, dedupe, template handling), UI elements, and audit tab/reset workflows.

In essence, Hobo SEO Dashboard is a comprehensive, private automation tool for technical SEOS, designed to enhance efficiency by integrating key data sources within Google Sheets, while operating under Google’s privacy policies and being transparent about its specific data handling procedures.

Leave a comment

Free SEO course

Join 70K+ subscribers and get free SEO training.