In our test, one LibreOffice import read 1/2 as January 2 under US settings and February 1 under UK settings.
Before you open a CSV with IDs, ZIP codes or codes like 3-4, import it with every column set to Text, then convert only the columns you know are numbers or dates.
Open a CSV in Excel and it decides what each field is. ZIP code 02134 becomes the number 2134, an 18-digit order ID loses its last three digits, and a fraction like 1/2 can turn into a date. Microsoft’s own support page says Excel removes leading zeros and rounds anything past the 15th digit. Once it has done that, formatting cannot bring the data back.
This guide shows why it happens, what each fix does, and when each one fails. We built a test CSV with 12 trap columns and ran it through LibreOffice’s importer, pandas and a short Python script that writes an Excel file with nothing guessed. We did not have Excel in our test environment, so the Excel steps come from Microsoft’s documentation and are marked as such. Sources were read on October 21, 2026.
\nThe CSV format’s reference document, RFC 4180, says there is “no formal specification” and describes only records, commas and quotes. Nothing in the file can say “this column is text”. So the program that opens it has to guess from what each value looks like.
\nExcel’s guess runs at the moment data comes in. Microsoft’s automatic data conversion page lists when: opening a .csv or .txt file, typing, and pasting from outside sources. It names four conversions:
\n00123 becomes the number 123 (leading zeros removed).12345678901234567890 becomes 12345678901234500000 or 1.23457E+19, because Excel keeps 15 digits of precision.123E5 becomes 1.23E+07, read as scientific notation.JAN1 becomes the date January 1.The damage happens on the way in. Microsoft says a custom number format such as 00000 “will not restore leading zeros that were removed prior to formatting”. The same holds for digits past the 15th: they are gone from the cell, not hidden.
This is not a rare edge case. In 2016, Mark Ziemann, Yotam Eren and Assam El-Osta screened supplementary files from 18 genomics journals published from 2005 to 2015. They confirmed gene name errors in 987 files from 704 papers: 19.6% of the papers with Excel gene lists. Gene symbols such as SEPT2 and MARCH1 had become 2-Sep and 1-Mar, and a RIKEN identifier, 2310009E13, had become 2.31E+13.
The fix that stuck was renaming the genes. The HUGO Gene Nomenclature Committee’s 2020 guidelines in Nature Genetics report that “all symbols that auto-converted to dates in Microsoft Excel have been changed”. SEPT1 is now SEPTIN1, and MARCH1 is now MARCHF1. Your part numbers and customer IDs will not get renamed, so the fix has to happen at import.
We wrote a two-row CSV with 12 columns, each holding a value type that spreadsheets are known to change. Every value in it is made up.
\nzip,employee_id,order_id,gene,gene_2,promo_code,portion,part_no,accession,product_code,phone,ship_date\n02134,00123,123456789012345678,SEPT2,MARCH1,JAN1,1/2,3-4,2310009E13,1E5,+46701234567,03/04/2026\n07030,00456,987654321098765432,SEPT9,MARCH5,DEC25,3/4,10-12,4930430E12,2E10,+14155550100,12/05/2026We opened it seven ways on Linux on October 21, 2026, and counted how many of the 24 data cells came back different from the file. The LibreOffice runs used version 24.2.7.2, converting to .xlsx from the command line, with each result read back with openpyxl 3.1.5. Here is what changed.
\n| Route | \nCells changed (of 24) | \nWhat went wrong | \n
|---|---|---|
| LibreOffice, default import | \n12 | \nZeros dropped, order IDs cut to 15 digits, 2310009E13 and 1E5 read as numbers, + dropped from phones | \n
| LibreOffice, “detect special numbers” on, English (US) | \n16 | \nAll of the above, plus 1/2 read as January 2 and 03/04/2026 as March 4 | \n
| LibreOffice, “detect special numbers” on, English (UK) | \n18 | \nAll of the above, but 1/2 read as February 1, 03/04/2026 as April 3, and 3-4 as April 3 | \n
| LibreOffice, every column set to Text | \n0 | \nNothing | \n
pandas 3.0.5, read_csv defaults | \n10 | \nZeros dropped, + dropped, accession numbers and 1E5 read as floats | \n
pandas, dtype=str, keep_default_na=False | \n0 | \nNothing | \n
| Our script (below) | \n0 | \nNothing, and a LibreOffice re-export matched the source byte for byte | \n
Guess before you read on: which value was the most dangerous? Not the dropped zeros, which are visible. The fraction column was worse.
\nThe same file, imported with the same program, gave 1/2 as January 2 under US settings and February 1 under UK settings. Both looked like valid dates, and both took the current year (2026), which was never in the file.
Two smaller findings. First, LibreOffice stored the order ID as 1.23456789012346E+017 in the saved file, so the digits after the 15th were gone from the workbook itself, not just from the display.
Second, LibreOffice left SEPT2, MARCH1 and JAN1 alone in every setting we tried, while Microsoft’s page says Excel turns JAN1 into a date. Results from one program do not predict another. LibreOffice’s import documentation confirms the locale effect: with “Detect special numbers” on, “the selected language influences how such special numbers are detected”.
The fix that worked in every route we tried is the same idea in each program: tell the importer the type of each column before it reads a single value. Text is the safe default, because text can always become a number later, and a number cannot become the original text again.
\nExcel, Power Query (from Microsoft’s documentation; we did not run Excel). Microsoft’s steps are:
\nTwo settings on the same preview screen matter for this too. File Origin sets the character set, and the documentation says UTF-8 is only recognized automatically when the file starts with a UTF-8 byte-order mark. Delimiter offers comma, semicolon, tab and others, for files that do not use commas.
\nThe trade-off: a query is a saved recipe, so refreshing it next month applies the same types again. That is good for a monthly export with a fixed layout and annoying for a one-off file. And if a new column appears later, check its type by hand; the recipe was built for the old layout.
\nExcel, the old wizard (from Microsoft’s documentation, untested). Microsoft’s import page says that opening a CSV directly uses “the current default data format settings”. Renaming the file from .csv to .txt before opening it starts the Import Text Wizard instead.
\nThe wizard’s page also gives a menu route. Turn on File, Options, Data, Show legacy data import wizards, From Text (Legacy), then choose Data, Get Data, Legacy Wizards, From Text (Legacy). In step 3, select each column in the preview and set Column data format to Text. It is quicker than Power Query for a single file and saves nothing for next time.
\nLibreOffice Calc. In the Text Import dialog, select the columns in the preview and set Column type to Text. On the command line, the CSV filter options take column/format pairs in the fifth token, where format code 2 means Text. This is the string we ran for our 12 columns:
\nsoffice --headless --convert-to xlsx \\\n --infilter=\"CSV:44,34,76,1,1/2/2/2/3/2/4/2/5/2/6/2/7/2/8/2/9/2/10/2/11/2/12/2,1033,false,false,,,,,,,false\" \\\n traps.csvThe first four tokens are comma (44), double quote (34), UTF-8 (76) and start at line 1. The token after the pairs, 1033, is the language: English (US).
\nThe empty tokens that follow leave formula evaluation off, and the final false turns off scientific-notation detection. Our locale runs left the column types at Standard and set token 8, “Detect special numbers”, to true. Then switching 1033 to 2057 (English, UK) moved our dates from the second table row to the third.
pandas. pd.read_csv(\"file.csv\", dtype=str, keep_default_na=False) read all 24 cells exactly in our test. keep_default_na=False matters as well: by default pandas reads “N/A”, “NULL” and other common markers as missing. In a separate check, dtype=str alone turned the country code NA (Namibia) and the text null into empty values; with keep_default_na=False both survived.
Microsoft added settings for each of the four conversions. The page lists Excel for Microsoft 365 and Excel 2024, on Windows and Mac:
\nUnder it are four options. Clear the ones you do not want:
\nKnow the limits before you rely on it. The date option covers continuous letters and numbers like JAN1. Microsoft notes that JAN 1 or JAN-1 may still be read as dates, and the page does not say whether values like 1/2 or 3-4 are covered. We could not test it without Excel, so assume they are not.
The settings live in each person’s copy of Excel, so a colleague who opens the same file sees the old behavior. Microsoft also says the options do not apply to Power Query, which has its own types. Older versions, such as Excel 2021 or 2019, are not on the page’s list.
\nOur view: switch them off on your own machine, and still use Fix 1 for any file that matters. A setting that differs per person is not a process.
\nWhen you type into a cell rather than import, Microsoft’s page on stopping numbers changing to dates gives four ways:
\n'1/47. The apostrophe is not shown.0 1/2 for the fraction one half.These fit a handful of entries, not a 5,000-row export. The leading space in particular is a trap of its own: the cell now holds “ 1/2”, which will not match “1/2” in a lookup.
\nIf a CSV arrives every week from the same system, the most reliable route is to skip the import step entirely. A script reads the file as plain text and writes an .xlsx in which every column is text unless you named it as a number or a date. The receiver opens a workbook, and no program has anything left to guess.
\nThe script below does that with Python and openpyxl. It also formats text columns as Text (@), so values someone types into them later stay text too. Then it reads the saved file back and stops if any text cell differs from its CSV field. It writes to a temporary file first, so a failed run leaves no half-finished workbook.
One trap we found while building it: openpyxl stores any string that starts with = as a formula. In our edge-case file, a field =1+2 saved by a plain append came back from LibreOffice as 3. The script forces those cells back to text, which also stops a CSV field from running as a formula in the receiver’s spreadsheet.
\"\"\"Turn a CSV into an .xlsx where nothing is guessed.\n\nEvery column is stored as text unless you name it:\n --number amount,qty stored as numbers (a value that is not a plain number stops the run)\n --date ship_date=%m/%d/%Y stored as real dates, read with the format you give\n\nUsage: python csv_to_xlsx.py input.csv output.xlsx [--number ...] [--date ...]\n\"\"\"\nimport argparse, csv, os, sys, tempfile\nfrom datetime import datetime\nfrom openpyxl import Workbook, load_workbook\n\np = argparse.ArgumentParser()\np.add_argument(\"src\")\np.add_argument(\"dst\")\np.add_argument(\"--number\", default=\"\", help=\"comma-separated column names\")\np.add_argument(\"--date\", action=\"append\", default=[], help=\"column=strptime format\")\np.add_argument(\"--delimiter\", default=\",\")\na = p.parse_args()\n\n# utf-8-sig drops a byte-order mark at the start of the file, if there is one\nwith open(a.src, newline=\"\", encoding=\"utf-8-sig\") as f:\n rows = list(csv.reader(f, delimiter=a.delimiter))\nif not rows:\n sys.exit(f\"{a.src} is empty, nothing written\")\n\nheader = rows[0]\nnumbers = {c for c in a.number.split(\",\") if c}\ndates = dict(d.split(\"=\", 1) for d in a.date)\nmissing = (numbers | dates.keys()) - set(header)\nif missing:\n sys.exit(f\"no such column(s): {', '.join(sorted(missing))}\")\n\ndef convert(col, value, line):\n if value == \"\":\n return None # an empty cell stays empty\n try:\n if col in numbers:\n if \"_\" in value: # Python reads 1_000 as 1000; a CSV should not\n raise ValueError\n return float(value) if any(ch in value for ch in \".eE\") else int(value)\n if col in dates:\n return datetime.strptime(value, dates[col]).date()\n except ValueError:\n sys.exit(f\"line {line}, column {col}: {value!r} is not a {'number' if col in numbers else dates[col] + ' date'}\")\n return value # everything else: text, exactly as in the file\n\nwb = Workbook()\nws = wb.active\nws.append(header)\nfor line, row in enumerate(rows[1:], start=2):\n if len(row) != len(header):\n sys.exit(f\"line {line} has {len(row)} fields, the header has {len(header)}\")\n ws.append([convert(c, v, line) for c, v in zip(header, row)])\n\n# Format text columns as Text (@) so values typed into them later stay text too.\n# openpyxl stores any string that starts with \"=\" as a formula; force those back to text.\nfor i, col in enumerate(header, start=1):\n fmt = \"yyyy-mm-dd\" if col in dates else (\"General\" if col in numbers else \"@\")\n for (cell,) in ws.iter_rows(min_col=i, max_col=i, min_row=2):\n cell.number_format = fmt\n if fmt == \"@\" and isinstance(cell.value, str):\n cell.data_type = \"s\"\n\n# Write to a temporary file and rename, so a failed run never leaves half a workbook\nfd, tmp = tempfile.mkstemp(suffix=\".xlsx\", dir=os.path.dirname(os.path.abspath(a.dst)))\nos.close(fd)\ntry:\n wb.save(tmp)\n # Read it back: every text cell must equal its CSV field exactly\n back = list(load_workbook(tmp).active.iter_rows(values_only=True))\n for line, (want, got) in enumerate(zip(rows[1:], back[1:]), start=2):\n for col, w, g in zip(header, want, got):\n if col not in numbers and col not in dates and (g or \"\") != w:\n sys.exit(f\"read-back mismatch, line {line}, column {col}: {w!r} became {g!r}\")\n os.replace(tmp, a.dst)\nfinally:\n if os.path.exists(tmp):\n os.remove(tmp)\nprint(f\"{a.dst}: {len(rows) - 1} rows, {len(header)} columns, \"\n f\"{len(header) - len(numbers) - len(dates)} as text; read-back check passed\")To use it:
\npip install openpyxl.csv_to_xlsx.py.$ python csv_to_xlsx.py traps.csv typed.xlsx --date ship_date=%m/%d/%Y\ntyped.xlsx: 2 rows, 12 columns, 11 as text; read-back check passedWith no options, all 12 columns stayed text, all 24 cells matched the file, and LibreOffice’s own CSV export of the workbook was identical to the source. With --date, the two ship dates became the real dates March 4 and December 5, 2026, because we said which format the file uses instead of letting a locale decide.
We also ran it on the failures you will meet. These were an empty file, a short row, a column name that does not exist, 12 USD in a number column and a date in the wrong format. Each stopped the run with the line and column named, and left no output file behind. A file with a byte-order mark, a quoted field with a comma in it and an empty amount came through correctly.
When not to use it: the script reads the whole file into memory. We ran it only on small files, so try it on a copy before a large export. It does not handle thousands separators (1,250.00) in number columns; it stops on them, so clean those first or leave the column as text. And a worksheet holds at most 1,048,576 rows, per Microsoft’s limits page, so a larger CSV needs a different plan.
If your own system or script writes the CSV, two habits reduce the damage on the other side. Write dates as 2026-03-04 (year, month, day). In our LibreOffice runs it read as March 4 under both US and UK settings. And when the receiver opens files in Excel, send an .xlsx with typed columns instead, made with the script above.
Do your CSVs come out of email or a PDF in the first place? Our guides to getting email data into Excel and bank statement PDFs to Excel cover the step before this one. More on the automation topic page.
\ndtype=str, keep_default_na=False in pandas, or Python’s csv module, where “no automatic data type conversion is performed” unless you ask for it.Whichever route you pick, test it once on a real export before you trust it. Find a row with a leading zero, a long ID and a date where the day is 12 or lower, and compare them with the CSV opened in a text editor. If 02134 is still 02134, the import did its job.
On October 21, 2026, we wrote a two-row CSV with 12 trap columns of made-up values. We opened it on Linux with LibreOffice 24.2.7.2 under four import settings, pandas 3.0.5 in two ways and the script in this guide (Python 3.13, openpyxl 3.1.5), and read every result back cell by cell; the script also ran on small edge-case files. We read Microsoft’s support and Power Query pages, LibreOffice’s CSV filter documentation, the pandas reference, RFC 4180 and the two gene-name papers that day. We did not have Excel, so every Excel step here comes from Microsoft’s documentation and is untested, and two rows of test data cannot show every value a real export holds.
\nAn Outlook to SharePoint and Teams flow costs $0 extra on Microsoft 365, and from $239.88 a year on Zapier.
List the apps your flow touches and check each one's class on Microsoft's connector page. All Standard: build it in Power Automate for $0. One Premium: weigh a $180 yearly owner license against Zapier.
An office on Microsoft 365 already owns an automation tool. Microsoft’s plans include Power Automate, and flows between Outlook, Excel, SharePoint and Teams cost nothing extra. Zapier, its best-known rival, charges for every action from the first one.
\nSo the question for a Microsoft 365 office is rarely “which is better”. It is which apps the flow touches, and whether either vendor puts one of them behind a paywall.
\nWe checked 35 apps that small offices commonly connect, on both tools, from Microsoft’s connector reference pages and Zapier’s app pages on October 21, 2026. Then we priced three ordinary flows with a short script, from both vendors’ price lists read the same day. The table below is the part you will not find on either vendor’s site.
\nMicrosoft says select Office 365 licenses include “limited Power Automate use rights” meant “for personal productivity scenarios”. In practice that means cloud flows built only from standard connectors. Users on those plans “can only access standard connectors”, the same FAQ says; the exception is premium connectors inside Dataverse for Teams environments. Premium and custom connectors are not included, and neither is the on-premises data gateway.
\nThe step up is Power Automate Premium at $15.00 per user a month, paid yearly, or $180 a year. The rule that decides how many you need is short. For an automated or scheduled flow that uses a premium connector, “only the owner needs to have a Premium license”. For an instant flow (a button, or one started from Power Apps), “every user who runs the flow needs a Power Automate Premium license”.
\nThere is a trap in that first rule. Microsoft calls it multiplexing: pooling access so fewer people need licenses.
\nIts own example is a premium flow that starts when someone adds an item to a SharePoint list. If the flow emails only its owner, one license is enough. If it emails the person who added the item, “both the owner and the user need a Premium license”.
\nA single Premium license on a shared service account that many people use is, in Microsoft’s words, “multiplexing, and the flow isn’t compliant”. Microsoft adds that this “isn’t hard enforcement”; admins are responsible.
\nZapier’s pricing page counts tasks. Each successful action uses one, though Zapier says “some apps or actions may use more than one task”. Triggers, filters and Formatter steps use none, and neither does polling for new data.
\nThe Free plan gives 100 tasks a month and two-step Zaps only, meaning one trigger and one action. Professional starts at $19.99 a month billed yearly for 750 tasks, and adds multi-step Zaps and premium apps, plus webhooks. The Team plan starts at $69 a month billed yearly and adds 25 users with shared app connections.
\nZapier also differs on speed. It checks polling triggers every 15 minutes on Free, every 2 minutes on Professional and every minute on Team. Power Automate’s shortest schedule, its minimum recurrence interval, is 60 seconds on every license.
\nMicrosoft classes each connector Standard or Premium on its reference page; Zapier marks some apps Premium, which means paid plans only. We read each page for the apps below. In the Zapier column, “Free plan” means the app is not Premium; a Zap with more than one action still needs a paid plan, whatever the app.
\n| App | \nPower Automate connector | \nZapier app | \n
|---|---|---|
| Outlook | \nStandard | \nFree plan | \n
| Excel | \nStandard | \nFree plan | \n
| SharePoint | \nStandard | \nPremium | \n
| Teams | \nStandard | \nFree plan | \n
| OneDrive for Business | \nStandard | \nFree plan | \n
| Gmail | \nStandard | \nFree plan | \n
| Google Sheets | \nStandard | \nFree plan | \n
| Google Drive | \nStandard | \nFree plan | \n
| Google Calendar | \nStandard | \nFree plan | \n
| Slack | \nStandard | \nFree plan | \n
| Trello | \nStandard | \nFree plan | \n
| Asana | \nStandard | \nFree plan | \n
| Jira | \nPremium | \nFree plan | \n
| Smartsheet | \nStandard | \nFree plan | \n
| Notion | \nPremium, independent publisher | \nFree plan | \n
| Zoom | \nPremium, independent publisher, preview | \nFree plan | \n
| Dropbox | \nStandard | \nFree plan | \n
| Box | \nStandard | \nFree plan | \n
| Docusign | \nStandard | \nFree plan | \n
| Mailchimp | \nPremium | \nFree plan | \n
| HubSpot | \nPremium, independent publisher, preview | \nFree plan | \n
| Salesforce | \nPremium | \nPremium | \n
| Pipedrive | \nPremium | \nFree plan | \n
| Zendesk | \nPremium | \nPremium | \n
| Freshdesk | \nStandard | \nFree plan | \n
| Typeform | \nStandard, preview | \nFree plan | \n
| Calendly | \nPremium, preview | \nFree plan | \n
| SurveyMonkey | \nPremium | \nFree plan | \n
| Twilio | \nStandard | \nFree plan | \n
| SendGrid | \nStandard | \nFree plan | \n
| Stripe | \nPremium | \nFree plan | \n
| Shopify | \nPremium, independent publisher, preview | \nPremium | \n
| WooCommerce | \nPremium, third-party publisher | \nFree plan | \n
| QuickBooks Online | \nNo connector found | \nPremium | \n
| Xero | \nPremium, third-party publisher, preview | \nPremium | \n
Unlinked rows come from the same sets of pages: Microsoft’s at learn.microsoft.com/en-us/connectors/ and Zapier’s at zapier.com/apps/. “Independent publisher” and “third-party publisher” mean the connector page names someone other than Microsoft or the app’s own maker as publisher. “Preview” is Microsoft’s label for a connector not yet generally available. For QuickBooks Online we searched Microsoft’s list of Power Automate connectors and found only a QuickBooks Time connector.
\nGuess how many of the 35 sit behind a paywall on each side. On Power Automate, 14 are Premium and one has no connector at all. On Zapier, 6 are Premium. The five Microsoft 365 apps in the table are all Standard on Power Automate, and SharePoint is the one Zapier keeps for paid plans.
\nThe pattern is plain. Microsoft and Google apps are Standard on Power Automate, and so are Slack and Trello, while Jira is Premium. Every CRM and online-store app in the table is Premium, as are Stripe and SurveyMonkey. For HubSpot, Shopify, Notion and Zoom, every connector we found in Microsoft’s list comes from an independent publisher, not Microsoft or the app’s maker.
\nThe Excel Online (Business) connector’s reference page lists actions only, from adding and updating rows to running Office Scripts. It lists no trigger. So a Power Automate flow cannot start on the Excel connector because a row appeared. The usual route is a schedule that reads the table, and that read returns 256 rows by default unless you turn on pagination.
\nThe connector also caps files at 25 MB and warns that a file “may be locked for an update or delete up to 6 minutes” after the connector last used it.
\nZapier’s Excel app has four triggers, among them New Row and Updated Row, polling every 15 minutes on Free. Its catch: “Only files on OneDrive for Business (available with Office 365 and Sharepoint server) are supported.” A workbook on a personal OneDrive won’t work.
\nSo if the job starts when someone types a row into a shared workbook, Zapier fits it directly. Power Automate needs a scheduled flow that compares rows, or a different starting point such as a SharePoint list or Microsoft Forms.
\nWe wrote a 39-line Node.js script with Zapier’s Professional tiers and Microsoft’s Premium price, both read on October 21, 2026. It priced three hypothetical flows, each a common office job.
\nZapier figures are the cheapest yearly-billed Professional tier that holds the tasks, without pay-per-task overage. Power Automate figures are the extra cost on top of Microsoft 365.
\nFlow 1: an invoice email arrives in Outlook; save the attachment to SharePoint and post in Teams. Two actions, so two Zapier tasks a run, and SharePoint makes it a paid plan anyway.
\n| Runs a month | \nZapier tier | \nZapier a year | \nPower Automate a year | \n
|---|---|---|---|
| 50 | \nPro, 750 tasks | \n$239.88 | \n$0 | \n
| 300 | \nPro, 750 tasks | \n$239.88 | \n$0 | \n
| 1,000 | \nPro, 2,000 tasks | \n$588.00 | \n$0 | \n
| 5,000 | \nPro, 10,000 tasks | \n$1,548.00 | \n$0 | \n
Flow 2: a new Trello card posts a message in Slack. One action, one task a run.
\n| Runs a month | \nZapier tier | \nZapier a year | \nPower Automate a year | \n
|---|---|---|---|
| 50 | \nFree | \n$0 | \n$0 | \n
| 300 | \nPro, 750 tasks | \n$239.88 | \n$0 | \n
| 1,000 | \nPro, 1,500 tasks | \n$468.00 | \n$0 | \n
| 5,000 | \nPro, 5,000 tasks | \n$1,068.00 | \n$0 | \n
Flow 3: a new Salesforce lead becomes a row in an Excel table and a Teams message. Salesforce is Premium on both tools. On Power Automate this is an automated flow, so one Premium license for the owner covers it.
\n| Runs a month | \nZapier tier | \nZapier a year | \nPower Automate a year | \n
|---|---|---|---|
| 50 | \nPro, 750 tasks | \n$239.88 | \n$180.00 | \n
| 300 | \nPro, 750 tasks | \n$239.88 | \n$180.00 | \n
| 1,000 | \nPro, 2,000 tasks | \n$588.00 | \n$180.00 | \n
| 5,000 | \nPro, 10,000 tasks | \n$1,548.00 | \n$180.00 | \n
Power Automate’s limit is actions per day, not money. Microsoft counts “every trigger and action execution” as one, and the licensing FAQ sets 6,000 a day for Microsoft 365 users and 40,000 for Premium. At 5,000 runs a month, flows 1 and 3 use about 500 a day, so neither comes close.
\nOne license covers many flows. The $180 for flow 3 also pays for every other automated flow the same owner builds with premium connectors. A second Zapier flow adds tasks to the same bill.
\nPower Automate on Microsoft 365 rights runs on what Microsoft calls the Low performance profile. A failed action gets “up to two retries” there, against 12 on Premium. A flow without a trigger for 90 days “might be turned off”, unless its owner has a premium license.
\nIf the owner leaves the company, the flow “reverts to the Low performance profile”. A premium flow whose owner loses the Premium license is downgraded, and turned off after 14 days if nobody acts, the FAQ says.
\nThe connector gaps cost time too. The HubSpot connector names an independent publisher and carries Microsoft’s preview label, which marks a connector not yet generally available. If your CRM is on that list, you pay $180 a year and still depend on that connector.
\nZapier’s costs are easier to see. Every action is a task, so a long flow at high volume climbs tiers fast: flow 1 at 5,000 runs costs $1,548 a year. When tasks run out, Zapier either moves you to pay-per-task billing or pauses your Zaps until the next period. A Professional plan has one seat; sharing connections across a team means the Team plan, from $69 a month.
\nThe decision starts with a list of the apps in the flow, not with the tools’ feature pages.
\nBefore you build, run the flow through our payback formula. A free tool still costs the hours to fix it. For a worked Power Automate flow on the free license, see saving Outlook attachments automatically. More is under automation.
\nWrite the flow’s apps in one column and their class in the next. Microsoft’s own column decides most of these choices before the Zapier price matters.
\nWe read Microsoft’s connector reference pages for 35 apps, its licensing FAQ, limits page and pricing page, and Zapier’s pricing page and app pages, all on October 21, 2026. The connector classes and Zapier prices were taken from those pages with a script, and the three flows were priced by a second script we ran on those figures. The flows are hypothetical: we did not build or run them on either tool, because we have no Microsoft 365 tenant or paid Zapier account for testing.
\nOn Nextcloud 29, the newest built-in Collabora app on offer is June's 26.4.104, below the 26.4.303 fix.
Run occ app:list on your Nextcloud server. If richdocumentscode is there, update it to 26.4.303 or later, or remove it; disabling it does not close the hole.
CISA added CVE-2026-110447 to its known exploited vulnerabilities catalog on October 23, with an October 26 deadline for US federal agencies. It lets anyone, without logging in, run commands on a Nextcloud server that has the built-in Collabora office app, richdocumentscode. On Nextcloud 29 or older, no patched build exists.
Collabora’s advisory, published October 14, rates the bug critical, 9.2 on CVSS v4. A crafted request to the app’s proxy.php makes the web server run an operating system command as the web server user. It works only while the built-in server is not running, for example after a container restart, an upgrade or a crash. Every version below 26.4.303 is affected.
Two details matter more than the score. Disabling the app does not stop the attack; you have to upgrade or remove it. And standalone Collabora Online servers are not affected. BleepingComputer, citing Collabora, adds that Docker, RPM and DEB installs and Nextcloud All-in-One are safe too.
\nThe fix came first and the warning came late. BleepingComputer reports that the fix was committed on September 9, version 26.4.303 shipped on September 11, and administrators reported attacks from around September 10. On October 3, a user posted on the Nextcloud forum that the flaw “is already being exploited” and that some admins had found web shells. The CVE followed on October 14.
\nAdmins told BleepingComputer the attackers planted PHP web shells and searched for password databases, password manager files and crypto wallets. One forum user wrote on October 16 that Nextcloud’s integrity scan flagged an extra file, Nx_33143.php, in the app’s folder, which they called a simple backdoor. Nextcloud told BleepingComputer it had not seen widespread exploitation. CISA calls its catalog the authoritative list of flaws “exploited in the wild,” so this one now counts.
We checked the Nextcloud app store’s release list and its API on October 24. Version 26.4.303 and every later build require Nextcloud 30 or newer. A server on Nextcloud 29 is offered 26.4.104, released June 7, which is below the fix. The advisory says Nextcloud 29 and earlier are end of life and tells those users to upgrade Nextcloud or remove the app.
\nSo an app update will not save an older server. That is the trap: the store has nothing newer to offer it, and the server stays exposed.
\nThe trade-off is real. Removing the app ends in-browser editing until you set up Collabora some other way, such as the Docker image. Upgrading Nextcloud across major versions takes longer than an app update.
\nsudo -E -u www-data php occ app:list, per Nextcloud’s occ docs, and look for richdocumentscode. If only richdocuments is there, the forum post says you are not affected.occ app:update richdocumentscode and confirm 26.4.303 or later. The store’s newest build was 26.4.502 on October 23.occ app:remove richdocumentscode today, then plan the Nextcloud upgrade.apps/richdocumentscode and change any passwords the web server user could read. CISA’s BOD 26-04 asks agencies for this same step, a “forensic triage of the asset to assess whether the system is compromised.”On five sample bank statements we made, one free tool, Camelot, read all 154 transactions exactly.
Download CSV from your bank first. For PDF-only months, run the script in this guide and fix every row the balance check flags. It will not catch a wrong date or description.
If you copy bank statement PDFs into Excel by hand, a free Python tool can do the copying, and the statement itself can check the result. We made five sample statements in five common layouts and ran three free table readers on them. Camelot read all 154 transactions exactly. The other two each lost whole statements under their default settings.
\nThe check is the useful part. Where a statement prints a balance after each line, the previous balance plus the amount must equal the next balance.
\nA script that tests that on every row catches a dropped line, a misread amount or a debit booked as a credit. This guide shows where each tool broke and why, gives you the script, and says what the check cannot catch. Documentation and prices were read on October 21, 2026.
\nWe wrote a Python script that drew five statements as PDFs from transactions we generated, so every extracted row could be scored against the truth. Every name and amount in them is made up. Each one tests a different layout problem:
\n-687.18), and the date printed only on the first transaction of each day, 26 transactions.02 Sep), Paid out and Paid in columns, “balance brought forward” and “carried forward” rows, and long descriptions that wrap onto a second line, 34 transactions.1.234,56, dates as 14.09.2026, and debits written with a trailing minus (421,12-), 22 transactions.CR and debits carry nothing, and a balance that goes overdrawn and prints as 412.37 DR, 24 transactions.Each tool’s tables went through the same parser, which we wrote from the five layouts before running any tool. It finds the header row, maps the columns, turns the amounts into signed numbers and joins wrapped lines. A transaction counted as right only when its date, description, amount and balance all matched.
\n| Tool and settings | \nRight, of 154 | \nWhere it failed | \n
|---|---|---|
| Camelot 2.0.0, lattice, then stream when lattice finds no table | \n154 | \nnowhere | \n
| tabula-py 2.10.0, default settings | \n120 | \nfound no table at all in S3 | \n
tabula-py, guess=False, stream=True | \n0 | \nread all 154 amounts and balances, but put the date and description in one column | \n
| pdfplumber 0.11.10, default settings | \n72 | \nfound tables only in the ruled grids (S1 and S5) | \n
pdfplumber, text strategy | \n1 | \ncut words in two; split amounts across cells in S5 | \n
Our parser is tuned to these five layouts, so the scores flatter all three tools. Real statements add logos and footers, and some arrive as scans. Read the table as a ranking of how each tool copes with layout, not as an accuracy rate you can expect.
\nAll three tools read the text a PDF already contains. Their real job is deciding which words belong in which column, and each failure above traces to how a tool makes that guess.
\nLines or whitespace. pdfplumber’s table finder defaults to lines for both directions, using the page’s drawn lines as cell borders. Statements S2 and S4 have no lines, so it found nothing. S3 has rules between rows but none between columns, and that was not enough either.
Its text strategy draws imaginary column borders from where words line up. On our files that went worse: it split “Granite Ridge Bank” into “Granite Rid” and “ge Ban”, and split 2,955.21 CR across two cells.
Two modes, and a fallback between them. Camelot’s lattice mode “detects the grid from the ruled lines”, and its stream mode uses “text-alignment / whitespace heuristics” for borderless tables. Lattice found the grids in S1 and S5 and nothing in S2, S3 and S4. Falling back to stream for those three is why Camelot read everything.
\nThe guessed table area. tabula-py’s guess option, on by default, makes it “guess the portion of the page to analyze”. On S3 the guess found no table. With guess=False it read every amount and balance in all five statements, but it merged the date and description columns.
Giving it the column borders by hand fixed that. With columns=[95, 330, 405, 480], the x positions in points of the borders between S3’s columns, it read all 34 S3 transactions. The columns option takes “X coordinates of column boundaries”, so you need one list per bank layout.
One more trap showed up in our own checks. On a version of S2 printed newest first, Camelot’s stream mode returned the same table twice, overlapping, which doubled 26 transactions to 52. The balance check flagged it, and the script below now drops a table whose rows were already read on the same page.
\nA statement with a running balance checks itself in a way an invoice does not. Each row’s balance must equal the previous balance plus that row’s amount. The first row checks against the opening balance and the last against the closing balance, when the statement prints them.
\nTo see what that check catches, we took Camelot’s correct output for S1 and planted one fault at a time, then ran the check.
\n| Fault planted in S1’s 48 rows | \nFlagged by the balance check | \n
|---|---|
| One row in the middle dropped | \nyes, at the next row | \n
| The last row dropped | \nyes, against the closing balance | \n
| One amount off by $9.00 | \nyes | \n
| A withdrawal read as a deposit | \nyes | \n
| Two rows swapped | \nyes, at three rows | \n
| One row read twice | \nyes | \n
| One date wrong | \nno | \n
| One description cut short | \nno | \n
The same check worked on the tools’ real failures. pdfplumber’s text strategy lost 10 of S3’s 34 rows in 7 gaps, and the check flagged the row after each gap. It also flagged all 8 rows where that strategy got an amount wrong in S5.
What the check cannot see matters just as much. It tests money, not words or dates. pdfplumber’s text strategy read all 48 amounts and balances in S1 correctly while cutting 47 of the 48 descriptions, and the check passed it.
\nSo the check tells you the money is complete. Read a sample of descriptions and dates yourself before you trust a statement.
\nThe fastest PDF converter is the one you do not need. If your online banking offers a download of your activity, start there. QuickBooks’ own help page tells you to try a QFX, QBO or OFX file if your bank offers one of those but not CSV.
\nUse the PDF route for what downloads do not cover: older months, a closed account, or statements a client sends you. Check your bank’s download page for how far back it goes. We did not test any bank’s export, because that needs a real account.
\nOpen a statement and try to select a word. Camelot’s documentation gives the same test: “If you can click and drag to select text in your table in a PDF viewer, then your PDF is text-based.” Its built-in parsers need that text, and pdfplumber says it works best on machine-generated rather than scanned PDFs.
\nFor a scan, add a text layer first with ocrmypdf scan.pdf scan.pdf. OCRmyPDF uses the open-source Tesseract engine, and its own page warns that “the OCR accuracy may not match that of commercial OCR solutions”. Our invoice test found two stray characters on a clean, computer-made scan, so run the balance check on every OCR’d statement. The script below reports a PDF with no text and skips it rather than guessing.
The script reads every PDF in a folder and writes statements.xlsx with two sheets. Transactions has one row per transaction with a check column. Files has one row per statement with how many rows need a look. It uses Camelot for the tables and pdfminer.six to read the year and the opening and closing balances from the page text.
We ran it on Linux with Python 3.11. Camelot’s default backend needs no system dependencies, and our test machine had no Ghostscript. Set it up with:
\npython3 -m venv statements-env\nstatements-env/bin/pip install camelot-py pdfminer.six pandas openpyxlSave this as statement_to_excel.py:
\"\"\"Turn PDF bank statements into one Excel sheet of transactions, and check\nevery row against the running balance the bank printed.\nUsage: python statement_to_excel.py <folder>\"\"\"\nimport re, sys\nfrom datetime import datetime\nfrom pathlib import Path\nimport camelot, pandas as pd\nfrom pdfminer.high_level import extract_text\n\nROLES = [(\"balance\", r\"balance\"), (\"debit\", r\"withdraw|paid out|debit|money out\"),\n (\"credit\", r\"deposit|paid in|credit|money in\"), (\"amount\", r\"amount\"),\n (\"date\", r\"^(date|booking|posted)\"), (\"desc\", r\"desc|detail|transaction|text|payee|memo\")]\n\ndef money(s):\n s = re.sub(r\"[$€£\\s]|USD|EUR|GBP\", \"\", str(s)).upper()\n if not s: return None\n sign = 1\n if s.endswith((\"DR\", \"OD\")): sign, s = -1, s[:-2]\n elif s.endswith(\"CR\"): s = s[:-2]\n if s.endswith(\"-\"): sign, s = -1, s[:-1]\n if s.startswith(\"-\"): sign, s = -1, s[1:]\n if s.startswith(\"(\") and s.endswith(\")\"): sign, s = -1, s[1:-1]\n if re.fullmatch(r\"\\d{1,3}(\\.\\d{3})*,\\d{2}\", s): s = s.replace(\".\", \"\").replace(\",\", \".\")\n elif re.fullmatch(r\"\\d{1,3}(,\\d{3})*\\.\\d{2}|\\d+\\.\\d{2}\", s): s = s.replace(\",\", \"\")\n else: return None\n return sign * float(s)\n\ndef day(s, year, day_first):\n s = re.sub(r\"\\s+\", \" \", s).strip()\n fmts = [\"%d/%m/%Y\", \"%m/%d/%Y\"] if day_first else [\"%m/%d/%Y\", \"%d/%m/%Y\"]\n for f in fmts + [\"%d.%m.%Y\", \"%Y-%m-%d\", \"%b %d, %Y\", \"%d %b %Y\"]:\n try: return datetime.strptime(s, f).date()\n except ValueError: pass\n for f in (\"%b %d\", \"%d %b\", \"%m/%d\"): # no year printed: take it from the statement\n try: return datetime.strptime(f\"{s} {year}\", f + \" %Y\").date()\n except ValueError: pass\n\ndef tables(pdf, flavor):\n out, seen = [], set()\n for t in camelot.read_pdf(str(pdf), pages=\"all\", flavor=flavor):\n rows = [tuple(r) for r in t.df.values.tolist() if any(c.strip() for c in r)]\n if all((t.page, r) in seen for r in rows): continue # stream mode can find a table twice\n seen.update((t.page, r) for r in rows); out.append([list(r) for r in rows])\n return out\n\ndef roles(row):\n found = {}\n for i, cell in enumerate(row):\n for role, pat in ROLES:\n if role not in found and re.search(pat, cell.strip(), re.I):\n found[role] = i; break\n return found if {\"date\", \"balance\"} <= found.keys() else None\n\ndef parse(tables, year):\n \"\"\"tables: lists of rows of cell strings, in page order. Returns the transactions\n and the first \"brought forward\" balance, if a table has one.\"\"\"\n tables = [[[re.sub(r\"\\s+\", \" \", c).strip() for c in row] for row in t] for t in tables]\n rows = [r for t in tables for r in t]\n head = next((r for r in map(roles, rows) if r), {})\n column = lambda k: [r[head[k]] for r in rows if k in head and len(r) > head[k]]\n day_first = any(int(m.group(1)) > 12 for c in column(\"date\") # 25/09/2026 is day first\n if (m := re.match(r\"(\\d\\d)/\\d\\d/\\d{4}\", c)))\n has_cr = any(re.search(r\"\\dCR$\", c.replace(\" \", \"\"), re.I) for c in column(\"amount\"))\n cols, out, last_date, brought = None, [], None, None\n for row in (r for t in tables for r in [None] + t):\n if row is None or (r := roles(row)): # a new table or a header row\n cols, joinable = r if row else cols, False; continue\n if not cols or len(row) <= max(cols.values()): continue\n get = lambda k: row[cols[k]] if k in cols else \"\"\n desc, bal = get(\"desc\"), money(get(\"balance\"))\n if \"amount\" in cols:\n amt = money(get(\"amount\"))\n if amt is not None and has_cr: # CR marks credits, so an unmarked amount is a debit\n amt = abs(amt) if re.search(r\"CR\\s*$\", get(\"amount\"), re.I) else -abs(amt)\n else:\n out_, in_ = money(get(\"debit\")), money(get(\"credit\"))\n amt = None if out_ is None and in_ is None else (in_ or 0) - (out_ or 0)\n d = day(get(\"date\"), year, day_first) if get(\"date\") else None\n if d and last_date and (last_date - d).days > 180: # a December to January statement\n d = d.replace(year=d.year + 1)\n if amt is None:\n if bal is not None and not out and brought is None and re.search(r\"brought forward\", desc, re.I):\n brought = bal\n if joinable and bal is None and desc and not d: # a wrapped description line\n out[-1][\"description\"] += \" \" + desc; continue\n joinable = False; continue # balance brought or carried forward, page totals, other text\n out.append({\"date\": d or last_date, \"description\": desc, \"amount\": round(amt, 2), \"balance\": bal})\n last_date, joinable = d or last_date, True\n return out, brought\n\ndef balances(text):\n \"\"\"Opening and closing balance as printed on the statement, if found.\"\"\"\n num = r\"\\s*(?:EUR|USD|GBP)?\\s*[$€£]?\\s*(-?[\\d.,]+\\d(?:\\s*(?:CR|DR|-))?)\"\n o = re.search(r\"(?:opening|beginning|old|previous) balance\" + num + \"|balance brought forward\" + num, text, re.I)\n c = re.search(r\"(?:closing|ending|new) balance\" + num, text, re.I)\n return (money(o.group(1) or o.group(2)) if o else None), (money(c.group(1)) if c else None)\n\ndef check(txns, opening=None, closing=None):\n \"\"\"Flag every row where the previous balance plus the amount is not the printed balance.\"\"\"\n prev = opening\n for t in txns:\n if t[\"balance\"] is None: t[\"check\"] = \"no balance read\"\n elif prev is None: t[\"check\"] = \"first row, no opening balance to check against\"\n elif round(prev + t[\"amount\"], 2) == t[\"balance\"]: t[\"check\"] = \"ok\"\n else: t[\"check\"] = f\"break: expected {prev + t['amount']:.2f}\"\n prev = t[\"balance\"]\n if txns and closing is not None and txns[-1][\"balance\"] != closing:\n note = f\"last balance differs from closing balance {closing:.2f}\"\n txns[-1][\"check\"] = note if txns[-1][\"check\"] == \"ok\" else txns[-1][\"check\"] + \"; \" + note\n return txns\n\nif __name__ == \"__main__\":\n folder = Path(sys.argv[1]); pdfs = sorted(folder.glob(\"*.pdf\"))\n if not pdfs: sys.exit(f\"No PDF files in {folder}\")\n rows_out, summary = [], []\n for pdf in pdfs:\n try:\n text = extract_text(pdf)\n if not text.strip():\n summary.append({\"file\": pdf.name, \"rows\": 0, \"problems\": \"\",\n \"result\": \"no text layer: run ocrmypdf on it first\"}); continue\n year = (re.findall(r\"\\b20\\d\\d\\b\", text) or [datetime.now().year])[0]\n opening, closing = balances(text)\n for flavor in (\"lattice\", \"stream\"): # ruled tables first, then whitespace columns\n txns, brought = parse(tables(pdf, flavor), year)\n if txns: break\n if txns and txns[0][\"date\"] and txns[-1][\"date\"] and txns[0][\"date\"] > txns[-1][\"date\"]:\n txns.reverse() # newest first: check the balances oldest first\n txns = check(txns, opening if opening is not None else brought, closing)\n except Exception as e:\n summary.append({\"file\": pdf.name, \"rows\": 0, \"problems\": \"\", \"result\": f\"error: {e}\"}); continue\n problems = sum(t[\"check\"] != \"ok\" for t in txns)\n summary.append({\"file\": pdf.name, \"rows\": len(txns), \"problems\": problems,\n \"result\": \"no rows found\" if not txns else \"ok\" if problems == 0 else \"check by hand\"})\n rows_out += [{\"file\": pdf.name} | t for t in txns]\n out = folder / \"statements.xlsx\"\n with pd.ExcelWriter(out) as xl:\n pd.DataFrame(rows_out).to_excel(xl, sheet_name=\"Transactions\", index=False)\n pd.DataFrame(summary).to_excel(xl, sheet_name=\"Files\", index=False)\n print(pd.DataFrame(summary).to_string(index=False))\n print(f\"\\n{len(rows_out)} transactions written to {out}\")Run it with statements-env/bin/python statement_to_excel.py statements/. On a folder holding our five statements and a scanned copy of S2’s first page, it printed:
file rows problems result\n s1.pdf 48 0 ok\ns2-scan.pdf 0 no text layer: run ocrmypdf on it first\n s2.pdf 26 0 ok\n s3.pdf 34 0 ok\n s4.pdf 22 0 ok\n s5.pdf 24 0 ok\n\n154 transactions written to statements/statements.xlsxWe compared the Transactions sheet with our generated data: all 154 rows matched on every field. The script rewrites statements.xlsx on every run, so close the workbook in Excel first. A PDF that crashes Camelot gets an error: row instead of stopping the run, and an empty folder stops with a message.
Any value other than ok in the check column is a row to look at. These are the causes we know of, and the setting that fixes each:
first row, no opening balance to check against. The script looks for “opening”, “beginning”, “old” or “previous balance” followed by an amount, or a “balance brought forward” row. If your bank writes “Balance on 1 September”, add that wording to the pattern in balances().DR as a debit. When any amount in an Amount column ends in CR, it treats every unmarked amount as a debit. If your bank marks debits some other way, add that marker to money().ROLES.03/09/2026 as March 9 unless some date in the column has a first number above 12, which proves the day comes first. A statement from early in a month can have no such date. If your bank always writes the day first, add the line day_first = True right after the has_cr = ... line in parse().no balance read. Compare the sum of the amounts with the statement’s own totals instead.Dates without a printed year take the first year (2000 to 2099) found in the statement’s text. December-to-January statements are handled by moving a date forward a year when it falls more than 180 days before the row above it.
\nQuickBooks Online accepts a CSV in two shapes: three columns (Date, Description, Amount) or four (Date, Description, Credit, Debit). The Transactions sheet already holds the three-column version. Delete the file, balance and check columns, then save the sheet as CSV.
\nThe same page lists what makes an upload fail. Keep every date in one format. Remove any zeros and leave those cells blank. Fix descriptions that are only numbers.
\nOn a Mac, save as a Windows CSV.
\nThe free route costs setup time, and some upkeep per bank layout. A new bank means a new header word in ROLES or a new date format, and each change needs a test run on a statement you know. Our payback formula counts that upkeep against the hours of typing it saves.
Paid table extraction removes the layout work but not the check. Amazon’s AnalyzeDocument with the Tables feature costs $0.015 a page for the first million pages a month in US West (Oregon). New customers get 100 pages a month free for three months.
\nA hypothetical year of 12 three-page statements would cost 54 cents at that price. We did not test it, because it needs a paid account. Its output still needs the same mapping from columns to amounts and the same balance check.
\nTwo other routes have limits worth knowing before you choose. Excel’s own PDF import, through Power Query, is listed for Excel on Windows, with .NET Framework 4.5 or later, and not for Excel for Mac. Our invoice guide covers its settings; we have not tested it on statements.
\nFree converter websites take the file onto someone else’s server. A statement carries your account number and every payment you made that month, so read the site’s terms before you upload one.
\nOur view: download CSV where the bank offers it, run the script on the PDF-only months, and treat any row the balance check flags as unread until a person has looked at it.
\nOn October 21, 2026, we generated five sample bank statements as PDFs with the ReportLab library from transactions we made up, plus a newest-first copy of one and an image-only copy of one page to stand in for a scan. We ran Camelot, tabula-py and pdfplumber on them through one parser and scored all 154 transactions, planted eight faults in one statement to test the balance check, and ran the script in this guide on the same files, on Linux with Python 3.11. We read each tool’s documentation, QuickBooks’ CSV import rules, Amazon’s Textract pricing and Microsoft’s Excel data source list that day. We did not test any bank’s own export, any paid API or Excel’s PDF import, and our statements are cleaner than real ones, so treat the scores as a best case.
\nguess, stream, columns), version 2.10.0Installing the Brotli package alone made requests, httpx and aiohttp start asking servers for Brotli in our check.
Run node --version and pip show brotli brotlicffi inside every image you deploy. Move to Node 22.23.4, 24.22.1 or 26.12.1 and Brotli 1.2.1, then rebuild.
The Brotli bug Node.js patched on October 21 is not a Node.js bug. It sits in Google’s Brotli decoder, and Aikido Security reported on October 23 that Python packages, Envoy, Istio, Bun and bundled copies in curl carry it too. If your services fetch from other servers or accept compressed uploads, every runtime that unpacks Brotli needs a patched build.
\nNode.js rated CVE-2026-111497 high and fixed it in 22.23.4, 24.22.1 and 26.12.1. Its advisory explains the cause. An invalid block switch was reported as a need for more input, not as an error. So the decoder kept writing bytes into an eight-byte buffer.
\nAttacker-supplied Brotli data “can lead to a crash, disclosure of process memory, or remote code execution.” Node.js credits OpenAI Codex Security with the report.
\nThe GitHub advisory for the Python packages, published October 22, puts the flaw in Google Brotli 1.0.3 through 1.2.0 “on all platforms” and scores it critical, 9.2 on CVSS v4. Fixed releases are Brotli 1.2.1, 1.1.1 and 1.0.10, and brotlicffi 1.2.1.0. PyPI shows Brotli 1.2.1 went up on October 22, almost a year after 1.2.0.
\nEnvoy followed on October 23. Its advisory covers “Envoy deployments that have Brotli decompressor configured,” with fixes in 1.40.0, 1.39.3, 1.38.6, 1.37.8 and 1.36.12. Aikido lists Istio 1.29.9, 1.30.6 and 1.31.2 and Bun 1.4.4 as fixed.
\nAccording to Aikido, OpenAI found the bug in February and the source was fixed then. It was not flagged as a security issue, and no release carried the fix until this week.
\nMost apps never call a Brotli function themselves. A library does it for them. In Node.js, the built-in fetch() decompresses Brotli responses automatically, Aikido’s Node.js write-up says. Express 5 with body-parser 2.x inflates request bodies sent with Content-Encoding: br.
Imperva ran code through both paths against the official Node.js 24.22.0 image on Linux arm64. It took several attempts and was tested on arm64 only, and 24.22.1 rejected the same input.
\nPython works the same way, and we checked it on October 24. In a fresh Python 3.11 environment, requests 2.34.2, httpx 0.28.1 and aiohttp 3.14.5 each sent Accept-Encoding: gzip, deflate. After pip install brotli==1.2.0, with no code change, all three sent gzip, deflate, br, so any server they call may answer in Brotli.
Package metadata on PyPI also shows the brotli extras of urllib3 (brotli>=1.2.0) and aiohttp (Brotli>=1.2) still accept the vulnerable 1.2.0, so an old lockfile keeps it.
The Python research “didn’t pursue memory corruption or code execution in the Python extension,” Aikido says. For Node.js, no attack in the wild had been reported as of October 22. Aikido still calls it urgent, and we agree: the Brotli package gets 82.8 million downloads a month, by its count.
\nnode --version and pip show brotli brotlicffi in each container and server. Imperva notes package inventories can miss bundled runtimes.Content-Encoding includes br at the proxy or load balancer. For outbound calls, Aikido says to drop br from Accept-Encoding and refuse Brotli responses. “Changing Accept-Encoding alone is insufficient,” it warns.The trade-off is that a blanket block may break clients that legitimately upload compressed data, so Imperva advises testing the rule against normal traffic first. Apache and Nginx do not decode Brotli by default, Aikido says. We read that as a warning: the web server in front passes Brotli bodies on to the app unless you add the rule.
\nOn 10 sample invoices we made, two free tools read 55 of 58 line items, all but the scan.
If your invoices are digital PDFs from a few suppliers, run the script in this guide and check that each invoice's lines add up to its total. Send every mismatch to a person.
If invoices arrive as PDFs and someone types them into Excel, free tools can do most of that typing. We made 10 sample invoices in nine layouts and ran four free tools on them. The two best, Camelot and tabula-py, read 55 of 58 line items exactly. All four read nothing from the scanned one; after OCR, the two we retried read it fully.
\nThe paid route is cheap too. Amazon, Microsoft and Google sell invoice extraction for 1 to 10 cents a page or document, and those models find the invoice number and total for you. This guide shows where each free tool broke and why, gives you a script that writes a folder of invoices into a workbook, and prices the paid APIs for three monthly volumes. Prices and documentation were read on October 20, 2026.
\nWe wrote a Python script that drew 10 invoices as PDFs with known values, so every extracted field could be scored against the truth. The vendors and amounts are made up. The layouts are the kinds a small office receives:
\nWe scored two things. A line item counted only when both its description and its amount came out exactly right; there were 58. Then three header fields per invoice (number, date, total), 30 in all, read with one set of label rules we wrote before running anything.
\n| Tool (version) | \nLine items right (of 58) | \nHeader fields right (of 30) | \nWhere it failed | \n
|---|---|---|---|
| Camelot 2.0.0, lattice then stream | \n55 | \nnot tested (tables only) | \nthe scan | \n
| tabula-py 2.10.0 | \n55 | \nnot tested (tables only) | \nthe scan | \n
pdftotext 24.02 -layout plus our rules | \n53 | \n24 | \nthe scan; split 2 wrapped lines | \n
| pdfplumber 0.11.10, default settings | \n45 | \n24 | \nthe scan; found no table in the 2 borderless invoices | \n
pdfplumber, text strategy | \n53 | \nnot rescored | \nthe scan; split 2 wrapped lines | \n
After OCRmyPDF added a text layer to the scan, pdftotext and Camelot each read all 3 of its line items, and our label rules found all 3 header fields. The OCR was not perfect: two unit prices came back as 49.00. and 80.00:, with stray punctuation. The amounts we scored were clean, which is luck, not design.
Every free tool here reads the text a PDF already contains and guesses which words belong in which cell. That guess is where they differ, and each failure in our table traces to one of three causes.
\nLines or spacing. pdfplumber’s table finder defaults to lines for both directions, so it looks for drawn borders. On our two borderless invoices it found no table at all.
Switching both settings to text fixed those two. Camelot handles this by having two modes: lattice detects the grid from ruled lines, stream uses text alignment and whitespace. Our script tries lattice first and falls back to stream, which is why Camelot read both borderless invoices. tabula-py is a wrapper of tabula-java, which has the same two modes; with its default settings it read both borderless invoices.
Wrapped rows. When a description runs onto a second line, pdftotext prints two lines of text, and the second has no amount. Our line rules then saw the first half of the description as one item and dropped the rest. Camelot and tabula-py kept “Laptop repair, replaced keyboard and battery, tested” together in one cell. Microsoft documents the same problem for Excel’s PDF connector, where multi-line rows may need cleanup with Fill Down or Group By.
\nLabels. Header fields are not in a table, so a rule has to find them by their label. Our rules looked for “Invoice No”, “Invoice #” or “Invoice number” followed by a value on the same line. The invoice that put “Invoice number” above “CL-311” in a box beat them, and so did the one that said “Reference”. That is the gap the paid models close.
\nAmazon’s AnalyzeExpense maps “bill number, invoice number, receipt number” to one standard field, INVOICE_RECEIPT_ID, and returns a confidence score for every value.
One tabula-py trap is worth knowing before you start. By default it hands tables to pandas, which turned 49.00 into the number 49.0 in our first run. Our scorer expected text, so that run looked like a failure. Passing pandas_options={\"dtype\": str} keeps every cell exactly as printed, and the scores above use that setting.
The test points to a simple rule. Free tools are enough when your invoices are digital PDFs from a known set of suppliers whose layouts rarely change. You write label rules once per supplier and check the totals.
\nPay for an extraction API when you get invoices from many suppliers, when many arrive as scans or phone photos, or when nobody on the team will maintain a script. Microsoft’s invoice model accepts phone-captured images, scanned documents and digital PDFs and supports invoices in 27 languages.
\nDo not use either route without a check step. Every tool we ran missed something, and the paid models return confidence scores precisely because they can be wrong too.
\nRun pdftotext -layout invoice.pdf - on one invoice. pdftotext is a command-line tool from the free Poppler PDF library. If it prints the invoice’s words, the PDF has a text layer and every free tool here can read it. If it prints nothing, the PDF is an image, and all four tools returned nothing on ours.
For image PDFs, add a text layer first: ocrmypdf scan.pdf scan.pdf writes the OCR text into the file. OCRmyPDF uses the open-source Tesseract engine and says plainly that its accuracy “may not match that of commercial OCR solutions”. Our clean, computer-made scan still picked up two stray characters, so expect more on a crooked phone photo.
Camelot’s own documentation says its built-in parsers “need a text-based PDF”, and pdfplumber’s says it works best on machine-generated rather than scanned PDFs.
\nExcel can read PDF tables itself through Power Query. Microsoft lists the PDF source for Excel for Microsoft 365 on Windows, where it requires .NET Framework 4.5 or later. The Mac list of data sources does not include PDF, and Excel for the web reads PDFs only from SharePoint.
\nWe did not test it, because we had no Windows copy of Excel in our test environment. Here is what Microsoft’s connector documentation says:
\nPdf.Tables function: StartPage and EndPage limit the pages read; MultiPageTables (on by default) joins similar tables on consecutive pages; EnforceBorderLines (off by default) makes drawn lines the cell boundaries.The connector’s advantage is that the query refreshes. Drop next month’s invoices in the folder, click Refresh, and the table rebuilds. If our wrapped-row results are a guide, check any invoice with long descriptions by hand.
\nThe script below is the one we ran on our 10 test invoices. It reads every PDF in a folder and writes invoices.xlsx with two sheets: Invoices (number, date, total, the sum of the lines and a check) and Lines (one row per item, with the raw row kept for checking). It uses Camelot for line items and pdftotext plus label rules for the header.
It needs Python and Poppler’s pdftotext. We ran it on Linux with Python 3.11, where pdftotext came installed (the Ubuntu package is poppler-utils), and set it up with:
python3 -m venv invoices-env\ninvoices-env/bin/pip install camelot-py pandas openpyxlSave this as invoices_to_excel.py:
\"\"\"Read every PDF invoice in a folder into invoices.xlsx: one sheet of\ninvoices, one of line items. Usage: python invoices_to_excel.py <folder>\"\"\"\nimport re, subprocess, sys\nfrom datetime import datetime\nfrom pathlib import Path\nimport camelot, pandas as pd\n\ndef money(s):\n s = re.sub(r\"[$€£]|USD|EUR|GBP\", \"\", str(s)).strip()\n neg = s.startswith(\"(\") and s.endswith(\")\")\n s = s.strip(\"()\")\n if re.fullmatch(r\"-?\\d{1,3}(\\.\\d{3})*,\\d{2}\", s): s = s.replace(\".\", \"\").replace(\",\", \".\")\n elif re.fullmatch(r\"-?\\d{1,3}(,\\d{3})*\\.\\d{2}\", s): s = s.replace(\",\", \"\")\n else: return None\n return -float(s) if neg else float(s)\n\ndef date(s): # 03/10/2026 is read as March 10 (US order)\n for fmt in (\"%m/%d/%Y\", \"%d.%m.%Y\", \"%Y-%m-%d\", \"%B %d, %Y\", \"%b %d, %Y\"):\n try: return datetime.strptime(s.strip(), fmt).date()\n except ValueError: pass\n\ndef header(text):\n no = re.search(r\"invoice\\s*(?:no\\.?|number|#)\\s*:?\\s*(\\S*\\d\\S*)\", text, re.I)\n dt = re.search(r\"(?:invoice date|date|issued)\\s*:?\\s*([A-Za-z]{3,9} \\d{1,2}, \\d{4}|[\\d./-]{8,10})\", text, re.I)\n tots = re.findall(r\"(?:total(?: due)?|amount due)\\s*:?\\s*(?:USD|EUR)?\\s*\\$?\\s*([\\d.,()]+)\", text, re.I)\n return {\"number\": no.group(1) if no else None, \"date\": date(dt.group(1)) if dt else None,\n \"total\": money(tots[-1]) if tots else None}\n\ndef lines(pdf):\n tables = camelot.read_pdf(str(pdf), pages=\"all\", flavor=\"lattice\")\n if tables.n == 0: tables = camelot.read_pdf(str(pdf), pages=\"all\", flavor=\"stream\")\n out = []\n for t in tables:\n for row in t.df.values.tolist():\n cells = [re.sub(r\"\\s+\", \" \", c).strip() for c in row if c.strip()]\n if len(cells) < 2 or money(cells[0]) is not None: continue\n if re.match(r\"(sub)?total|amount due|.*tax\", cells[0], re.I): continue\n if (amt := money(cells[-1])) is not None:\n out.append({\"description\": cells[0], \"amount\": amt, \"row\": \" | \".join(cells)})\n return out\n\nfolder = Path(sys.argv[1]); pdfs = sorted(folder.glob(\"*.pdf\"))\nif not pdfs: sys.exit(f\"No PDF files in {folder}\")\ninvoices, items = [], []\nfor pdf in pdfs:\n rec = {\"file\": pdf.name}\n try:\n text = subprocess.run([\"pdftotext\", \"-layout\", str(pdf), \"-\"], capture_output=True,\n text=True, check=True).stdout\n if not text.strip():\n rec[\"check\"] = \"no text layer: run ocrmypdf on it first\"; invoices.append(rec); continue\n rec |= header(text)\n rows = lines(pdf); items += [{\"file\": pdf.name} | r for r in rows]\n rec[\"lines_sum\"] = round(sum(r[\"amount\"] for r in rows), 2)\n missing = [k for k in (\"number\", \"date\", \"total\") if rec[k] is None]\n rec[\"check\"] = (\"missing \" + \", \".join(missing) if missing else\n \"ok\" if rec[\"lines_sum\"] == rec[\"total\"] else \"lines do not add up to total\")\n except Exception as e:\n rec[\"check\"] = f\"error: {e}\"\n invoices.append(rec)\n\nout = folder / \"invoices.xlsx\"\nwith pd.ExcelWriter(out) as xl:\n pd.DataFrame(invoices).to_excel(xl, sheet_name=\"Invoices\", index=False)\n pd.DataFrame(items).to_excel(xl, sheet_name=\"Lines\", index=False)\nprint(pd.DataFrame(invoices)[[\"file\", \"number\", \"date\", \"total\", \"lines_sum\", \"check\"]].to_string(index=False))\nprint(f\"\\n{len(items)} line items written to {out}\")Run it with invoices-env/bin/python invoices_to_excel.py invoices/. On our folder, with the scan already passed through OCRmyPDF, it printed:
file number date total lines_sum check\ninv01.pdf NWS-1042 2026-10-03 320.00 320.00 ok\ninv02.pdf 2026-0877 2026-10-07 308.91 308.91 ok\ninv03.pdf NaN None 740.00 740.00 missing number, date\ninv04.pdf 50213 2026-10-14 2473.40 2473.40 ok\ninv05.pdf KPW-77810 2026-10-12 1292.30 1292.30 ok\ninv06.pdf FP-5531 2026-10-09 274.00 274.00 ok\ninv07.pdf NaN 2026-10-15 372.60 345.00 missing number\ninv08.pdf DGD/26/4410 2026-10-16 591.50 591.50 ok\ninv09.pdf NWS-1042 2026-10-03 320.00 320.00 ok\ninv10.pdf OSL-9001 2026-10-01 1080.00 1080.00 ok\n\n58 line items written to invoices/invoices.xlsxEight invoices came out fully right, and the two it could not read say so instead of filling in a wrong value. Our first version did not do that. It took the word “Invoice” from the boxed header as the invoice number, so we made the rule require a digit. Run on the scan before OCR, the check column reads no text layer: run ocrmypdf on it first.
The script rewrites invoices.xlsx on every run, so run it on a copy of the folder, and close the workbook in Excel first. A PDF that crashes a tool gets an error: row instead of stopping the run. An empty folder stops with a message.
The missing rows tell you which rule to extend. For invoice 7, adding reference to the number pattern, as (?:invoice\\s*(?:no\\.?|number|#)|reference), picked up “CC-2026-118” when we tried it. Its total check would still fail, because that invoice adds 8% sales tax to the lines. Compare the lines with the subtotal on invoices that list tax, or add the tax line to the sum.
Three settings deserve a look before you trust the output:
\n%d/%m/%Y ahead of %m/%d/%Y in date(), or split suppliers into folders by country.money() reads both 1,234.56 and 1.234,56, but only with two decimals. An amount printed without cents, such as 1,200, is not read as money.pandas_options={\"dtype\": str}, which read all of ours.If the check column fills with missing, the paid models are worth pricing. All three return the invoice number, the total and the line items as named fields (Amazon, Microsoft, Google), with no label rules to write. These are list prices as read on October 20, 2026; the monthly costs assume one-page invoices.
| Service | \nPrice | \n100 invoices a month | \n500 | \n2,000 | \nFree allowance | \n
|---|---|---|---|---|---|
| Amazon Textract AnalyzeExpense | \n$0.01 a page (US West, Oregon) | \n$1 | \n$5 | \n$20 | \n100 pages a month for 3 months, new customers | \n
| Azure Document Intelligence, prebuilt invoice (S0) | \n$10 per 1,000 pages (East US) | \n$1 | \n$5 | \n$20 | \nFree tier: 500 pages a month, only the first 2 pages of each file | \n
| Google Document AI Invoice parser | \n$0.10 per document of up to 10 pages | \n$10 | \n$50 | \n$200 | \nNone listed for the parser; Google Cloud Free Program credit of $300 | \n
The prices come from Amazon’s Textract pricing page, whose own example prices AnalyzeExpense at $0.01 a page in US West (Oregon) and $0.008 after one million pages; from Microsoft’s Azure Retail Prices API for East US, which lists prebuilt pages at $10 per 1,000; and from Google’s Document AI pricing page, where one “count” equals up to 10 pages. Azure’s free tier also caps files at 4 MB and one request per second, and its 500-page allowance is on the pricing page.
\nThe per-document price makes Google the costliest for one-page invoices and the closest for long ones. A 10-page invoice costs $0.10 at Google and $0.10 at the other two.
\nWhat the table leaves out matters as much. Each service needs a cloud account with billing set up, and each means sending your suppliers’ invoices to that cloud. We did not run any of the three, because that needs a paid account. Cloudflare’s preview invoice model is cheaper still on its free tier, but it does not accept PDFs, only images.
\nEach new supplier layout costs a rule, and each rule needs a test. Our payback formula counts that upkeep. At 500 one-page invoices a month, Amazon or Azure would cost $5 a month in API fees. Put the hours you spend writing and fixing label rules against that figure.
\nOur view: a script pays only while the layouts stay few and fixed.
\nIf your invoices arrive by email, our guide to saving Outlook attachments automatically gets the PDFs into a folder for the script. For the fields in the email body itself, see email data into Excel. More guides like these are on the automation topic page.
\nWhichever route you pick, keep the check column. Compare the sum of the lines with the printed total, or with the subtotal when tax is listed, and send every mismatch to a person. In our test, every invoice the script could not read flagged itself that way, and every invoice marked ok was right.
On October 20, 2026, we generated 10 sample invoices with the ReportLab library, including one rendered as an image to stand in for a scan, and scored Camelot, tabula-py, pdfplumber and pdftotext against their known values; the vendors and amounts are made up. We ran the script in this guide on the same files, on Linux with Python 3.11, and read the vendors’ pricing pages, the Azure price API and each tool’s documentation that day. We did not test Excel’s PDF connector or any paid API, and our invoices are cleaner than real scans, so treat the scores as a best case.
\nOpenAI's Decisions API charges nothing for output tokens and claims answers about 10x faster than the Responses API.
If you run a yes-or-no or pick-one classifier on gpt-6-luna today, price one day of its traffic on both endpoints. Decisions saves the output fee, but it cannot read files or audio.
OpenAI’s Decisions API is now generally available, its API changelog says in an October 22 entry. The guide prices uncached input at $0.10 per million tokens, and output is not charged at all. If your product routes tickets or scores leads with a language model, those calls can now run cheaper and faster than on the Responses API, with limits worth checking first.
\nThe API had been in public beta since October 6. TechCrunch reported the launch the same day.
\nThe endpoint is POST /v1/decisions, and gpt-6-luna is “the only currently supported model,” the guide says. Instead of a prompt that asks for text, a request carries up to 400 questions, up from 200 in the beta. Each question has one of three types: a predicate returns a probability from 0 to 1, a choice returns one of your options with a probability per option, and a score rates the item on a scale of 2 to 10 levels.
The guide claims answers “about 10x faster than the Responses API.” OpenAI did not train a new model for this. TechCrunch reports the team reconfigured Luna for faster inference, and quotes Nikunj Handa, product lead for OpenAI’s APIs: “it’s just plain old Luna that gets the job done.”
\nHanda told TechCrunch latency fell from one to three seconds to “100, 120, 180 milliseconds.” Box, Datadog and Ramp were among its early trial users, the report says.
\nThe input price is no discount. OpenAI’s pricing page lists standard gpt-6-luna rates at the same $0.10 per million input tokens, plus $0.50 per million output tokens and $0.01 for cached input. The guide says Decisions cache reads match those caching rates, and cache writes are charged.
\nA hypothetical triage job shows the size of it: 10,000 emails of 800 tokens each is 8 million input tokens, or $0.80 on either endpoint. If Responses wrote 40 output tokens per email, that adds 400,000 tokens, or $0.20. Decisions would cost $0.80 against $1.00. Short answers keep the saving modest; speed is the stronger reason to switch.
\nThe trade-offs are in the guide. “Files, audio, and item references aren’t supported,” so PDFs need converting first. When you need an object in your own JSON schema, the guide points you back to Structured Outputs on the Responses API.
\nVoice works only through GPT-Live, which, per OpenAI’s voice guide, “sends the conversation transcript to Decisions automatically.” Regional processing premiums and long-context multipliers also apply. And on two outside rankings cited by TechCrunch, OpenAI’s decision model placed 8th and 14th, behind rival Jev from TypeSafe at 7th and 3rd.
\nGET /v1/organization/usage/decisions with an admin key that has api.usage.read.Self-hosted n8n is free for a business whose own people build the workflows, consultants charging clients included.
Write down who will open the n8n editor before you install. If all of them work for you, self-host for free; if clients must build workflows, email license@n8n.io first.
Self-hosted n8n costs nothing to license for a small business that builds its own workflows. The condition fits in one line of the company’s FAQ: “If workflows are only created or modified by you or people in your organization, you can use n8n under the Community license for free.” Clients can get the results. They can’t get the editor.
\nThat leaves two costs. A short list of features sits behind a paid license key, and the server and its upkeep are yours to pay for. We read the license text on GitHub clause by clause, along with n8n’s license FAQ, its feature list and the price pages of two hosting providers, all on October 20, 2026. We also counted the enterprise-licensed files in n8n’s code.
\nThis is our reading, not legal advice. Where the text leaves room, we say so.
\nThe code is under the Sustainable Use License, version 1.0, which n8n wrote in 2022. The company says plainly that “we do not call ourselves open source”, because the Open Source Initiative does not accept limits on use. Until March 17, 2022, n8n used Apache 2.0 with the Commons Clause.
\nThe grant itself is broad: a “royalty-free, worldwide” license to “use, copy, distribute, make available, and prepare derivative works.” Then come the limits. The one that matters for a business reads:
\n\n\nYou may use or modify the software only for your own internal business purposes or for non-commercial or personal use.
\n
The second limit covers handing n8n to others: “You may distribute the software or provide it to others only if you do so free of charge for non-commercial purposes.” The third says you may not remove n8n’s licensing or copyright notices. A fourth rule, under Notices, says a modified copy must carry “a prominent notice stating that you have modified the software.”
\nHere is the gap. The license never defines “internal business purposes.” The FAQ does, as “the use of n8n within your organization or product where people outside of your business can receive or see what your workflows produce.” So the practical answers live in the FAQ, which is the company’s guidance rather than the license text itself.
\nThe FAQ lists what is allowed and what is not. We sorted the cases a small business asks about.
\n| What you want to do | \nAllowed without a paid license? | \nn8n’s wording | \n
|---|---|---|
| Run your own company’s automations | \nYes | \n“Use n8n community version to help run your business” | \n
| Charge clients to build and maintain workflows | \nYes | \n“Charge your customers for workflow creation, setup, and maintenance services” | \n
| Run client workflows on your own instance | \nYes, if clients can’t edit them | \n“as long as your clients do not have the possibility to create or edit them” | \n
| Install and manage n8n on a client’s server | \nYes, if you don’t also host it | \n“as long as you don’t offer hosting as well” | \n
| Use n8n behind your own product | \nYes, if users only trigger what you built | \n“users can use and trigger the automations you built” | \n
| Host n8n so clients build their own workflows | \nNo | \n“Host n8n as a service and allow your clients to build workflows” | \n
| Embed a workflow builder in your product | \nNo, even with your own interface | \n“whether via a custom UI, our API, MCP, or an AI agent” | \n
| White-label n8n | \nNo | \n“White-label n8n by removing our branding and offering n8n as is” | \n
| Fork n8n into your own automation product | \nNo | \n“Fork n8n’s code to launch your own automation product” | \n
The test is who controls the workflows, not how much you charge. “The key question is not whose credentials are used, but who controls the workflow logic,” the FAQ says. Clients may even connect their own accounts to workflows you built. For agencies, “there is no limit on the number of clients you can serve from a single instance.”
\nTwo cases sit in a gray zone, by the company’s own account. Shipping n8n inside a paid product that runs on the customer’s premises “may sit in gray territory,” because a customer with local access may be able to build workflows. The FAQ asks you to confirm that setup with license@n8n.io before launch. Embedding the n8n editor in your product is a separate deal: OEM deployment “requires a separate commercial agreement,” and n8n branding stays.
\nThe penalty for getting it wrong is the license itself. Use outside the terms “is not licensed, and your license will automatically terminate.” If n8n sends a notice and you stop within 30 days, the license comes back. A second violation after that ends it “automatically and permanently.”
\nThe first lines of LICENSE.md carve out an exception. Files with “.ee.” in their name or “.ee” in a folder name “are NOT licensed under the Sustainable Use License.” They fall under the n8n Enterprise License, which says the code “may only be used in production” with a valid enterprise license. You may “copy and modify the Software for development and testing purposes, without requiring a subscription.”
\nWe counted them. On n8n’s master branch at commit a5eada9 (October 20, 2026), 1,320 of 31,957 files match that rule, about 4%. Of those, 464 are tests and 856 are not. The folder names read like the paid feature list: sso.ee, ldap.ee, log-streaming.ee, source-control.ee, environments.ee and external-secrets.ee among 19 folder names of that kind.
\nThat code is in the copy you install. The npm package of n8n 2.44.4, the stable release on October 20, holds 789 such files among its 6,524, in folders such as sso.ee and ldap.ee. So the license key, not the download, decides which of those features switch on. With no key, n8n says, a self-hosted instance “runs as the free Community edition.”
\nn8n’s edition comparison says the free Community edition “includes almost the complete feature set.” It lists what it leaves out:
\nWe expect the sharing gap to be the first one a small team hits. Without it, “only the instance owner and the user who creates them can access workflows and credentials.” If you register with an email address, a free key adds folders, debug in editor and custom execution data.
\nThe paid step is large. n8n’s pricing page showed us the self-hosted Business plan at 667 euros a month, billed yearly, for 40,000 executions. Its feature list includes SSO, Git version control and 6 shared projects. A Start-up Plan gives companies under 20 employees 50% off, if they qualify. A paid key “must ping our license server daily to stay active,” and that ping reports production execution counts.
\nOne inconsistency: the Business card lists “Queue mode for scaling” as a feature, while the documentation says queue mode is included in Community. The docs also call the pricing page the source of truth. Check both before you plan around queue mode.
\nIn our cost test on October 20, 2026, n8n peaked at 884 MiB of memory over 1,000 webhook runs, so we recommended a 2 GiB server. The company’s own sizing example gives 320 MB to 2 GB of memory.
\nPrices for that size, read October 20, 2026:
\n| Provider | \nPlan | \nCPU and memory | \nMonthly price | \nBackups | \n
|---|---|---|---|---|
| DigitalOcean | \nBasic droplet | \n1 vCPU, 2 GiB | \n$12.00 | \n20% of the droplet price weekly, 30% daily | \n
| Hetzner, EU | \nCPX12 | \n1 vCPU, 2 GB | \n€11.99 excl. VAT | \nFrom €1.20 a month, priced by server | \n
| Hetzner, US | \nCPX11 | \n2 vCPU, 2 GB | \n€17.99 excl. VAT | \nFrom €1.20 a month, priced by server | \n
n8n’s Hetzner guide says “the CPX11 type is enough” for most usage; Hetzner listed it only in its two US locations. Hetzner’s cheaper cost-optimized plans, from €5.99 for 4 GB, were labeled “not available” when we read the page.
\nWith weekly backups, the DigitalOcean server comes to $14.40 a month before tax, or $172.80 a year. The Business plan costs 8,004 euros a year at the price we were shown. So the server is the small part of the bill. The license fee is the big one, and a team pays it only once it needs a paid feature such as SSO, Git or shared projects.
\nn8n is blunt about who should do this: “n8n recommends self-hosting for expert users. Mistakes can lead to data loss, security issues, and downtime.” Four jobs come with the server.
\nUpdates. n8n “releases a new minor version most weeks,” and its update page says “try to update at least once a month” and read the release notes for breaking changes. It suggests testing the update in Environments first. Environments is a paid feature. On the free edition, a second instance can serve as the test copy; the FAQ allows running several.
\nBackups. A full backup is the .n8n folder plus your database. The folder holds the encryption key for every stored credential, and without it a restored database “can’t be decrypted.” With the default SQLite database, you stop n8n before copying the folder. n8n recommends a full backup before every update, and the built-in CLI export holds only workflows and credentials, not users or execution history.
The database. n8n uses SQLite out of the box. Its Docker Compose guide says SQLite “is fine for trying things out, but for a production instance that must handle more than a handful of users or workflows running around the clock use Postgres instead.” That is a second service to run and back up. n8n supports Postgres 16 to 18, and that range shifts each year.
\nScaling. Queue mode hands executions to separate worker processes through a Redis queue, and n8n doesn’t recommend it with SQLite. So scaling up means Redis and workers on top of Postgres. A single instance avoids all of that.
\nWe have not timed this upkeep, so we won’t put an hour figure on it. Our payback formula shows how to count it once you know your own.
\nThe decision is about who touches the editor, then about which paid features you can live without.
\nBefore you install, write down who will open the editor. If every name on the list works for you, the license costs nothing.
\nWe read both license texts, n8n’s FAQ, docs and pricing page, and two hosts’ price pages on October 20, 2026. We counted the enterprise-licensed files from n8n’s GitHub file list and its npm package. We did not install n8n for this piece; the memory figure comes from our earlier test.
\nArc stops opening on Mac and Windows on December 22, and account data is deleted within 30 days after.
If you use Arc for work, import it into Dia or move your passwords to another manager before December 22. Arc's own export saves only tab links, not logins.
The Browser Company will shut Arc down on December 22, 2026, it said on Arc’s homepage on October 22. That day Arc stops working on macOS and Windows; account data is deleted within 30 days. TechCrunch and Digital Trends reported the same dates. Teams that work in Arc have two months to move their saved logins, and by Arc’s own FAQ, its export tool will not carry them.
\nThe company’s stated reason is security. “Keeping a browser secure takes constant, dedicated work that is only increasing in the age of AI,” the farewell page says. Its engineering and security teams will focus on Dia, the browser it built after Arc.
\nThe shift had been visible for a while. TechCrunch reports that active feature work on Arc stopped in 2025, and Digital Trends calls Arc long in “maintenance-only mode.”
\nAtlassian agreed in September 2025 to buy The Browser Company for about $610 million in cash. Atlassian’s Mike Cannon-Brookes said then that “today’s browsers weren’t built for work.” Of the two browsers it bought, only Dia remains.
\nDo not expect an open-source Arc soon. CEO Josh Miller told TechCrunch the company can’t do that meaningfully without also open-sourcing ADK, the internal toolkit that Dia runs on too.
\nThe timeline on arc.net runs in three steps:
\nUntil December 22, Arc “will continue to work as usual and will receive basic updates,” the FAQ says.
\nWe read the FAQ closely, and the two exit routes are not equal. Importing into Dia brings over passwords, history, tabs, bookmarks and extensions, with Spaces renamed Profiles and Folders renamed Tab Groups. The timeline says the new release can “export all of your data out of Arc.” But the FAQ’s steps for using tabs in another browser end in “a list of links.”
\nThe FAQ describes no other way to take saved passwords out of Arc.
\nThat is the trade-off. Dia is free, and the company says Arc’s features stay free there and “the AI is optional.” But Dia comes from the company that is ending Arc. Leaving for another browser avoids that bet, at the cost of moving logins separately.
\nAfter December 22 the company “will no longer be able to identify or retrieve Arc user data for data requests.” There is no recovery later.
\nOffice Scripts runs in Excel on the web and in Power Automate flows, and VBA runs in neither.
Ask of each macro: does it touch anything outside the workbook? Keep those in VBA. Move the workbook-only jobs that need a browser or a schedule, and search for VBScript.RegExp.
Microsoft’s own comparison page puts the split in one line: VBA macros “are developed for desktop solutions” and Office Scripts “are designed for secure, cross-platform, cloud-based solutions.” For a small office with a folder of .xlsm files, that line sets the limits. A browser tab and a 6 a.m. flow with nobody at the PC are two places VBA can’t go.
\nOn October 20, 2026, we read Microsoft’s documentation and built the table below from it. Then we wrote one small job both ways. Our view, in short: keep VBA for anything that reaches outside the workbook, and move the workbook-only jobs that must run in a browser or with nobody at the keyboard.
\nEvery row comes from a Microsoft page listed under Sources. The differences page itself was last updated in November 2023, so where a newer page says more, the newer page wins.
\n| \n | VBA macros | \nOffice Scripts | \n
|---|---|---|
| Excel for Windows | \nYes | \nVersion 2210 or later | \n
| Excel for Mac | \nYes | \nYes | \n
| Excel on the web | \nNo. Macros stay in the file but can’t run or be edited | \nYes | \n
| Excel for iOS | \nNo | \nNo | \n
| Word, Outlook, PowerPoint | \nYes | \nNo, Excel only | \n
| Run by Power Automate | \nNo connector | \nYes, the Run script action | \n
| Language | \nVBA | \nTypeScript 4.0.3, with no any type and no eval | \n
| Where the code lives | \nInside the workbook, saved as .xlsm (.xlsx can’t hold it) | \n.osts files in the author’s OneDrive, or on SharePoint | \n
| What it can reach | \nThe whole desktop: COM and OLE, DLLs, the file system | \nThe workbook only | \n
| Calls to the web | \n“No convenient way” | \nfetch from Excel only; it fails inside Power Automate | \n
| Events such as open or change | \nYes | \nNo | \n
| Starts when | \nSomeone runs it, or an event fires | \nSomeone runs it, presses a script button, or a flow calls it | \n
| Recorder | \nRecord Macro on the Developer tab | \nAction Recorder on web, Windows, Mac | \n
| License | \nBuilt into desktop Excel | \nA business or education plan; Personal and Family in preview | \n
| Admin switch | \nAllow all or none, or only signed macros | \nOn or off for the tenant or one group | \n
Two rows matter most for a small office. Office Scripts is the only one of the two that runs in Excel on the web. And it is the only one Power Automate can start, so it is the only one that can update a workbook “without even opening Excel.”
\nVBA’s strength is reach. Microsoft’s VBA guide says it can work with “two or more Office applications at the same time.” Its own samples create an Outlook email and copy an Outlook contact into Word.
\nFileSystemObject “provides access to a computer’s file system.” The Declare statement lets it call procedures in a DLL. VBA macros “have the same security clearance as Excel,” says the differences page, which “gives them full access to your desktop.”
\nThat reach is why Microsoft changed the default. “VBA macros are a common way for malicious actors to gain access to deploy malware and ransomware,” its admin guide says. So Office on Windows now blocks macros in files from the internet.
\nThe change started rolling out to Current Channel on July 27, 2022. Semi-Annual Enterprise Channel got it on January 10, 2023.
\nThe test is the Mark of the Web, a tag Windows adds to downloads and email attachments. A macro file that carries it opens with a Security Risk banner, and that banner has no Enable content button. Office on a Mac, on the web, and on iOS and Android devices is not affected.
\nThe fixes Microsoft lists are concrete. Right-click the file, choose Properties and tick Unblock.
\nFiles opened from OneDrive or SharePoint with Open in Desktop App, or synced by the OneDrive client, don’t get the mark. A Trusted Location skips the check entirely, which is why Microsoft says to use those “sparingly.” Group policies for this exist only in Microsoft 365 Apps for enterprise, not in Apps for business.
\nThe second change is slower. In a September 2025 post, Microsoft’s Wenjun Gong named two VBA habits that depend on VBScript: running external .vbs files, and referencing VBScript’s library for regular expressions (VBScript.RegExp).
The plan has three phases. Today VBScript stays on by default. In “approximately 2026 or 2027” it will be turned off by default.
\nAt an unnamed date it will be removed from Windows, and then “calling .vbs scripts from VBA will no longer be supported.” RegExp references will break “unless the Office client is updated to a supported build.”
\nThat build is Office Version 2508 (Build 19127.20154) on Windows, which puts RegExp classes into VBA itself. Replying to a reader in the comments, Gong added: “We did not make any change to Scripting.FileSystemObject and Scripting.Dictionary.” So the check is short: search your modules for .vbs and VBScript.RegExp.
Office Scripts trades reach for safety. Scripts “only have access to the workbook, not the machine hosting the workbook,” and they get no sign-in token for the user. There is no file system, no other Office app and no DLL.
\nWeb calls exist, with limits. A script can use fetch when it runs inside Excel. But “there is no way to sign in or use OAuth2,” so keys must be hard-coded or read from somewhere else.
Scripts stored on SharePoint can’t make the calls at all. In a flow, fetch fails with “fetch is not defined,” and Microsoft points you to Power Automate’s own HTTP actions instead.
Storage is the quiet trap. Scripts live as .osts files in the author’s OneDrive, under /Documents/Office Scripts/.
\nSharing a script with a workbook links it rather than attaching it, and the script “remain[s] in the script creator’s OneDrive.” When that person leaves, what happens to the script depends on your OneDrive retention policy. Scripts saved to a SharePoint site “are owned by your team,” which makes that the safer home for anything shared, unless the script uses fetch.
Office Scripts has no workbook events. A script runs when a person starts it or “when a Power Automate flow calls the script.” The built-in scheduler inside Excel is “temporarily disabled,” Microsoft’s overview says, so a flow is now the way to run a script daily.
\nThe platform limits page gives the numbers:
\nA hypothetical flow that runs one script on 40 workbooks every hour makes 960 calls a day, inside the cap. For scripts that run long, Microsoft says to speed them up or “split your Excel automation into multiple script calls.”
\nFlows also change behavior. Power Automate runs each script “in independent Excel sessions,” so getActiveWorksheet returns the first sheet unless the script activated another, and getSelectedRange throws. Pivot refreshes do nothing. And “Power Automate always uses UTC,” while a person in Excel gets local time, so “today” can differ by a day.
VBA “requires no special licensing” in desktop Excel. Office Scripts needs a business or education plan. Microsoft’s list names Office 365 Business and Business Premium, ProPlus, Enterprise E1, E3 and E5, F3, and the education plans A3 and A5.
\nThe list uses Office 365 plan names, so if your plan goes by another name, look for the Automate tab in Excel on the web before you plan a move. Personal and Family plans get Office Scripts only as a preview through the Microsoft 365 Insider program, and can’t share scripts through workbooks.
\nAdmins have little to do. Office Scripts is “turned on by default” for everyone, and a change to its settings “can take up to 48 hours” to apply.
\nHere is one small job written twice. On a sheet called Invoices, color every unpaid row whose due date has passed. Then copy those rows to a fresh sheet called Overdue. Both assume the table starts in cell A1, with due dates in column C and the status in column D.
\nThe VBA version:
\nSub CopyOverdue()\n ' Table starts in A1: headers, due date in C, status in D.\n Dim src As Worksheet, dst As Worksheet, data As Range\n Dim r As Long, outRow As Long, due As Variant\n\n Set src = ThisWorkbook.Worksheets(\"Invoices\")\n Set data = src.UsedRange\n\n Application.DisplayAlerts = False ' delete without the prompt\n On Error Resume Next ' no Overdue sheet yet is fine\n ThisWorkbook.Worksheets(\"Overdue\").Delete\n On Error GoTo 0\n Application.DisplayAlerts = True\n\n Set dst = ThisWorkbook.Worksheets.Add(After:=src)\n dst.Name = \"Overdue\"\n data.Rows(1).Copy dst.Range(\"A1\")\n outRow = 2\n\n For r = 2 To data.Rows.Count\n due = data.Cells(r, 3).Value\n If VarType(due) = vbDate Then\n If due < Date And data.Cells(r, 4).Text <> \"Paid\" Then\n data.Rows(r).Interior.Color = RGB(255, 199, 206)\n data.Rows(r).Copy dst.Cells(outRow, 1)\n outRow = outRow + 1\n End If\n End If\n Next r\nEnd SubThe Office Scripts version:
\nfunction main(workbook: ExcelScript.Workbook) {\n // Table starts in A1: headers, due date in C, status in D.\n const src = workbook.getWorksheet(\"Invoices\");\n const data = src?.getUsedRange();\n if (!src || !data) {\n throw new Error(\"No Invoices sheet, or it is empty\");\n }\n const values = data.getValues();\n\n workbook.getWorksheet(\"Overdue\")?.delete();\n const dst = workbook.addWorksheet(\"Overdue\");\n dst.getRange(\"A1\").copyFrom(data.getRow(0));\n\n // Excel stores dates as serial numbers: day 25569 is January 1, 1970.\n const now = new Date();\n const today = Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()) / 86400000 + 25569;\n\n let outRow = 1;\n for (let r = 1; r < values.length; r++) {\n const due = values[r][2];\n if (typeof due === \"number\" && due < today && values[r][3] !== \"Paid\") {\n data.getRow(r).getFormat().getFill().setColor(\"#FFC7CE\");\n dst.getCell(outRow, 0).copyFrom(data.getRow(r));\n outRow++;\n }\n }\n}The two look alike, but three details differ. VBA reads a date cell as a Date, while getValues returns a plain number. So the script builds today’s serial number itself, with the 25569 offset from Microsoft’s date samples.
The macro reads cell by cell, while the script reads every value once, before the loop, as Microsoft’s performance guide advises. And run from a flow, its “today” is the UTC date. For an office west of UTC, that date turns over before local midnight, so a late-day run counts invoices due today as overdue.
\nWhat we checked: the script passes the TypeScript compiler in strict mode against the Office Scripts signatures it uses. That was compiler version 5.9.3, not the 4.0.3 that Office Scripts runs.
\nWe ran it once against a mock workbook of six rows. It marked and copied the two overdue rows and left the paid row, the row due today, the blank date and the text date alone. We did not run either version in Excel.
\nTwo gaps remain. Neither version clears old highlights, so a row paid since the last run stays colored. And a plain number in column C counts as a date in the script but not in the macro.
\nPython in Excel “runs the Python code used by Excel in a secure container on the Microsoft Cloud,” Microsoft says. The code “doesn’t have access to your computer, devices, or account” and “doesn’t have network access.” It reads only the data a formula references.
\nIt runs for Enterprise and Business users on Windows and Mac and in Excel on the web, but not on iPad, iPhone or Android. Faster premium compute needs an add-on license. Use it to analyze a range. With no access to the PC or the network, it can’t replace a macro that saves files or sends mail.
\nThe decision comes down to one question per macro: does it touch anything outside this workbook?
\nKeep VBA when the macro drives Outlook or Word, touches files on disk or a DLL, or runs on a workbook event such as open or save. A script can’t do those itself. A flow around it can cover part of the gap: Microsoft’s samples pair scripts with flows that send email and Teams messages.
\nClear the two security items while you are there. Keep shared macro files on OneDrive or SharePoint and open them with Open in Desktop App or through the sync client, so the Mark of the Web isn’t added. Then search the code for .vbs and VBScript.RegExp before Windows turns VBScript off.
Move to Office Scripts when the job stays inside the workbook and people open it in a browser, or when it should run with no one at the PC. Start with the Action Recorder, which captures cell edits and formatting, then tidy the code.
\nThe traps that bite during a move, all from Microsoft’s own pages:
\nWorkbook_Open or change events. Use a scheduled or event-driven flow instead.getActiveWorksheet and getSelectedRange assume a person is looking. In a flow, name the sheet.fetch works when you press Run and fails in the flow.If you are already moving email or file jobs out of macros, our guides to email data into Excel and saving Outlook attachments use the same Power Automate pieces.
\nThis week, list every .xlsm file the office uses and mark each macro “outside” or “inside.” Move the inside ones that people open in a browser or want on a schedule first, and leave the rest where they work.
\nWe read Microsoft’s documentation and its VBScript post on October 20, 2026, and built the table from them. We type-checked the Office Script and ran it once against a six-row mock workbook in Node. Neither version ran in Excel, and the VBA was not run at all.
\neMudhra is leaving web certificates five days after a researcher showed anyone could recover eight of its CA keys.
Update ca-certificates, Node.js, Java, Go, Python certifi and Docker Desktop to the fixed versions, then rebuild container images. That closes a path for forged certificates against your services.
eMudhra, an Indian certificate authority, said on October 22 that its board has decided to “voluntarily withdraw from the global SSL/TLS certificate business.” Reuters reported the exit the same day. It follows the discovery that eight of its intermediate CA keys could be recovered by anyone. Browsers already block those certificates, so the risk that remains sits in servers and containers that never got the update.
\nOn October 17, a researcher named Wayne signed a message with the private key of each of the eight intermediates and reported it. That is the account of the disclosure site run by Mozilla’s Dennis Jackson. The keys were generated wrongly in April 2025, so “anyone can recover them from the certificates.” Help Net Security reports each key was smaller than 256, so recovering one took at most 256 guesses.
\neMudhra’s own statement blames “a flaw in the KGC” that produced weak keys alongside the strong ones.
\nWith one of those keys, an attacker “could impersonate any website or service,” the disclosure site says. The tooling is public: mitmproxy, a widely used interception proxy, added an option to “sign certificates with a compromised eMudhra intermediate CA key.”
\nFirefox and Chrome have blocked the certificates since October 17, Apple since October 19 and Microsoft since October 20, per the disclosure site. Chrome used CRLSets, and the Chrome Root Program wrote that Root Store version 43 will remove the eMudhra root. No Certificate Transparency log holds entries for these intermediates, the site notes. So CT-enforcing browsers “could not have been attacked.”
\nBut many other clients check neither revocation nor CT. Revocation alone does nothing for them. They need a software update.
\nThe disclosure site runs test servers signed by the broken intermediates and publishes how many clients still connect. We read that file at 14:37 UTC on October 22.
\nIn the 71 minutes since its counter started at 13:26 UTC, it logged 50,866 successful connections from clients that still trusted the chains. The largest groups were iOS WebViews (9,882), curl 8 (8,323), Safari on iOS (7,036 across versions 26 and 27) and the Zabbix monitoring agent (2,273). These count connections rather than devices, from people who chose to run the test. Still, they show that a vendor block does not reach every client at once.
\neMudhra says it revoked the CAs within 14 hours of discovery, that no customer certificates were issued from them and that its infrastructure was not breached. It puts global SSL/TLS at about 1% of revenue and calls the scrutiny “out of proportion.”
\nIts G1 RSA roots keep serving customers during the transition. It will replace affected certificates at no cost. Reuters reports the shares fell 40% over two days.
\ncurl https://dv-g3b-emudhra.we-have-a-problem.com/ from the machine that matters. A certificate error is the good result.The trade-off: the site warns that removing roots by hand is “NOT recommended for ordinary users.” Its commands also drop AAA Certificate Services, the root Sectigo used to cross-sign the eight. Where a vendor update exists, take that instead.
\nGmail's built-in mail merge sends the same attachment to everyone and can't put a name in the subject line.
Before a real send, set testTo to your own address and run the script once. You get up to 3 sample emails to check, and the sheet stays untouched.
Google gives you two ways to mail merge from a Google Sheet. Gmail’s own mail merge reads names and addresses from a sheet and sends each person a separate copy. It works only on seven Workspace plans, and it attaches the same file to every copy. If each person needs their own document, such as a certificate or an invoice, you need a short Apps Script instead.
\nThis guide covers both. The script below fills a Google Docs template for each row, saves it as a PDF, emails it from Gmail and writes a status back to the sheet, so a second run skips rows already sent. We tested its logic on 5 sample rows in Node.js, with stand-ins for Google’s services, because we had no Google account to run it in. Limits are from Google’s pages, read on October 20, 2026.
\nGmail’s mail merge works on the email itself. Google’s help page says “each recipient gets a unique copy of the email in which the merge tags are replaced with your details.” Tags come from your column headers: a column named Course becomes @Course in the message. Recipients can’t see who else got it, and their replies arrive in separate threads.
That design sets three limits. You “can’t use merge tags in” subject lines or in linked text. A file you attach is the same file for everyone, and Google warns it is stored in every copy: 500 recipients with a 10 MB attachment use “about 5GB of your storage.” Mail merge also can’t be used for scheduled sends.
\nSo the built-in tool fits an announcement or an event invitation. It does not fit “here is your certificate, Ada”, where the document itself changes per person.
\nGoogle Docs has no built-in merge from a sheet that we could find. Its variable chips let you type a value once and see it everywhere in one document, on eligible work or school accounts. You still enter each value by hand. Google’s own merge into Docs is a Docs API sample written in Python, which is a developer project, not a menu.
\n| \n | Gmail mail merge | \nOur Apps Script | \n
|---|---|---|
| Accounts | \nWorkspace Individual, Business Standard and Plus, Enterprise Standard and Plus, Education Standard and Plus | \nAny Google account | \n
| A document per person | \nNo: one attachment, same for all | \nYes: a PDF made from a Docs template | \n
| Tags in the subject | \nNo | \nYes | \n
| Emails a day | \nUp to 1,500 recipients | \n100 on personal Gmail, 1,500 on Workspace | \n
| Unsubscribe link | \nAdded to every email | \nNone; add your own line | \n
| Remembers who got it | \nSent folder banner | \nStatus column in the sheet | \n
Our view: use Gmail’s mail merge when everyone gets the same message and you have an eligible plan. It needs no code and adds the unsubscribe link for you. Use the script when each person needs their own PDF, or when you are on personal Gmail or Business Starter, which are not on Google’s list of eligible plans.
\nWorkspace admins also control who you can reach. Google’s 2023 announcement said Enterprise and Education editions limit mail merge to internal recipients by default, while Business Standard and Plus allow external recipients. Admins can turn external sending on for a group or organizational unit.
\nBoth routes read the same kind of sheet: a header row, then one row per person. Gmail’s mail merge adds two rules. “Contact information must be in the first tab of your spreadsheet and can only contain text.” And a header with characters other than letters or numbers gets a tag by its position, such as @A for the first column, so plain headers like FirstName are easier to use.
For the script, the tab is named Recipients and needs a column called Email. Any other header becomes a placeholder. Our sample sheet:
| Name | \nCourse | \nDate | \nPrice | \n|
|---|---|---|---|---|
| ada@lind.example | \nAda Lind | \nBookkeeping basics | \n10/14/2026 | \n$1,200.00 | \n
| carl@holm.example | \nCarl Holm Jr. | \nPayroll 101 | \n10/15/2026 | \n$900.00 | \n
The script reads each cell as it is shown, through getDisplayValues(), which “takes into account date, time and currency formatting.” So $1,200.00 arrives in the PDF as $1,200.00, not as 1200. Format a column in the sheet, and that format is what the reader sees.
If the built-in route fits, these are Google’s steps:
\n@, pick a tag such as @Course, and press Enter.If a recipient is missing a value for a tag, Gmail shows an error. You can type a default there, so “Hi @firstname” becomes “Hi friend”, or fix the sheet. Google’s page describes no preview step, so send one merge to yourself first with your own address as the only row.
\nTwo catches. With recipients from a sheet you “can’t include Cc or Bcc recipients.” And Gmail adds an unsubscribe link to each email but you “can’t get a list of all unsubscribed recipients.” You get one notification email per unsubscribe, so keep a note of them.
\nThe script route starts with a normal Google Doc. Write the certificate, letter or invoice once, and put each column name in double braces where the value should go: {{Name}}, {{Course}}, {{ Date }}. Spaces inside the braces are allowed. The names must match the headers exactly, capitals included.
Our test template had a header line, four body lines and a footer:
\nExample Training\nCertificate\n{{Name}}\nhas completed {{Course}} on {{ Date }}.\nFee paid: {{Price}}\nIssued to {{Name}}The script fills the body, the header and the footer. It reads only the first tab: Google’s reference says getBody() “retrieves the first tab’s Body”, and the same holds for the header and footer. Keep the template on one tab.
Copy the Doc’s ID from its address bar, the long string between /d/ and /edit. Make a Drive folder for the PDFs and copy its ID, the part of its address after folders/.
Open the sheet and choose Extensions, then Apps Script. That makes a script bound to the sheet. Paste the code over the empty myFunction, edit CONFIG, save, and reload the sheet. A Mail merge menu appears.
The first run asks you to authorize the script. Sending through GmailApp needs full Gmail access, the https://mail.google.com/ scope. Google’s own mail merge sample notes you may see “This app isn’t verified”; for a script you wrote, choose Advanced, then go to the project.
// Mail merge: each row of a sheet becomes a PDF made from a Docs template and a Gmail message with it attached.\n// Paste into Extensions > Apps Script in the spreadsheet, edit CONFIG, reload the sheet, use the Mail merge menu.\nconst CONFIG = {\n sheet: 'Recipients', // tab with a header row and a column named Email\n templateId: 'PASTE_TEMPLATE_DOC_ID', // the Docs template, with {{Column name}} placeholders\n folderId: 'PASTE_DRIVE_FOLDER_ID', // where the PDFs are saved\n fileName: 'Certificate {{Name}}',\n subject: 'Your certificate, {{Name}}',\n body: 'Hi {{Name}},\\n\\nYour certificate for {{Course}} is attached.\\n\\nBest regards,\\nAnna',\n senderName: 'Anna at Example Training',\n optional: [], // columns that may be empty; any other empty placeholder skips the row\n skipDuplicates: true, // a second row with an address already sent to is skipped\n keepDocs: false, // true keeps each filled Doc copy next to its PDF\n testTo: '', // your own address: sends up to 3 rows to you and writes nothing back\n maxPerRun: 50,\n};\nconst STATUS = 'Status', SENT_AT = 'Sent at';\nconst TIME_BUDGET_MS = 4.5 * 60 * 1000; // stop well before the 6-minute limit per run\n\nfunction onOpen() {\n SpreadsheetApp.getUi().createMenu('Mail merge').addItem('Send pending rows', 'sendMerge').addToUi();\n}\n\nfunction sendMerge() {\n const lock = LockService.getScriptLock();\n if (!lock.tryLock(10000)) return say('Another run is still sending. Try again in a minute.');\n try { return say(run()); } finally { SpreadsheetApp.flush(); lock.releaseLock(); }\n}\n\nfunction run() {\n const started = Date.now();\n const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(CONFIG.sheet);\n if (!sheet) throw new Error('No tab named ' + CONFIG.sheet);\n const data = sheet.getDataRange().getDisplayValues();\n const header = data[0].map(h => h.trim());\n if (header.indexOf('Email') < 0) throw new Error('No column named Email');\n const test = Boolean(CONFIG.testTo);\n for (const name of [STATUS, SENT_AT]) {\n if (!test && header.indexOf(name) < 0) { header.push(name); sheet.getRange(1, header.length).setValue(name); }\n }\n const emailCol = header.indexOf('Email'), statusCol = header.indexOf(STATUS), sentAtCol = header.indexOf(SENT_AT);\n const mark = (row, text) => test ? console.log(`row ${row}: ${text}`) : sheet.getRange(row, statusCol + 1).setValue(text);\n\n const seen = new Map(); // address -> first row that was sent, or may have been\n data.forEach((r, i) => { if (i && /^(Sent|Sending|Check)/.test(r[statusCol] || '')) seen.set(norm(r[emailCol]), i + 1); });\n const unsure = data.filter((r, i) => i && /^(Sending|Check)/.test(r[statusCol] || '')).length;\n\n let quota = MailApp.getRemainingDailyQuota(), sent = 0, stop = '';\n for (let i = 1; i < data.length; i++) {\n const row = i + 1, r = data[i], status = r[statusCol] || '';\n if (/^(Sent|Sending|Check)/.test(status)) continue; // done, or waiting for a person to look\n if (r.every(v => v === '')) continue; // blank row\n const email = norm(r[emailCol]);\n if (!email) { mark(row, 'Skipped: no email'); continue; }\n if (!/^[^\\s@,;]+@[^\\s@,;]+\\.[^\\s@,;]+$/.test(email)) { mark(row, 'Skipped: not one email address'); continue; }\n if (CONFIG.skipDuplicates && seen.has(email)) { mark(row, 'Skipped: same address as row ' + seen.get(email)); continue; }\n if (sent >= (test ? 3 : CONFIG.maxPerRun)) { stop = 'the per-run limit'; break; }\n if (Date.now() - started > TIME_BUDGET_MS) { stop = 'the time budget'; break; }\n if (quota < 1) { stop = 'the daily email quota'; break; }\n\n const values = Object.create(null); // no inherited keys, so {{constructor}} is not a column\n header.forEach((h, c) => { values[h] = (r[c] || '').trim(); });\n let pdf, subject, body;\n try {\n subject = fill(CONFIG.subject, values);\n body = fill(CONFIG.body, values);\n pdf = makePdf(values);\n } catch (e) { mark(row, 'Error: ' + e.message); continue; } // nothing was sent; the next run tries again\n\n if (!test) { mark(row, 'Sending'); SpreadsheetApp.flush(); } // a crash after this line leaves a visible trace\n try {\n GmailApp.sendEmail(test ? CONFIG.testTo : email, subject, body, { attachments: [pdf], name: CONFIG.senderName });\n } catch (e) {\n mark(row, 'Check: ' + e.message + '. Look in Sent, then clear this cell to retry.');\n continue;\n }\n quota--; sent++;\n seen.set(email, row);\n if (!test) { mark(row, 'Sent'); sheet.getRange(row, sentAtCol + 1).setValue(new Date()); }\n }\n return `Sent ${sent}` + (test ? ' test emails to ' + CONFIG.testTo : '')\n + (stop ? `. Stopped at ${stop}; run again to continue.` : '.')\n + (unsure ? ` Rows marked Sending or Check: ${unsure}. Look in Sent before clearing them.` : '');\n}\n\nfunction say(msg) {\n console.log(msg);\n SpreadsheetApp.getActiveSpreadsheet().toast(msg, 'Mail merge', 15);\n return msg;\n}\n\nfunction makePdf(values) {\n const folder = DriveApp.getFolderById(CONFIG.folderId);\n const name = fill(CONFIG.fileName, values);\n const copy = DriveApp.getFileById(CONFIG.templateId).makeCopy(name, folder);\n try {\n const doc = DocumentApp.openById(copy.getId());\n for (const part of [doc.getBody(), doc.getHeader(), doc.getFooter()]) {\n if (!part) continue;\n const keys = new Set([...part.getText().matchAll(/\\{\\{\\s*([^{}]+?)\\s*\\}\\}/g)].map(m => m[1]));\n for (const key of keys) replaceLiteral(part, key, lookup(values, key));\n const left = part.getText().match(/\\{\\{[^{}]*\\}\\}/);\n if (left) throw new Error('template still contains ' + left[0]);\n }\n doc.saveAndClose();\n const pdf = copy.getAs('application/pdf').setName(name + '.pdf'); // getAs alone cuts names after a period\n if (!CONFIG.testTo) folder.createFile(pdf); // a test run keeps no PDFs\n return pdf;\n } finally {\n if (!CONFIG.keepDocs) copy.setTrashed(true);\n }\n}\n\n// Inserts the value as plain text. replaceText() would read the template's placeholder as a regular expression.\nfunction replaceLiteral(part, key, value) {\n const pattern = '\\\\{\\\\{\\\\s*' + key.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&') + '\\\\s*\\\\}\\\\}';\n for (let hit = part.findText(pattern); hit; hit = part.findText(pattern)) {\n const text = hit.getElement().asText();\n const start = hit.isPartial() ? hit.getStartOffset() : 0;\n const end = hit.isPartial() ? hit.getEndOffsetInclusive() : text.getText().length - 1;\n if (value) text.insertText(start, value); // an empty optional value only deletes\n text.deleteText(start + value.length, end + value.length);\n }\n}\n\nfunction fill(template, values) {\n return template.replace(/\\{\\{\\s*([^{}]+?)\\s*\\}\\}/g, (_, key) => lookup(values, key));\n}\n\nfunction lookup(values, key) {\n if (!(key in values)) throw new Error('no column named ' + key);\n const v = values[key];\n if (!v && !CONFIG.optional.includes(key)) throw new Error('empty ' + key);\n if (v.includes('{{')) throw new Error(key + ' contains {{');\n return v;\n}\n\nfunction norm(v) { return String(v || '').trim().toLowerCase(); }The status column is the memory. Before each send the script writes Sending and calls SpreadsheetApp.flush(), which “applies all pending Spreadsheet changes.” After the send it writes Sent and the time. Any later run skips rows marked Sent, Sending or Check.
A failed send never retries by itself. If sendEmail throws an error, the row gets Check and the error text. If the run dies between the send and the Sent mark, the row stays Sending. Neither tells you whether the email left. So the script waits for you: look in Gmail’s Sent folder, and clear the cell only if the email is not there. We chose a missed email over a double one.
Duplicates and bad cells are skipped. A second row with the same address, in any capitals, gets Skipped: same address as row 2. Set skipDuplicates to false if one person should get two documents. A cell with two addresses is refused, because sendEmail takes “the addresses of the recipient” and would send to both. The check catches a malformed address, not a dead one. Clean old lists first: Gmail’s help for personal accounts says that after many emails bounce, you “may be able to send emails again after 24 hours.”
Empty values stop the row. An empty cell behind a placeholder gives Error: empty Name instead of “Hi ,”. List columns that may be empty in optional. A misspelled placeholder such as {{Nmae}} gives Error: no column named Nmae. Error rows are tried again on the next run, since nothing was sent.
Values go in as plain text. Apps Script’s replaceText() reads its search pattern as a regular expression, Google’s Body reference says. It doesn’t say how the replacement treats characters like $. So the script finds each placeholder and inserts the value with insertText() instead. A value like $1,200.00 stays as typed.
PDF names keep their periods. Google’s File reference says getAs() treats the text after the last period as an extension and replaces it: “ShoppingList.12.25.2014” becomes “ShoppingList.12.25.pdf”. A row for “Carl Holm Jr.” would lose part of its name, so the script sets the name again.
Two runs can’t overlap. A script lock “prevents any user from concurrently running a section of code.” Click the menu twice and the second click waits 10 seconds, then gives up.
\nSet testTo to your own address and run Mail merge, then Send pending rows. The script makes the PDFs for the first 3 sendable rows and emails all 3 to you. It writes nothing to the sheet and saves no PDFs in the folder.
Open each PDF. Check the name, the dates and the money columns, and that no {{ is left anywhere. Then clear testTo.
Run Send pending rows again. A popup in the corner of the sheet reports the result, such as Sent 3. Each row now has one of these:
| Status | \nMeaning | \nWhat to do | \n
|---|---|---|
Sent | \nEmail sent; Sent at has the time | \nNothing | \n
Skipped: ... | \nNo email, two addresses, or a duplicate | \nFix the cell; the next run tries again | \n
Error: ... | \nTemplate or data problem; nothing was sent | \nFix it; the next run tries again | \n
Check: ... | \nGmail gave an error during the send | \nLook in Sent, then clear the cell to retry | \n
Sending | \nThe run stopped mid-send | \nLook in Sent, then clear the cell to retry | \n
The script stops after 50 emails a run, after 4.5 minutes, or when Google’s daily email count runs out. The popup says which. Run it again to continue.
\nWe could not run Apps Script itself. So we ran the script unchanged in Node.js 22 with small stand-ins for SpreadsheetApp, DocumentApp, DriveApp, GmailApp, MailApp and LockService, written to follow Google’s reference pages. The 5 rows were invented, on .example addresses: Ada, a row with no email, Carl Holm Jr., Ada again as ADA@lind.example with a trailing space, and Dana Berg with (Q4) $1 \\n in her name.
What the 10 cases showed:
\n| Case | \nResult | \n
|---|---|
| Three runs on the 5 rows | \nRun 1: 3 sent, no-email row and duplicate skipped. Run 2: 0 sent. Run 3, after we filled in the missing email: that 1 row sent | \n
| Gmail error on one row, once | \nRow marked Check; not resent on 2 more runs | \n
Same, with skipDuplicates off | \nSame result | \n
Run killed after a send, before Sent | \nRow stayed Sending; next run sent only the last row | \n
| 2 emails left in the day’s quota | \n2 sent, stopped; the rest sent on the next run | \n
| Test mode | \n3 emails to the tester; sheet unchanged; no PDFs kept | \n
{{Nmae}} in the template | \n0 sent; every row Error; Doc copies trashed | \n
{{toString}} in the template | \n0 sent; Error: no column named toString | \n
| Two addresses in one cell | \nRefused | \n
| Lock already held | \nNothing sent | \n
In the first run, our stand-in sheet already showed Sending for each row at the moment its email went out. Values with $, brackets and a backslash landed in the PDF as typed, and “Carl Holm Jr.” kept his full name in the file name. We also broke the script on purpose six ways, such as removing the duplicate check. Each break made at least one case fail, so the cases catch those bugs.
What it does not prove: anything about Google’s servers. Our stand-ins follow the documentation, but the real findText(), PDF export, quotas, timing and Gmail delivery were not part of the run. We don’t know how long one row takes in real Apps Script, so 50 a run is our guess, and the 4.5-minute stop is the backstop. Send yourself a test before any real list.
Apps Script counts emails by recipient, per user, and the count resets “24 hours after the first request,” according to Google’s quotas page (updated September 3, 2026). That is not midnight. If the day’s first email went out at 3 p.m., the count resets around 3 p.m. the next day.
\n| Limit | \nPersonal Gmail | \nGoogle Workspace | \n
|---|---|---|
| Script email recipients a day | \n100 | \n1,500 | \n
| Documents created a day | \n250 | \n1,500 | \n
| Files converted a day | \n2,000 | \n4,000 | \n
| One run | \n6 minutes | \n6 minutes | \n
| Attachments per email | \n25 MB in total | \n25 MB in total | \n
| Gmail’s own daily send limit | \n500 | \n2,000 | \n
| Gmail mail merge a day | \nNot available | \n1,500 recipients | \n
The first line decides most cases. On personal Gmail the script stops at 100 emails a day, even though Gmail itself allows 500. On Workspace, 1,500 emails and 1,500 Doc copies line up, one each per row.
\nWe assume each template copy counts as a document created; Google’s page doesn’t say. Each PDF export likely counts as a conversion too, since the File reference points getAs() to that quota. The script checks what is left with MailApp.getRemainingDailyQuota(), which Google describes as “the number of recipients you can send emails to for the rest of the day.”
Gmail’s mail merge shares its 1,500 with your normal email. Once your regular and merge emails reach 1,500 in a day, the rest of the 2,000 “are reserved for regular emails only.” Google’s Workspace limits page applies its limits “over a rolling 24-hour period” and notes that “Quotas might be different if you’re using Google Apps Script.” It doesn’t say how the script’s 1,500 and Gmail’s 2,000 combine, so plan as if they share one budget.
\nGmail’s own limits block more than the merge. A Workspace user who reaches one “can’t send new messages for up to 24 hours,” and a personal account can send again “within 1 to 24 hours.” Run a big merge on a quiet day, not before a deadline.
\nBoth routes send from your own address, so its reputation carries the risk. Google’s sender guidelines warn that when mail from a domain is often reported as spam, “future messages from you are more likely to be marked as spam.” They ask every sender to keep reported spam “below 0.3%,” and say plainly: “Don’t send messages to people who didn’t sign up to get messages from you.”
\nStricter rules start at volume. Google’s sender FAQ defines a bulk sender as one sending “close to 5,000 messages or more to personal Gmail accounts within a 24-hour period,” counted across the whole domain. One person can’t get there with these limits.
\nA hypothetical team of four on one company domain, each running a 1,500 merge to customers on gmail.com, would send 6,000 and cross it. And “senders who meet the above criteria at least once are permanently considered bulk senders.”
\nBulk senders need SPF, DKIM and DMARC set up for the domain. Their marketing messages need one-click unsubscribe, done with List-Unsubscribe headers; a link in the body alone doesn’t count. Our script can’t add those headers: the options Google documents for sendEmail have no field for them.
The rule applies only to marketing. “Transactional messages are excluded,” the FAQ says, naming confirmations as examples.
\nThat gives a simple split:
\nWhatever you pick, the first real run is the one to watch. Open Gmail’s Sent folder and compare it with the rows marked Sent. The counts should match, and each PDF should carry the right name.
If you also want to fill this kind of sheet from incoming email, our Gmail to Google Sheets guide has a tested script for that, and our checks for scheduled scripts help a silent failure speak up. More guides are under automation.
\nStart with a copy of your real sheet holding just two rows, both with your own address. With skipDuplicates on, one row should come back Sent and the other Skipped: same address as row 2.
We read Google’s help, quota and sender pages on October 20, 2026. The script ran unchanged in Node.js 22 against stand-ins we wrote for Google’s services, on 5 invented rows and 10 cases. It has not run in Apps Script or sent a real email.
\nGitLab rated a new regex flaw 10.0: anyone, without logging in, could run code on a self-managed server.
Check your version under Help > Help and upgrade to the fixed release for your line today. If you patched on October 12, upgrade again: that release does not cover this flaw.
GitLab released seven patch versions on October 21 for CVE-2026-110264, a flaw rated 10.0, the top CVSS score. Under conditions GitLab has not described, an unauthenticated user could run code on a self-managed GitLab server through an integer overflow when it compiles a crafted regular expression. It affects every release from 7.0 on. If your company hosts its own GitLab, this is today’s upgrade.
\nThe Hacker News reported it the same day. GitLab.com is already patched, GitLab says, and Dedicated tenants on 19.3.5-internal0 or 19.4.2-internal0 and later already have the fix. Self-managed servers are the ones at risk.
\nThis did not come out of nowhere. GitLab’s own advisories show a run of bugs in how the server parses and compiles regular expressions:
\nThat last point is the trap. The earlier three only affected 19.2 and newer, so a server on an older line had nothing to patch. This one hits everything back to 7.0, which The Hacker News notes came out in 2014. And a server patched on October 12 is still exposed: 19.4.2 is older than 19.4.3.
\nThe same researcher, joaxcar, is credited on the HackerOne report, and The Hacker News counts four such flaws from that person in a month. The October 21 release also ships a “Ruby regexp repeat ID overflow patch,” per GitLab’s list of changes, which fits The Hacker News’s account that the root cause sits in Onigmo, the regex engine Ruby uses.
\nGitLab’s maintenance policy backports security fixes to the current release and the previous two, which would mean 19.5, 19.4 and 19.3. This time it also shipped 19.2.9, 19.1.9, 19.0.10 and 18.11.13. The policy allows that only “in rare cases.” We read the extra four lines as GitLab’s own signal of how serious it thinks this is.
\nGitLab says nothing about attacks so far. When we checked CISA’s known exploited vulnerabilities catalog at 05:38 UTC on October 22, this CVE was not on it. The same catalog shows why old servers matter, though: in February 2026 CISA added two GitLab flaws from 2021, CVE-2021-39935 and CVE-2021-22175, which means attackers were still using five-year-old bugs.
\nA daily digest would use 8 of Apps Script's 1,500 email recipients and 5 of Power Automate's 6,000 actions.
Write down what starts the job before you pick. If it starts in Google, use Apps Script; if in Outlook, use Power Automate. Either way, name a second owner.
An office that pays for both Google Workspace and Microsoft 365 already owns two automation tools at no extra cost. Google says Apps Script needs nothing but a Gmail account, and Microsoft says a flow without premium connectors runs on a Microsoft 365 license. Each can reach the other suite. Their limits differ, and the limits decide the fit.
\nWe read both vendors’ quota and licensing pages on October 20, 2026, along with the connector references, and set the numbers side by side. Then we counted what one ordinary job, a daily email digest of new spreadsheet rows, uses in each tool. The digest costs nothing in either. What separates them is what can start a job and who can fix it when it breaks.
\nApps Script runs on Google’s servers, and Google lists no price for it. Its FAQ asks “Do I need to pay for Google Workspace to use Apps Script?” and answers: “No. All you need is a Gmail account to begin building with Apps Script.” A paid Workspace account buys higher quotas, not access.
\nPower Automate is free in a narrower sense. Plans such as Office 365 Business Basic, Business Standard, Business Premium, E3 and E5 include limited use rights that Microsoft describes as meant “for personal productivity scenarios”. Those rights cover cloud flows with standard connectors only; premium and custom connectors are “Not included”.
\nThe step up is Power Automate Premium at $15.00 per user a month, paid yearly. A Process license costs $150.00 per bot a month (also paid yearly) and gives one flow its own capacity. For a scheduled or automated flow that uses a premium connector, Microsoft says “only the owner needs to have a Premium license”, so one $15 license can cover a flow the whole office relies on.
\nEvery cell below comes from a vendor page read that day, listed under Sources: mainly Google’s quotas page (updated September 3, 2026), its trigger guide, and Microsoft’s limits page, its license types page and the licensing FAQ.
\n| \n | Apps Script, Gmail account | \nApps Script, Workspace account | \nPower Automate, Microsoft 365 rights | \nPower Automate Premium | \n
|---|---|---|---|---|
| Cost on top of the suite | \n$0 | \n$0 | \n$0 | \n$15 per user a month, paid yearly | \n
| Longest single run | \n6 minutes | \n6 minutes | \n30 days | \n30 days | \n
| Daily budget | \n90 minutes of trigger runtime | \n6 hours of trigger runtime | \n6,000 actions per user | \n40,000 actions per user | \n
| Email from the tool | \n100 recipients a day | \n1,500 recipients a day | \nEach send counts as 1 action | \nEach send counts as 1 action | \n
| Calls to other web services | \n20,000 URL Fetch calls a day | \n100,000 URL Fetch calls a day | \nStandard connectors only | \nPremium and custom connectors too | \n
| Most frequent schedule | \nEvery minute | \nEvery minute | \nEvery 60 seconds | \nEvery 60 seconds | \n
| How many per person | \n20 triggers per script | \n20 triggers per script | \n600 flows owned | \n600 flows owned | \n
| Idle flows | \nNo rule listed | \nNo rule listed | \nMay be turned off after 90 days without a trigger | \nExempt | \n
| At the limit | \nScript throws an error and stops | \nScript throws an error and stops | \nRuns slow down | \nRuns slow down | \n
Google’s quotas are per user and “reset 24 hours after the first request”. Google also says they can change “at any time, without notice”.
\nMicrosoft’s action numbers need one footnote. Its limits page lists higher figures for now, 10,000 a day for Microsoft 365 users and 200,000 for Premium. It says they “aren’t guarantees” and sit above the documented limits during a “licensing transition period”. The FAQ adds that during that period per-user limits “aren’t the ones being applied yet”, and each flow gets one shared limit instead.
\nWe would plan on 6,000 and 40,000, the figures Microsoft lists as the license limits, and treat anything above them as temporary.
\nMicrosoft’s Gmail and Google Sheets connectors are both classed Standard. So a Microsoft 365 license covers them, with no Premium needed.
\nThe Google Sheets connector has no trigger. Its reference lists six actions (Get rows, Get row, Insert row, Update row, Delete Row, Get sheets) and nothing that fires when a row is added. So a new row can’t start a flow; the flow has to check the sheet on a schedule. Get rows takes no filter, starts at the first entry by default, and returns 256 entries unless you raise Top Count. Spreadsheets in shared drives “cannot be selected”, so you paste the file’s ID by hand. Each connection gets 100 calls per 5 minutes.
\nThe Gmail connector treats consumer accounts differently. An @gmail.com account “can only connect to a limited set of services”. Google Sheets, Office 365, OneDrive, SharePoint and Teams are on the approved list, and a flow that uses anything else “will end up being saved in a disabled state”. Workspace accounts are not affected.
\nThe Gmail connector also meters work. Each connection gets 90,000 work units a day, and Send email (V2) costs 100, which works out to at most 900 sent emails a day per connection. The new-email trigger “may skip emails” above 300 in 30 seconds, and on Workspace accounts it “may intermittently skip emails with attachments”. We would not build an invoice inbox on that trigger.
\nApps Script’s built-in libraries cover Google’s own apps, such as Gmail and Drive. To act inside Microsoft 365, a script calls Microsoft Graph with UrlFetchApp. Google’s guide says Apps Script “doesn’t provide built-in support” for OAuth, the token-based sign-in that Graph requires, and points to open-source libraries.
\nThe setup takes four pieces:
\nhttps://script.google.com/macros/d/{SCRIPT ID}/usercallback registered in Entra.Mail.Send permission and the offline_access scope, without which no refresh token comes back.POST /me/sendMail for each email.Every part of that has an edge. The library’s samples folder covers dozens of services, Xero and Zoom among them, but has no Microsoft file. Microsoft’s own protocol page says hand-built requests are something “we do not recommend” and points to its own libraries. Refresh tokens have no fixed lifetime but can “expire, are revoked, or lack sufficient privileges”, so the script needs a way to ask someone to sign in again.
\nConsent may not be the blocker. By default, Microsoft says, “a user can consent to allow an app to access their mailbox”. An admin can turn that off, and then the script waits until an admin approves the app.
\nOften a script needs none of this. If the goal is only an email in an Outlook inbox, MailApp sends ordinary email, and an Outlook address is just another recipient. Graph earns its setup when the message must come from the Microsoft 365 mailbox, which Graph saves “in the Sent Items folder”.
A hypothetical eight-person office logs every customer inquiry as a row in a Google Sheet, with a date column. Every weekday morning it wants one email to all eight Outlook inboxes listing yesterday’s rows.
\nIn Apps Script, a script bound to the sheet gets one time-driven trigger at 8 AM. Going by Google’s own example of a 9 AM trigger, it fires at a time Google picks between 8 and 9, then keeps that time. Each run reads the rows, keeps yesterday’s and sends one MailApp email with 8 recipients.
| Resource | \nUsed per run | \nLimit (Workspace / Gmail account) | \n
|---|---|---|
| Triggers | \n1 in total | \n20 per user per script | \n
| Email recipients | \n8 | \n1,500 / 100 a day | \n
| Recipients on one message | \n8 | \n50 | \n
| URL Fetch calls | \n0 (about 2 if sent through Graph) | \n100,000 / 20,000 a day | \n
| Runtime | \nOne read and one send; we did not time it | \n6 minutes a run, 6 hours / 90 minutes a day | \n
| Extra license | \nNone | \n\n |
In Power Automate, one Microsoft 365 user owns a scheduled cloud flow with five steps: Recurrence (weekdays at 8:00), Google Sheets Get rows, Filter array (date equals yesterday), Create HTML table, and Office 365 Outlook Send an email (V2) to the 8 addresses. Microsoft counts “every trigger and action execution” as one action.
\n| Resource | \nUsed per run | \nLimit (Microsoft 365 rights) | \n
|---|---|---|
| Actions | \n5 (1 trigger and 4 actions) | \n6,000 a day per user | \n
| Share of the daily limit | \n0.08% | \n\n |
| Actions in a month of 22 weekdays | \n110 | \n\n |
| Google Sheets calls | \n1 | \n100 per 5 minutes per connection | \n
| Connectors | \nGoogle Sheets, Office 365 Outlook: both Standard | \nStandard only | \n
| Extra license | \nNone | \n\n |
Neither tool comes near a limit: 8 of 1,500 recipients (or 100 on a Gmail account), 5 of 6,000 actions.
\nThe flow’s one real trap is Get rows. It starts at the first entry and stops at 256 by default, so once new rows at the bottom pass row 256, they fall outside the read. The digest then goes out quietly short until someone raises Top Count. Build the flow with an Apply to each loop over the rows instead of Filter array, and Microsoft counts each action inside the loop once per row.
\nApps Script is code, and it belongs to one person. Someone has to read JavaScript to change the digest. Google says installable triggers “always run under the account of the person who created them”, and that one account “can’t see triggers installed from a second account”. When it fails, Apps Script emails a failure summary instead of showing an error on screen. A run also stops at 6 minutes, so a long job has to be split into batches.
\nPower Automate charges for reach and slows under load. Premium connectors are off limits on Microsoft 365 rights, and for a custom connector Microsoft says you “must have a premium or trial license”. When a flow runs too many actions, runs are delayed, and a flow that is “consistently throttled” for 14 days is turned off. On Microsoft 365 rights a failed action gets “up to two retries”, against 12 on Premium. The Outlook connector warns that a retried send can produce duplicate emails.
\nBoth tie the job to an owner. If a flow’s owner leaves, the flow “reverts to the Low performance profile”. For a flow outside a solution, the original creator’s limits “can’t be changed”; if the creator leaves, co-owners can export it and import it under a new owner. A flow that fires quarterly also risks the 90-day idle rule on Microsoft 365 rights. A daily digest does not.
\nThe quotas will rarely decide this. Two questions will: where does the event that starts the job happen, and who on staff will fix it.
\nMailApp unless the message must sit in an Outlook Sent Items folder.If the job needs apps neither suite connects well, our Zapier, Make and n8n price comparison prices a third route. For Apps Script quotas in practice, see Gmail to Google Sheets, and for a flow on the free Microsoft license, saving Outlook attachments. Our checks for scheduled scripts make a silent failure speak up. More is under automation.
\nWrite your job as one line before you pick: what starts it, which suite it reads and which it writes. Give it to the tool that owns the starting event, and name a second person who can open it.
\nWe read Google’s and Microsoft’s quota, licensing and connector pages on October 20, 2026, and built both tables from them. The digest is a hypothetical task: we counted its quota use from the documentation and did not build or run either version, because we have no Workspace or Microsoft 365 tenant for testing.
\nPHP says there are no complete mitigations for its two critical flaws: updating is the only safe choice.
Update PHP today, or ask your host to. On Ubuntu, check the package version with dpkg, not php -v, because Ubuntu backports the fix into older version numbers.
PHP released 8.5.12, 8.4.27, 8.3.36 and 8.2.35 today, fixing two critical flaws that “can allow unauthenticated remote code execution.” PHP’s advisory says every installation serving web requests is at risk, and that “there are no complete mitigations, updating is the only safe choice.” If your company runs a PHP site, the job for today is the update, not a workaround.
\nThis follows our report this morning on the pre-announcement. Two things are new: the fixed versions, and PHP’s own word on what the stopgaps can and cannot do.
\nBoth are rated CVSS v4.0 9.2. The first, CVE-2026-109618, starts when PHP runs out of memory: per the advisory, handling that failure can leave request data “only partially initialized,” and cleanup then treats it as valid. The second, CVE-2026-109619, is state that outlives the request it belongs to; the GitHub advisory calls it a use-after-free that a later request in the same worker can reach.
\nThat is why fixing the site alone is not enough. PHP lists PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP and LiteSpeed as affected, and rates mod_php highest, “with a demonstrated exploit where an unauthenticated request can trigger the attack before any application code runs.” Cloudflare adds that updating site code or plugins alone does not fix it.
\nCalif.io, Wiz, OpenAI and Quarkslab disclosed the flaws, according to Cloudflare. PHP’s advisory does not say the flaws are being exploited.
\nLinux distributions got the patches in advance, PHP says. That creates a trap. Ubuntu’s tracker lists the fix in php8.3 8.3.6-0ubuntu0.24.04.13 on 24.04 LTS, php8.1 8.1.2-1ubuntu2.28 on 22.04 LTS and php8.5 8.5.4-0ubuntu1.5 on 26.04 LTS. A patched 24.04 server still reports 8.3.6, not 8.3.36.
For the PHP 7 packages on Ubuntu 20.04 and 18.04, the status read “Needs evaluation” when we checked at 14:40 UTC.
\nFor PHP 8.1 and older, the PHP project ships no release. Its security team did publish minimal source backports for 7.4, 8.0 and 8.1 for people who build PHP themselves.
\nTurning off session.upload_progress.enabled blocks “the confirmed session paths but not other variants,” PHP says. It must be set in php.ini, an FPM pool or server configuration; PHP says not to rely on ini_set() or FPM .user.ini. Our earlier piece listed .user.ini as an option. For PHP-FPM, that is wrong.
For the memory bug, PHP suggests memory_limit=-1 and a low post_max_size (8M without uploads, 32M with them). Both have a cost. In our reading, no memory limit lets one request take far more memory, and PHP also suggests a container or cgroup limit as the boundary. A low post_max_size rejects larger uploads.
Cloudflare has blocked requests aimed at these flaws since 03:02 UTC today on every plan with its firewall turned on, Free included. It says this is an extra layer, not a fix.
\ndpkg -l | grep php and compare against Ubuntu’s tracker. On other distributions, check your vendor’s advisory.France's Conseil d'État cut Amazon's monitoring fine to 15 million euros; keeping every indicator 31 days still broke the rules.
Before recording anyone, write a legitimate interest assessment and a DPIA, tell staff in writing, and collect group-level data without keystrokes or screenshots. The fined French firm missed the DPIA and the written notice.
In December 2024, France’s data protection authority, the CNIL, fined a small real estate company 40,000 euros for watching its staff too closely. Its software counted “idle” minutes and took screenshots of staff computers every 3 to 15 minutes. Any small or mid-sized company that records how people work, even just to find tasks worth automating, answers to the same GDPR rules.
\nScreen recordings, task mining logs, app usage logs and email metadata are personal data under the GDPR once they relate to an identifiable person. The obvious first step, asking staff to agree, is the one European regulators say rarely holds up.
\nSo on October 20, 2026, we read the regulators’ own texts: the GDPR, EU guidance, the UK’s ICO, Sweden’s IMY and two French fines. Below are the texts side by side, the design choices they reward and a checklist for a 20-person company. It is a reading of the sources, not legal advice.
\nThe GDPR allows consent, but recital 43 says it “should not provide a valid legal ground” where “there is a clear imbalance between the data subject and the controller.” Article 7(4) sets out how to judge whether consent was freely given. The EDPB’s point is simple: an employee who fears what a refusal might cost is not free.
\nEvery text we read applies this to work, in nearly the same words:
\n| Source | \nOn consent at work | \nOn monitoring tools | \n
|---|---|---|
| WP29 Opinion 2/2017 (EU advisory body) | \nEmployees “are seldom in a position to freely give, refuse or revoke consent” | \nSoftware logging keystrokes, screens and apps used is “disproportionate”; a legal ground for recording keystrokes is “very unlikely” | \n
| EDPB Guidelines 05/2020 | \n“Problematic for employers”; for most processing at work the basis “cannot and should not be the consent of the employees” | \nNames workplace camera monitoring as a request staff are unlikely to answer freely | \n
| ICO, monitoring workers (UK) | \n“Not usually appropriate in the employment context, due to the imbalance of power” | \nGives keystroke monitoring as an example of high-risk processing; guidance under review after the Data (Use and Access) Act | \n
| IMY (Sweden, updated June 15, 2026) | \nDoes not think an employer can use consent as the legal basis for monitoring staff (our translation) | \nUsing an IT system to monitor in real time, or otherwise regularly, how staff work or take breaks is as a rule not allowed (our translation) | \n
The 2017 opinion came from the Article 29 Working Party, a European advisory body set up under the old directive. The EDPB’s 2020 guidelines, written for the GDPR, agree.
\nThere is one narrow exception. The EDPB says employees can consent freely only “when it will have no adverse consequences at all whether or not they give consent.” Its example is a film crew in an office: staff who do not want to be filmed “are not penalised in any way” and get equal desks elsewhere. A recording tool that a manager proposes to a team will rarely clear that bar.
\nWith consent out, the regulators point to legitimate interest. Article 6(1)(f) allows processing “necessary for the purposes of the legitimate interests pursued by the controller,” unless the person’s rights override them. The 2017 opinion names it as an alternative, then warns that “a legitimate interest in itself is not sufficient to override the rights and freedoms of employees.”
\nThe ICO breaks the test into three questions. Is there a legitimate interest behind the processing? Is the processing necessary for that purpose? Do the person’s interests, rights or freedoms override it?
\nWe think finding work to automate can pass the first question. The second and third are the hard part. The ICO says: “If you can achieve your aim in a less intrusive way, you must do so.”
\nIMY puts a weight on the scale: security reasons count for more than efficiency reasons (our translation). Automation is an efficiency reason.
\nLegitimate interest also gives staff rights. Under Article 21, a person can object, and the employer must then stop unless it shows “compelling legitimate grounds.” Article 13(1)(d) requires telling people which legitimate interest you rely on.
\nIMY accepts the employment contract as a basis when measuring performance is needed to pay agreed performance-based wages. An automation study is not that, so most projects come back to the balancing test.
\nArticle 35 requires a data protection impact assessment (DPIA), a written risk analysis done before processing starts, when processing “is likely to result in a high risk.” The EU guidelines on DPIAs (WP248) list nine risk criteria and say that in most cases, meeting two calls for one. Systematic monitoring is a criterion, and employees can count as vulnerable data subjects, which is another.
\nThe guidelines then give an example that reads like a task mining pilot: “A company systematically monitoring its employees’ activities, including the monitoring of the employees’ work station, internet activity.” Their answer to whether a DPIA is likely required is yes.
\nThe ICO says a DPIA is a must for high-risk monitoring and that you “should carry out a DPIA even if there is no specific high risk.” If the DPIA finds a high risk you cannot reduce, the ICO says you must consult it before you start. The French company in our opening skipped this step, and the CNIL counted that as its own breach of Article 35.
\nArticle 88 lets EU countries set more specific rules for employee data “by law or by collective agreements,” with particular regard to “monitoring systems at the work place.” So the GDPR is only part of the answer.
\nTwo examples show how much this varies. In Germany, a works council has a co-determination right under section 87(1) no. 6 of the Works Constitution Act. It covers “the introduction and use of technical devices designed to monitor the behavior or performance of employees” (our translation).
\nIn Sweden, IMY says an employer’s right to monitor staff is governed first by employment law and collective agreements. The co-determination act (MBL, section 11) makes an employer with a collective agreement negotiate with the union before an important change to its operations, or to working conditions for the union’s members. IMY notes that such a duty can apply to workplace cameras.
\nFor the UK, the ICO says you “should seek and document the views of your workers or their representatives (such as trade unions).” Check your own country’s employment law before you buy a tool.
\nThe real estate company is the clearer case. Its software marked 3 to 15 minutes without a keystroke or mouse movement as idle, and idle time staff could not justify or make up could be docked from pay. The CNIL noted that time away from the keyboard can be real work, such as meetings or calls, so the tool could not count hours reliably. It found no legal basis for that or for the screenshots, which could capture personal emails, chats and passwords.
\nThe company had also filmed staff continuously with two cameras. Its written notice to staff fell short, and oral briefings left no record, so the CNIL found breaches of the information rules too.
\nThe Amazon case shows the other side. In December 2023, the CNIL fined Amazon France Logistique 32 million euros, mainly over indicators drawn from the handheld scanners its warehouse staff use. Amazon appealed, and on December 23, 2025, France’s Conseil d’État cut the fine to 15 million euros.
\nGuess which part survived. The court found that three scanner indicators did not breach the legitimate interest rule. One flagged two scans less than 1.25 seconds apart; another recorded idle time only after more than ten minutes in a row. What it kept was the data minimization breach: storing all the indicators for 31 days, for several purposes at once, when Amazon could not show why each needed that long.
\nFindings on staff information and security, which Amazon did not contest, also stood. Our reading: a narrow measurement tied to a clear purpose can pass, while keeping everything for 31 days cannot. Amazon runs warehouses, not an office, and the court judged it on those facts. Breaches of Articles 5 and 6 can cost up to 20 million euros or 4% of worldwide turnover, whichever is higher, under Article 83(5).
\nEach choice below is tied to what a regulator wrote.
\nThe decision is how much detail you need. A tally kept by staff, or a log from systems you already run, carries far less risk. Our pieces on noticing what to automate and task mining versus process mining compare those options. If you still want to record work, this order follows the sources:
\nThe French real estate company removed its software during the inspection. The CNIL chose not to name it because of its small size and that quick removal, and still fined it 40,000 euros. The cheaper version of that lesson is to write the DPIA before installing anything.
\nWe read the GDPR text, the 2017 working party opinion, the EU guidelines on impact assessments and on consent, the ICO’s monitoring guidance, IMY’s page and the two French decisions on October 20, 2026. The Swedish, German and French quotes are our own translations. We tested no monitoring tool, and none of this is legal advice.
\nPHP fixes two critical flaws at 14:00 UTC today, but about a third of PHP sites run unsupported versions.
Run php -v on every server, or ask your host which PHP version your sites use. If it is 8.2 or newer, book the update for 14:00 UTC; if older, ask for a backport today.
The PHP project will release fixes for two critical vulnerabilities today, Wednesday, October 21, at 14:00 UTC (10:00 in New York, 16:00 in Central Europe). PHP’s own notice rates both CVSS v4.0 9.2 and asks every PHP user to “prepare now.” If your company runs a site on WordPress or Magento, this is your update.
\nThe catch is which versions get it. PHP only supports 8.2 and newer. And details leaked before the release, so attackers may move before many sites patch.
\nPHP’s security team posted the notice on Tuesday at 19:33 UTC, signed by Jakub Zelenka on the php.announce list. It says “full details, affected versions, and the fixed versions will be published with the release,” and that PHP may release earlier if details go public or attacks start.
\nThey already went public in part. A Hacker News post at 15:20 UTC on Tuesday claimed two PHP remote code execution flaws were coming, citing an unnamed source. The EU’s computer emergency team, CERT-EU, lists them as CVE-2026-109618 and CVE-2026-109619 and says a 9.2 score suggests unauthenticated remote code execution. Sansec, a store security firm, reports that a screenshot of an exploit tool called PHP2Shell leaked and that watchTowr, another security firm, confirmed the bugs.
\nTwo claims stay unconfirmed. CERT-EU says the flaws “could affect all PHP versions from PHP 5 onwards,” but flags that this comes from social media. Sansec expects mass attacks within 15 minutes of the release; that is a forecast, not an observation.
\nPHP gives each version a fixed support window: 8.2 gets security fixes until December 31, 2026, and 8.5 until the end of 2029. Anything older than 8.2 gets nothing from the project. Sansec’s advice for servers on 8.1 or older is to ask the host to backport the fix or move to a supported version.
\nThat is not a small group. W3Techs counted PHP on 69.3% of websites whose server language it can see, as of today. Of those PHP sites, 27.0% run version 7 and 7.7% version 5, with a further 0.1% on version 4.
\nBy our arithmetic that is 34.8%, about one PHP site in three, on versions with no official fix. The real share is higher, because PHP 8.0 and 8.1 are also out of support and W3Techs does not split version 8.
\nReports gathered by lilting.ch place at least one bug in PHP’s upload progress feature; PHP has not confirmed this. The feature is on by default: the PHP source sets session.upload_progress.enabled to 1. Turning it off stops only progress tracking for file uploads, according to the same report, and uploads still work.
It is partial cover at best. A researcher quoted in the report says the switch blocks only one of the two bugs.
\nThe setting cannot be changed from inside a script. PHP’s manual says settings of this kind are set in php.ini, .htaccess, httpd.conf or .user.ini.
\nphp -v on servers you manage. For hosted sites, ask the host which version runs and when it will apply today’s fix.session.upload_progress.enabled = Off in php.ini or .user.ini if your site has no upload progress bar, and reload PHP. Treat it as partial cover.Gemini's new business tools take your receipts, but on a personal account some chats may go to human reviewers.
Before you upload receipts or connect Xero, open Gemini under a Google Workspace account, or turn Keep Activity off on a personal one. Your books then stay out of model training.
Google on Tuesday announced a business page inside the Gemini app that turns receipts and purchase records into financial charts and connects to apps such as Shopify and Xero. It reaches “all Gemini app users” in the coming days. The catch for an owner is the account: on a personal Google account, those receipts fall under consumer terms that allow human review and model training.
\nBelow: what Google shipped, why the account type matters, and the two settings to check before uploading your books.
\nThe post, by Vishnu Sivaji, senior director for the Gemini app, describes a “new business landing page designed to help small business owners streamline their daily tasks.” It has three parts.
\nGoogle lists no price. Larger firms that want “centralized administrative controls” are pointed to Gemini Enterprise.
\nXero confirmed its part three days earlier. Its post says the app “brings live Xero data into your Gemini conversations”: cash position and profit as well as invoices and bills. Anything that changes the books, such as issuing an invoice, needs the user to “review and confirm it before anything happens.”
\nGemini runs under two sets of data terms, and Google’s announcement mentions neither.
\nOn a personal account, the Gemini Apps Privacy Hub says: “A subset of chats are reviewed by human reviewers.” Google uses activity to improve its services, “including training generative AI models,” unless you turn the Keep Activity setting off. “Reviewed chats are retained for up to three years.” Activity is otherwise auto-deleted after 18 months by default.
\nOn a qualifying Google Workspace edition, the Workspace privacy hub says chats and uploaded files “won’t be reviewed by human reviewers or otherwise used to train generative AI models without your permission.” It adds: “Your interactions with Gemini stay within your organization.” An admin can also set how long chats are kept, from 3 to 36 months.
\nXero says “Xero data isn’t used to train Google Gemini models.” That covers the live data the connector pulls. A receipt you photograph and upload yourself is a different matter, governed by your Gemini account terms. And disconnecting a connected app, the consumer privacy hub notes, does not delete data already saved in your Gemini activity.
\nWe think this gap matters more than any single feature. Google built the page for “all Gemini app users,” personal accounts included, not only Workspace customers, and its post does not say which terms apply.
\nThe trade-off is real. With Keep Activity off, chats are kept for only 72 hours, so a finance model you build today will not wait for you next month. And Xero’s planned scheduled tasks, such as daily cash summaries, are “coming soon” and its footnote excludes the EEA and the UK, as well as Switzerland and Nigeria.
\nA power event in one Google Cloud zone in London led to almost eight hours of trouble across 38 products.
List which of your systems and vendors run in europe-west2, and keep spare capacity running in a second zone. Creating it mid-outage may fail, as Google warned on Tuesday.
Google Cloud’s London region, europe-west2, had problems for almost eight hours on Tuesday, October 20. Google’s incident record dates the start to 06:08 UTC, names a “power event” in a single zone, europe-west2-b, and lists 38 affected products.
\nGoogle’s own design guide says a one-zone power fault should be survivable by moving to the region’s other zones. On Tuesday, Google still reported errors elsewhere in the region. If you or a supplier run in London on Google Cloud, that gap is your risk.
\nThe best-known affected company was Revolut. The Stack reported that the bank told its 80 million users it was “experiencing a service disruption affecting multiple services,” and that its status page showed core services failing. Bloomberg reported that Revolut blamed Google Cloud, while The Stack noted that Revolut’s own statement did not name a cause.
\nOther UK apps reported trouble too. The budgeting app Emma blamed the Google Cloud disruption for its own outage, and Halifax acknowledged problems with its app and website without saying why, according to IANS. IANS also noted it was unclear whether every affected service relied on Google Cloud.
\nWe read every update in Google’s incident record. The times, in UTC:
\nThe list of 38 products covers the basics most apps sit on: Compute Engine, Kubernetes Engine, Cloud SQL, Cloud Storage, Pub/Sub, Cloud Run, Spanner, load balancing and Cloud NAT.
\nGoogle’s own regions and zones documentation says it designs zones “to minimize the risk of correlated failures caused by physical infrastructure outages like power, cooling, or networking,” so that if one zone goes down “you can transfer traffic to another zone in the same region.”
\nThat is the promise multi-zone setups rest on. On Tuesday the fault was a power event, it started in one zone, and Google still reported errors in other parts of the region. The same page says spreading across regions “provides an even higher degree of failure independence.” We do not yet know why the damage spread beyond europe-west2-b; Google has not published its analysis.
\nThe 11:58 note matters too. Plans that create fresh capacity during an outage, such as autoscaling into a healthy zone, assume you can create new workloads. For part of the recovery, Google said you might not.
\nstatus.cloud.google.com, but do not rely on it. On Tuesday, Google’s first public note came 2 hours 27 minutes after the start, so your own monitoring has to raise the alarm first.At an assumed hour a month of upkeep, 5 of 7 tasks in our recomputed xkcd table never pay back.
Before you build, multiply minutes saved by runs a year and compare it with the upkeep you expect. If upkeep is larger, do it by hand or keep it a throwaway script.
The xkcd chart Is It Worth the Time? says how long you can spend making a routine task faster before you lose time over five years. It counts 24-hour days, 365-day years and zero upkeep. We recomputed it for a working year and subtracted the hours an automation needs to keep running.
\nThe change matters to anyone deciding what to automate at a small company, because upkeep is the line the chart leaves blank.
\nAt an assumed hour a month of it, five of the seven common tasks in our table never pay back at all, however fast you build. This piece shows why the chart reads the way it does, what forces upkeep, and a 28-line Python script you can run with your own numbers.
\nRandall Munroe published the chart on 29 April 2013. Rows give the time shaved off one run, from 1 second to 1 day. Columns give how often you do the task, from 50 times a day to yearly. Each cell is the time saved over five years, which is the most you can spend on the fix and still break even.
\nThe comic never prints its formula, so we checked one.
\nWe multiplied time shaved by runs per year by five, using 24-hour days and 365-day years, for all 45 cells that hold a number. Every result landed within 27% of the printed cell, and the gaps match the comic’s rounding to whole units. A minute shaved off a daily task gives 30.4 hours; the comic rounds that to “1 day”. The other 9 cells read “n/a”, with no number to check.
\nTwo of those assumptions do not fit office work. A task you do “daily” at work happens on weekdays, which is 52 times 5, or 260 days a year before holidays and leave, not 365. And a “day” of building is a workday of about 8 hours, not 24.
\nGuess which way the two corrections push. They pull in opposite directions. Counting 260 days cuts the hours saved by 29% for anything done daily or more often, and counting 8-hour days triples the number of days those hours buy.
\nNet, the minute shaved off a daily task is worth 21.7 hours over five years, or 2.7 workdays, where the comic says 1 day. Weekly, monthly and yearly tasks keep their hours, since they repeat the same number of times either way.
\nSo the chart is not too strict for office work in days. It is too generous in one larger way: it assumes the automation, once built, costs nothing more.
\nThe chart’s own sequel says as much. In xkcd 1319, “Automation”, the “theory” panel shows coding time ending as the automation takes over the task. In the “reality” panel, writing code turns into debugging, rethinking and “ongoing development”, and the original task gets no time at all.
\nThat is a joke, but the platforms office workers build on put the same lesson in writing. Microsoft’s Power Automate limits page says a cloud flow that “isn’t triggered within a 90 day period might be turned off” unless its owner has a premium or capacity license. Owners are notified 30 days before. A flow whose trigger or actions “fail continuously” for 14 days is turned off too.
\nZapier’s help center says it will turn off a Zap that errors 95% of the time it runs and has run more than 20 times in the past 7 days. Team plans get a 24-hour grace period and Enterprise plans 72 hours.
\nScripts are not exempt. Google keeps a table of retired Apps Script features, and seven of them reached their sunset date between November 2022 and June 2026. One was the Rhino runtime: “Scripts running on Rhino will continue to function until January 31, 2026, after which they will no longer execute.” Others, such as the Contacts and Sites services, now simply no longer function.
\nNone of these is a bug in your automation. Each one is a date or a rule set by someone else, and each one costs time you did not put in the chart.
\nHere is the recomputed table. The script below printed it in our sandbox on 20 October 2026. Rows are seven common cells from the comic, with its “1 day” row read as one 8-hour workday. Each column subtracts a different amount of yearly upkeep, meaning time spent checking, fixing and migrating.
\nThe upkeep levels are inputs we chose, not measurements. We found no published measure of how much upkeep office automations need. Read 2 hours a year as “one small fix a year”, 12 as “an hour a month” and 24 as “two hours a month”.
\nEvery other number is arithmetic on the comic’s rows. A “day” in the table is 8 working hours.
\n| Saved per run, how often | \nSaved per year | \nUpkeep 0 h/yr | \nUpkeep 2 h/yr | \nUpkeep 12 h/yr | \nUpkeep 24 h/yr | \n
|---|---|---|---|---|---|
| 30 seconds, 5 times a day | \n10.8 h | \n54 h (6.8 days) | \n44 h (5.5 days) | \nnever pays | \nnever pays | \n
| 1 minute, daily | \n4.3 h | \n22 h (2.7 days) | \n12 h (1.5 days) | \nnever pays | \nnever pays | \n
| 5 minutes, daily | \n21.7 h | \n108 h (13.5 days) | \n98 h (12.3 days) | \n48 h (6.0 days) | \nnever pays | \n
| 5 minutes, weekly | \n4.3 h | \n22 h (2.7 days) | \n12 h (1.5 days) | \nnever pays | \nnever pays | \n
| 30 minutes, weekly | \n26.0 h | \n130 h (16.2 days) | \n120 h (15.0 days) | \n70 h (8.8 days) | \n10 h (1.2 days) | \n
| 1 hour, monthly | \n12.0 h | \n60 h (7.5 days) | \n50 h (6.2 days) | \nnever pays | \nnever pays | \n
| 1 workday, yearly | \n8.0 h | \n40 h (5.0 days) | \n30 h (3.8 days) | \nnever pays | \nnever pays | \n
Each cell is the most you can spend building it and still break even over five years. “Never pays” means the upkeep alone eats the saving, so even a build that took no time loses hours. The hour-a-month task sits exactly on that line: 12 hours saved, 12 spent.
\nThe pattern is simple once it is written down. The hours a task saves each year are the most upkeep it can carry. A minute shaved off a daily task saves 4.3 hours a year, so a little over half a day of fixes each year wipes it out. Thirty minutes shaved off a weekly task saves 26 hours a year and survives two hours of upkeep a month.
\nThe rules above hit infrequent tasks hardest. A yearly task leaves its flow untriggered for far longer than 90 days, so on a standard license its Power Automate flow is exactly the kind Microsoft says “might be turned off”. A monthly flow stays inside the window.
\nThe yearly row also has the thinnest margin, 8 hours a year in our working-time version. A migration like Rhino that took a few hours, once in five years, would take a real bite of its 40-hour budget. And a yearly job that breaks is found a year late, when the task is due.
\nA hypothetical shows the cost of a silent failure. Say a daily automation that saves 5 minutes stops for a month of 22 workdays before anyone notices. That is 110 minutes of work to catch up by hand, plus the time to find the fault, and it goes in the upkeep column too.
\nOur guide to scheduled scripts that fail silently covers how to make a failure reach a person the same day.
\nThere is an honest argument against all of this arithmetic.
\nIn a December 2024 post titled Xkcd’s “Is It Worth the Time?” Considered Harmful, the author describes a fix to a pattern in about 10 spots in a codebase. By hand it would have taken a minute; automating it took an hour. “And I think that was the right choice,” the post says, because of what the author learned along the way.
\nThe claim is that “automating the easy things is how you build the skills, mindset, and muscle-memory to automate the hard things.” The post also grants that doing a task by hand can make sense when all that matters is getting it done quickly. The post drew 27 points and 18 comments on Hacker News.
\nWe think the post is right about one-off scripts that you run yourself and can throw away. Those carry almost no upkeep, because nobody depends on them next month.
\nThe case weakens for a flow other people rely on, where every broken run lands on a colleague. Learning is a fine reason to build. It is a poor reason to leave something running that costs more than it saves.
\ntasks and upkeep_levels below. It needs Python 3 and nothing else.# xkcd 1205 recomputed for a working year, with upkeep subtracted.\n# Inputs: time shaved off each run, runs per year, upkeep hours per year.\nYEARS = 5 # the comic's horizon\nWORKDAYS = 260 # 52 weeks x 5 weekdays, before holidays and leave\nHOURS_PER_DAY = 8\n\ntasks = [ # (label, minutes saved per run, runs per year)\n (\"30 seconds, 5 times a day\", 0.5, 5 * WORKDAYS),\n (\"1 minute, daily\", 1, WORKDAYS),\n (\"5 minutes, daily\", 5, WORKDAYS),\n (\"5 minutes, weekly\", 5, 52),\n (\"30 minutes, weekly\", 30, 52),\n (\"1 hour, monthly\", 60, 12),\n (\"1 workday, yearly\", 60 * HOURS_PER_DAY, 1),\n]\nupkeep_levels = [0, 2, 12, 24] # hours per year spent fixing and checking\n\nprint(\"| Saved per run, how often | Saved per year | \" +\n \" | \".join(f\"Upkeep {u} h/yr\" for u in upkeep_levels) + \" |\")\nprint(\"|---\" * (2 + len(upkeep_levels)) + \"|\")\nfor label, minutes, runs in tasks:\n saved = minutes * runs / 60 # hours a year\n cells = []\n for u in upkeep_levels:\n budget = YEARS * (saved - u) # build hours that still break even\n cells.append(f\"{budget:.0f} h ({budget / HOURS_PER_DAY:.1f} days)\"\n if budget > 0 else \"never pays\")\n print(f\"| {label} | {saved:.1f} h | \" + \" | \".join(cells) + \" |\")If you have not picked a task yet, start with a one-week tally of what you repeat, then run the strongest candidates through the table. More guides are on the automation page. The comic’s alt text adds that the time spent finding the chart counts too. Upkeep is the same kind of time: small, easy to leave out, and billed again every year the automation runs.
\nAt 10,000 runs a month, the same lead workflow costs $289 on Zapier and $50 on n8n Cloud, billed yearly.
Count the action steps in your workflow and multiply by your monthly runs before you pick a plan. Add 25% headroom, because Make and n8n Cloud pause workflows when the allowance runs out.
Zapier, Make and n8n don’t bill the same thing, so one workflow can cost ten times more on one than another. Zapier charges for every action and Make for every module, the trigger included, while n8n charges once per run. So we priced one real workflow on all three, from their pricing pages on October 20, 2026.
\nThe workflow is a common one. A website form sends a lead, and a filter drops entries without an email. The name and phone get cleaned up, then the lead goes to a CRM, a Google Sheet and a Slack channel.
\nAt 1,000 runs a month the cheapest yearly plans cost $9 on Make, $20 on n8n Cloud and $80 to $89 on Zapier. At 10,000 runs they cost about $29, $50 and $289.
\nWe also built the workflow in n8n and ran it 1,000 times on our own machine, to see what self-hosting asks of a server. We did not build it in Zapier or Make, because we have no paid accounts there; those counts come from each vendor’s documentation.
\nZapier counts tasks. Zapier’s help center says “Zap triggers never use tasks”, and neither do Filter, Paths or Formatter steps. Each successful action uses one task. Our workflow has three actions (CRM, sheet, Slack), so each lead costs 3 tasks, and a lead the filter stops costs nothing.
\nMake counts credits. Credits are Make’s billing unit, and “most actions consume 1 credit”. Make’s operations guide counts the trigger as one operation each time it runs, whatever it returns. So our workflow costs 4 credits per lead: the trigger plus three modules. In Make a filter sits on the line between two modules, not in a module, so we count it as free; the Make pages we read don’t say so outright. A rejected lead still costs the trigger’s credit.
\nn8n counts executions. “An execution is a single run of your entire workflow”, whatever the number of steps. A webhook trigger counts one execution for every inbound request, including requests with an empty body. So every lead costs 1 execution, and so does every spam entry the filter rejects.
\nThat difference decides the result. The more steps your workflow has, the better n8n looks. The more runs end at a filter, the better Zapier looks.
\nWe put each vendor’s price list into a 41-line script and asked it for the cheapest plan that covers each volume. Zapier prices come from its pricing page, n8n prices from its pricing page. Every run is assumed to be a real lead: 3 tasks, 4 credits or 1 execution.
\n| Runs a month | \nZapier Pro, yearly | \nZapier Pro, monthly | \nMake Core, yearly | \nMake Core, monthly | \nn8n Cloud, yearly | \n
|---|---|---|---|---|---|
| 250 | \n$19.99 | \n$29.99 | \n$9.00 | \n$10.59 | \n$20.00 | \n
| 1,000 | \n$79.63 to $89.00 | \n$133.50 | \n$9.00 | \n$10.59 | \n$20.00 | \n
| 2,500 | \n$129.00 | \n$193.50 | \n$9.00 | \n$10.59 | \n$20.00 | \n
| 5,000 | \n$189.00 | \n$283.50 | \n$16.00 | \n$18.82 | \n$50.00 | \n
| 10,000 | \n$289.00 | \n$433.50 | \n$29.00 | \n$34.12 | \n$50.00 | \n
| 20,000 | \n$361.25 | \n$650.25 | \n$55.00 | \n$64.71 | \nnone listed | \n
Prices are in US dollars per month and read October 20, 2026.
\nMake’s prices are the weakest numbers in the table. Make’s pricing page loads its prices with a script, and Cloudflare’s bot check blocked our browser, so we could not read them there. Make’s own blog confirms the first tier: Core “starts at $9/month (annual billing) for 10,000” credits. The higher tiers and the monthly prices come from an independent write-up that read the page on October 8, 2026, and that links to Make with an affiliate code. Check them on make.com before you buy.
\nZapier’s 1,000-run price has two answers. 3,000 tasks don’t fit the 2,000-task tier ($49 a month yearly), so the clean choice is the 5,000-task tier at $89. The script found something cheaper: the 2,000 tier plus pay-per-task billing for the other 1,000 tasks. Zapier’s pricing page says extra tasks cost 1.25 times your base task rate on yearly plans and 2.5 times on monthly ones, up to 3 times your plan’s task limit. That makes $79.63. Zapier’s help center adds that the rate “depends on your plan and billing cycle type”, so confirm it in your billing settings.
\nn8n Cloud’s figures are yearly. The page lists Starter at $20 a month for 2,500 executions and Pro at $50 for 10,000, both “billed annually”. Yearly billing saves 17%, it says. It lists no Cloud plan with more than 10,000 executions except Enterprise, through sales. The Business plan, $800 a month for 40,000 executions, is self-hosted only.
\nTwo of the three cheap options have no headroom at 10,000 runs, and the tools behave differently at the limit.
\nSo at 10,000 runs, plan on Make’s next tier, reported at $55 a month yearly for 80,000 credits. For n8n, the step past Cloud Pro is Enterprise or self-hosting. Both Make prices stay far below Zapier’s $289.
\nThe free n8n Community Edition has no execution quota: per n8n’s docs, only paid plans have one. Its Sustainable Use License allows use “only for your own internal business purposes or for non-commercial or personal use”. Running your own lead workflow fits; selling n8n as a hosted service to clients does not.
\nTo see what a server needs, we installed n8n 2.44.4 from npm on our Linux sandbox (4 vCPUs, 16 GB of memory) with Node.js 24 and the default SQLite database. We built the workflow above as seven nodes: Webhook, If, Edit Fields, three HTTP Request nodes and a webhook reply. A small local server stood in for the CRM, the sheet and Slack, because we have no test accounts there. A script then posted 1,000 made-up leads on .example addresses, five at a time, with every 20th lead missing its email.
What happened:
\nWe ran this on a large machine, not on a small cloud server, so read the memory figures as what n8n used, not a proven minimum. n8n’s own sizing example gives 320 MB to 2 GB of memory and says memory needs usually outweigh CPU. On DigitalOcean, a 1 GiB droplet is $6 a month and a 2 GiB one is $12. With our peak near 900 MiB, we would pick the 2 GiB server.
\n$12 a month beats every hosted option above 2,500 runs, on paper. The real price is the hours: updates, backups, an HTTPS front end and someone to call when it stops. n8n’s hosting docs mark npm installs as deprecated from n8n 3.0 and point production users to Docker Compose.
\nThe decision turns on three numbers you can count today: steps per run, runs per month, and how many runs end at a filter.
\nIf you are not sure this workflow is the one to automate first, our one-week tally helps you find it. For a scheduled report, the weekly report guide covers the Zapier schedule step by step, and our email-to-Excel test shows a workflow that may not need any of these tools. More comparisons are under automation.
\nBefore you sign up, write your workflow as a list of steps and mark each as trigger, action or filter. Multiply by your runs and add 25%. That one line tells you which of the three bills you least.
\nEU regulators called software that logs keystrokes and captures screens disproportionate for employers in 2017.
Export one process as a CSV with case ID, activity and timestamp, then mine it before buying anything. If you need click-level detail, have one volunteer record one task they choose.
Process mining and task mining both promise to show where work goes, but they look at different things. Process mining reads the timestamped records your business systems already keep, such as when an invoice was entered, approved and paid. Task mining records what a person does on their own computer, click by click, and some tools take a screenshot on each action.
\nFor a small team that difference decides what data you need and how much legal risk comes with it. When we checked on October 19, every top result for “task mining vs process mining” came from a vendor of one or both.
\nSo we built a sample event log and mined it with a free library. We also priced the tools from their own pages and read what European and UK regulators say about recording employees. Prices and documentation were read on October 20, 2026.
\nProcess mining needs an event log: one row per step, with three columns. Microsoft’s documentation for its process mining tool names them as a case ID, an activity name and a timestamp. The case is the thing the process acts on, such as an order or an invoice. Optional columns add the person or system that did the step, or an amount.
\nThe catch is getting that log. Microsoft warns that many database tables hold only the current state of a record, not its history, and that “not all events that you’re interested in are logged.” Some systems keep the history in a separate table; Microsoft names the Activities table in Dynamics apps as one example.
\nWhen the log exists, the analysis is cheap. To show how cheap, we built a sample log of 60 invoices with a short Python script, so every number below comes from data we made up on purpose, not from a real company.
\nEach invoice is received, entered in the accounting system, matched to a purchase order, approved and paid. About one in five fails the match and goes back to the supplier, a few of them more than once. Small invoices skip approval.
\nWe ran the log through pm4py, an open-source process mining library for Python, version 2.7.23.11. This is the whole analysis, 23 lines:
\nimport pandas as pd, pm4py\ndf = pd.read_csv(\"invoice_log.csv\")\ndf[\"timestamp\"] = pd.to_datetime(df[\"timestamp\"])\nlog = pm4py.format_dataframe(df, case_id=\"case_id\", activity_key=\"activity\", timestamp_key=\"timestamp\")\nprint(\"pm4py\", pm4py.__version__)\nprint(\"\\n# Variants (path through the process, number of invoices)\")\nfor path, n in sorted(pm4py.get_variants(log).items(), key=lambda x: -x[1]):\n print(n, \" > \".join(path))\nprint(\"\\n# Directly-follows counts\")\ndfg, starts, ends = pm4py.discover_dfg(log)\nfor (a, b), n in sorted(dfg.items(), key=lambda x: -x[1]):\n print(f\"{n:3d} {a} -> {b}\")\nprint(\"\\n# Median wait before each step (hours)\")\ndf = df.sort_values([\"case_id\", \"timestamp\"])\ndf[\"wait_h\"] = df.groupby(\"case_id\")[\"timestamp\"].diff().dt.total_seconds() / 3600\nprint(df.groupby(\"activity\")[\"wait_h\"].median().round(1).dropna().sort_values(ascending=False).to_string())\ndur = df.groupby(\"case_id\")[\"timestamp\"].agg(lambda s: (s.max() - s.min()).total_seconds() / 86400)\nrework = df[df.activity == \"Ask supplier for fix\"].case_id.unique()\nprint(\"\\n# Throughput time (days), median\")\nprint(\"all invoices:\", round(dur.median(), 1), \"| with supplier fix:\", round(dur[dur.index.isin(rework)].median(), 1),\n \"| without:\", round(dur[~dur.index.isin(rework)].median(), 1), \"| invoices with a fix:\", len(rework))\nnet = pm4py.discover_petri_net_inductive(log)\nprint(\"\\n# Inductive-miner model fitness on its own log:\", round(pm4py.fitness_token_based_replay(log, *net)[\"log_fitness\"], 3))Guess how many different paths 60 invoices took through a five-step process. Our sample produced seven. The first lines of the real output:
\n39 Receive invoice > Enter in accounting > Match to PO > Approve > Pay\n12 Receive invoice > Enter in accounting > Match to PO > Ask supplier for fix > Enter in accounting > Match to PO > Approve > Pay\n5 Receive invoice > Enter in accounting > Match to PO > PayThe other four paths held one invoice each, all with one to three trips back to the supplier. The rest of the output, abridged:
\n# Median wait before each step (hours)\nApprove 58.0\nEnter in accounting 21.7\nPay 17.3\nMatch to PO 2.0\nAsk supplier for fix 1.4\n\n# Throughput time (days), median\nall invoices: 4.7 | with supplier fix: 7.1 | without: 3.7 | invoices with a fix: 16Read it the way you would read a real log. Sixteen invoices went back to a supplier, and those took a median 7.1 days against 3.7 for the rest. The longest median wait sits before approval, at 58 hours. Those are the two questions process mining answers well: where work loops and where it waits.
\nOne honest limit: these patterns are in the output because our generator put them there. The test shows what the method reports, not how real invoice processes behave. The library also prints a license notice when it loads: pm4py is under the AGPL-3.0, and its maintainer, a Fraunhofer FIT spin-off, sells a separate license for closed-source commercial use. Running it on your own data is a different case from building it into software you sell or host for others; ask whoever handles licenses before you do that.
\nProcess mining could not tell us why entering an invoice takes a person ten minutes. The accounting system logs that the invoice was saved, not the copying and pasting that came before. That gap is what task mining fills.
\nTo show the difference, we built a second sample: 341 desktop actions for one clerk’s morning, the kind of trail a recorder produces. Again it is made up by our script, not recorded from a person. Thirty invoices each take eight steps, from opening the email to clicking Save, with other work and interruptions mixed in. Then we counted repeated runs of actions:
\nmost frequent run of 8 actions, seen 12 times:\n Outlook | open email\n Outlook | open PDF attachment\n PDF viewer | copy invoice number\n Accounting app | click New supplier invoice\n Accounting app | paste invoice number\n PDF viewer | copy amount\n Accounting app | paste amount\n Accounting app | click Save\n\napp switches: 238 | paste actions: 60The routine ran 30 times, but an exact count of all eight steps found it only 12 times, because an interruption anywhere inside it breaks the match. A four-step prefix showed up 22 times.
\nThat is one reason the commercial tools group similar actions for you (Microsoft’s tool now does this automatically) and ask for a lot of data. Still, the output names the automation: copy two fields from a PDF into the accounting app, 30 times a morning. Our guide to getting email data into Excel covers that kind of extraction.
\nThe two task mining tools we read up on differ in who presses Record. In Microsoft’s Power Automate, a person starts the desktop recorder, performs the task and selects Finish, and can pause or delete steps. The recorder stores screenshots and text entries, and Microsoft’s documentation shows how to delete screenshots and remove text before analysis.
\nUiPath’s unassisted task mining runs in the background instead. It collects “the screenshot and log data upon each user action,” such as a mouse click or keystroke. Its best-practice page recommends 2 to 7 users per project and at least 10,000 actions before analysis, with 50,000 ideal. It says an active user produces 200 to 1,000 actions an hour.
\nWork that out for a small team. At 1,000 actions an hour, the 10,000-action minimum takes 10 hours of active recording; at 200, it takes 50. Each analysis also uses 5,000 of UiPath’s AI Units. Our 341-action sample is about 3% of the minimum, which is why it took exact matching and a tidy routine to find anything.
\nHere is what each option costs, from its own pages on October 20, 2026:
\n| Option | \nWhat it does | \nPrice shown | \nDownsides | \n
|---|---|---|---|
| pm4py (open source) | \nProcess mining in Python | \nFree under AGPL-3.0; commercial license sold separately | \nNeeds someone who writes Python; no task mining | \n
| Power Automate Premium | \nProcess and task mining | \n$15 a user a month, paid yearly, with 50 MB of process mining data per license | \nText/CSV upload needs OneDrive for Business | \n
| Power Automate Process Mining add-on | \n100 GB of process mining data | \n$5,000 a tenant a month, paid yearly, Premium only | \nPriced for large companies | \n
| Celonis | \nProcess mining | \nNo prices published; a contact form for sales, free training through its Academy | \nNo way to price it before talking to sales | \n
| UiPath Task Mining | \nBackground task mining | \nNot listed on the documentation pages we read; 5,000 AI Units per analysis | \nScreenshots on every action; 10,000-action minimum | \n
Our 353-event sample log was 16.6 KB as a CSV. A five-person team on Premium holds 50 MB per license, so a log of that kind fits thousands of times over. Size is rarely the small team’s limit. Getting a clean history out of its systems is.
\nProcess mining logs often name the person who did each step, as ours did in its resource column. Under the GDPR that is personal data, so the usual rules apply even to a spreadsheet. Article 88 of the GDPR also lets EU member states set more specific rules for employee data, with particular regard to “monitoring systems at the work place.” Check your own country’s law and any collective agreement.
\nTask mining raises the stakes.
\nIn 2017 the EU’s Article 29 Working Party, the group of national data protection authorities that preceded today’s EDPB, published its opinion on data processing at work. It describes software that logs “keystrokes and mouse movements, screen capturing (either randomly or at set intervals), logging of applications used.” Its verdict: the processing is disproportionate, and the employer “is very unlikely to have a legal ground under legitimate interest” for recording keystrokes and mouse movements. The opinion predates the GDPR, but its reasoning on consent carries over: employees “are seldom in a position to freely give, refuse or revoke consent.”
\nThe UK regulator says much the same in its guidance on monitoring workers. Consent “is not usually appropriate in the employment context, due to the imbalance of power.”
\nEmployers must tell workers about monitoring and “select the least intrusive means” for their purpose, and must carry out a data protection impact assessment before processing likely to cause high risk. The ICO’s page on monitoring methods adds that keystroke monitoring counts as behavioral biometric data where a worker is identifiable. Covert monitoring is unlikely to be justified “in usual circumstances.” The ICO notes that the guidance is under review after the UK’s Data (Use and Access) Act.
\nOur reading: a person choosing to record one task, then deleting what they do not want analyzed, sits far from background capture of a whole team. It is still processing of personal data, and this is not legal advice. Background screenshot capture on every click is the case both regulators describe, and a small company should expect to have to justify it in writing.
\nMost small teams should start with process mining, because it reuses data that already exists and records nobody’s screen. Task mining earns its cost only when you already know which task to study and need the clicks inside it.
\nMore on choosing and building the automation itself is on the automation hub.
\nIn our stand-in test, a label-per-thread script missed 2 of 13 sample form emails and wrote 4 rows wrong.
Paste the script into Extensions, Apps Script, set the sender and labels, and run setup. Then send your form to yourself twice, once without a phone, and check for two rows.
If you copy details from Gmail into Google Sheets by hand, three tools can do it for you. A free Apps Script runs inside the sheet; Zapier and Google’s Workspace Studio need no code. The script route has one trap. Gmail hands scripts whole conversations, not single emails, so a script that labels each conversation can lose the second email in it.
\nWe wrote the script below and ran it on 13 sample emails we built, using stand-ins for Gmail and Sheets in Node.js, because our sandbox has no Google account. In that test a simple label-based script missed 2 of the 13 emails and wrote 4 rows wrong. Our script got all 13. Below are the steps for each route, the code, and the limits Google and Zapier document, all read on October 20, 2026.
\nApps Script reaches Gmail through GmailApp.search(), which returns threads, the conversations you see in your inbox. Gmail groups replies into one conversation, up to 100 emails before it starts a new one.
A simple script does three things. It searches for unprocessed mail, reads the first message of each thread, and marks the thread with a label such as Processed. That label is the weak spot. Google’s reference says addToThread() “adds this label to the given thread”, so the mark sits on the whole conversation.
So when a second email joins a thread that is already marked, the script has two choices, and both are wrong. If the search skips labeled threads, the new email never reaches the sheet. If the search returns the thread again, the script reads its first message a second time and writes a duplicate. We could not check which of the two real Gmail does, so we tested both.
\nThe fix is to stop marking threads. Our script reads every message in each matching thread and writes the message’s own ID in column A. Before it writes a row, it checks whether that ID is already in the sheet.
\nWe built 11 threads with 14 messages: 13 web-form notifications from one sender and 1 reply from a colleague. The names, companies and addresses are invented, on .example domains. The cases:
| Emails | \nWhat they test | \n
|---|---|
| 1, 6, 8 | \nPlain Label: value lines; email 6 has a phone starting with +, email 8 one starting with 0 | \n
| 2 | \nA message three lines long | \n
| 3 | \nNo phone line | \n
| 4 | \nCompany Name: above Name: | \n
| 5 | \nEach value on the line below its label | \n
| 7 | \nA message field that starts with =HYPERLINK( | \n
| 9 | \nThe label spelled E-mail: | \n
| 10, 12, 14 | \nThree form emails in one conversation, with a colleague’s reply (email 11) between the first two | \n
| 13 | \nA CSV file and a logo attached | \n
We could not run Apps Script itself. So we ran the code unchanged in Node.js 22 with small stand-ins for GmailApp, SpreadsheetApp, ScriptApp and Utilities that follow Google’s reference. That tests our logic, not Google’s servers. Gmail’s own conversion of HTML email to plain text, its search, and real quotas were not part of it.
We compared our script with a short label-based script that does those three things. Both ran once, then again after email 14 arrived in the old conversation:
\n| Method | \nEmails with a row (of 13) | \nRows fully right | \nWhat went wrong | \n
|---|---|---|---|
| Label-based script, labeled thread skipped | \n11 | \n6 | \nEmails 12 and 14 missed; 4 rows wrong; 1 formula | \n
| Label-based script, labeled thread returned | \n11, plus 1 duplicate | \n6 | \nSame, and email 10 written twice | \n
| Our script | \n13 | \n13 | \nNothing in this run | \n
The 4 wrong rows: email 2 lost two lines of its message, email 4 got Dahl CPA as the person’s name, email 5 came out blank, and email 9 had no email address. The formula is email 7. Google’s reference for both appendRow() and setValues() says: “If a cell’s content begins with =, it’s interpreted as a formula.” Anyone who can fill in your form can put a working formula in your sheet.
One caveat is ours. We wrote the script while looking at these cases, so 13 of 13 is a best case. A sender with a layout we did not plan for will break it until you add the label.
\n| \n | Apps Script | \nZapier | \nWorkspace Studio | \n
|---|---|---|---|
| Cost | \nFree with any Google account | \nFree: 100 tasks a month; Professional from $19.99 a month billed yearly | \nAvailable in eligible Workspace editions | \n
| Personal Gmail | \nYes | \nNot checked by us | \nOnly through Google Workspace Experiments | \n
| How fast | \nEvery 1 to 30 minutes | \nChecks every 15 minutes on Free, 2 on paid plans | \nWhen the email arrives | \n
| Splits fields | \nYes, with the labels you list | \nNeeds a third step, so a paid plan | \nYes, with its AI Extract step | \n
| Old mail | \nYes, anything the search finds | \nNew mail, as the trigger’s name says | \nNew mail only | \n
| Main limit | \n90 minutes of trigger runtime a day on personal accounts | \nTasks per month | \n25 flows; a daily run limit | \n
Our view: start with the script if you have a personal Gmail account or the emails follow a fixed layout. It is free, it backfills old mail, and you can read what it does. Use Workspace Studio if your company is on an eligible Workspace edition and the layouts vary. Use Zapier when the data must also go to tools outside Google.
\nmyFunction, then save.CONFIG. Set from to the sender’s address and query to a Gmail search, for example from:noreply@yourform.example newer_than:7d. Under fields, list every label your senders use for each column.setup in the toolbar and choose Run. It creates a time-driven trigger and fills the sheet from the mail the search finds. Google asks you to authorize access first: every GmailApp method needs the full https://mail.google.com/ scope.Leads tab appears with one row per email. The Missing column names any field the script did not find.// Gmail to Google Sheets: copy labeled fields from matching emails into a sheet.\n// Paste into Extensions > Apps Script in the target spreadsheet, edit CONFIG, run setup() once.\nconst CONFIG = {\n from: 'noreply@yourform.example', // only messages from this sender; '' for any sender\n query: 'from:noreply@yourform.example newer_than:7d', // Gmail search, same syntax as the search box\n sheet: 'Leads',\n fields: { // column: the labels senders use for it\n Name: ['Name', 'Full name'],\n Email: ['Email', 'E-mail'],\n Phone: ['Phone', 'Mobile'],\n Company: ['Company', 'Company name'],\n Message: ['Message', 'Comments'],\n },\n multiline: ['Message'], // these keep reading until the next label\n csvSheet: 'CSV import', // rows from .csv attachments go here; '' to skip\n};\nconst QUOTE = /^(-{2,}\\s*(Forwarded message|Original Message)\\s*-{2,}|On .+ wrote:)$/im;\n\nfunction setup() { // run once: creates the sheets and a 15-minute trigger\n ScriptApp.getProjectTriggers().forEach(t => ScriptApp.deleteTrigger(t));\n ScriptApp.newTrigger('run').timeBased().everyMinutes(15).create();\n run();\n}\n\nfunction run() {\n const ss = SpreadsheetApp.getActiveSpreadsheet();\n const sheet = getSheet(ss, CONFIG.sheet, ['Message ID', 'Received', 'From', ...Object.keys(CONFIG.fields), 'Missing']);\n const seen = new Set(sheet.getRange(1, 1, Math.max(1, sheet.getLastRow()), 1).getValues().map(r => String(r[0])));\n const rows = [], csvRows = [];\n let csvHeader = [];\n for (const thread of GmailApp.search(CONFIG.query, 0, 100)) {\n for (const msg of thread.getMessages()) { // every message, so a reply in an old thread still counts\n const id = msg.getId();\n if (seen.has(id) || !msg.getFrom().toLowerCase().includes(CONFIG.from.toLowerCase())) continue; // done, or a reply from you\n seen.add(id);\n const row = parse(msg.getPlainBody());\n const cols = Object.keys(CONFIG.fields);\n rows.push([id, msg.getDate(), msg.getFrom(), ...cols.map(c => asText(row[c] || '')),\n cols.filter(c => !row[c]).join(' ')]);\n if (CONFIG.csvSheet) {\n for (const file of msg.getAttachments({includeInlineImages: false})) {\n if (!/\\.csv$/i.test(file.getName())) continue;\n const text = file.getDataAsString('UTF-8').replace(/^\\uFEFF/, ''); // drop Excel's byte order mark\n const table = Utilities.parseCsv(text);\n csvHeader = table[0];\n table.slice(1).forEach(r => csvRows.push([id, file.getName(), ...r.map(asText)]));\n }\n }\n }\n }\n write(sheet, rows);\n if (csvRows.length) write(getSheet(ss, CONFIG.csvSheet, ['Message ID', 'File', ...csvHeader]), csvRows);\n console.log(`added ${rows.length} rows, ${csvRows.length} CSV rows`);\n}\n\nfunction parse(text) {\n const parts = text.split(QUOTE);\n if (parts.length > 1) text = parts[parts.length - 1]; // forwarded or replied: read only the original\n const labels = {};\n for (const [col, ls] of Object.entries(CONFIG.fields)) ls.forEach(l => labels[l.toLowerCase()] = col);\n const alts = Object.keys(labels).sort((a, b) => b.length - a.length).map(l => l.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'));\n const rx = new RegExp('^\\\\s*(' + alts.join('|') + ')\\\\s*:\\\\s*(.*)$', 'i');\n const row = {};\n let col = null;\n for (const raw of text.split(/\\r?\\n/)) {\n const line = raw.replace(/^(>\\s?)+/, '').trim(), hit = line.match(rx);\n if (hit) {\n col = labels[hit[1].toLowerCase()];\n if (col in row) { col = null; continue; } // keep the first value of each field\n row[col] = hit[2].trim();\n } else if (col && line) {\n if (!row[col]) row[col] = line; // value on the line below its label\n else if (CONFIG.multiline.includes(col)) row[col] += ' ' + line;\n else col = null;\n } else if (!line && col && row[col]) col = null;\n }\n return row;\n}\n\nfunction asText(v) { // the apostrophe keeps =, +, -, @ and leading zeros as typed text\n v = String(v);\n return /^[=+\\-@]|^0\\d/.test(v) ? \"'\" + v : v;\n}\n\nfunction getSheet(ss, name, header) {\n let sheet = ss.getSheetByName(name);\n if (!sheet) { sheet = ss.insertSheet(name); sheet.appendRow(header); }\n return sheet;\n}\n\nfunction write(sheet, rows) { // one call for all rows: much faster than appendRow in a loop\n if (!rows.length) return;\n const width = Math.max(...rows.map(r => r.length));\n rows = rows.map(r => r.concat(Array(width - r.length).fill('')));\n sheet.getRange(sheet.getLastRow() + 1, 1, rows.length, width).setValues(rows);\n}Labels match only at the start of a line, longest first, so Name doesn’t match inside Company Name. An empty label line takes the next line as its value. A message from anyone other than from is skipped, so your own replies in the thread never become rows.
The apostrophe in asText is there to keep such values as text. Our stand-in can’t show how a live sheet treats it, so check one row with a + phone number after your first run.
Rows are written in one setValues() call per run rather than one call per row. Google’s best-practices page says “Your scripts will run faster if you minimize service calls.” In its example, 10,000 cells written one at a time took about 70 seconds; batched, 1 second.
This is the real output of three runs in our stand-in: the first run, a second run with no new mail, and a third after email 14 arrived in the old conversation.
\n--- run 1 (setup)\ntrigger: run every 15 minutes\nadded 12 rows, 2 CSV rows\n--- run 2, no new mail\nadded 0 rows, 0 CSV rows\n--- run 3, one new form email lands in an old conversation\nadded 1 rows, 0 CSV rowsRow 3 came out as Cara Lund | cara@lund.example | | Lund Bakery | No phone, email me. | Phone: a blank phone, and the gap named in Missing instead of hidden. Email 7’s message was written as '=HYPERLINK(...), as text.
Apps Script limits are per user, and they reset “24 hours after the first request”, according to Google’s quotas page (updated September 3, 2026):
\n| Limit | \nPersonal Gmail | \nGoogle Workspace | \n
|---|---|---|
| Trigger runtime, total | \n90 minutes a day | \n6 hours a day | \n
| Gmail read and write (not sending) | \n20,000 a day | \n50,000 a day | \n
| One run | \n6 minutes | \n6 minutes | \n
| Triggers | \n20 per user per script | \n20 per user per script | \n
The runtime line matters most. A 15-minute trigger runs 96 times a day, so on a personal account each run must average under 56 seconds (5,400 seconds divided by 96) to stay inside 90 minutes. If your runs take longer, set the trigger to 30 minutes in setup. everyMinutes() accepts only 1, 5, 10, 15 or 30.
When a quota runs out, the script stops with an error such as “Service using too much computer time for one day”. A failed trigger sends you an email titled “Summary of failures for Apps Script”, and the project’s Executions page shows each run.
\nThree more limits come from the code itself:
\nSome systems email a CSV report every morning instead of one email per record. The script handles that too. For every attachment whose name ends in .csv, it parses the text with Utilities.parseCsv(). The rows go to a tab named CSV import, after the message ID and file name.
Two details came from our test file. A CSV saved by Excel as UTF-8 can start with an invisible byte order mark, which the script strips so the first header doesn’t carry it. And the test file had a quoted value with a comma, \"Lind, Anna\", which landed in one cell as it should.
The script skips inline images such as logos by passing includeInlineImages: false to getAttachments(); Google’s default includes them. Set csvSheet to '' if you don’t want this part.
Zapier’s Gmail and Google Sheets page lists the pieces: the trigger New Email Matching Search and the action Create Spreadsheet Row.
\nfrom:noreply@yourform.example.That two-step Zap fits the Free plan: 100 tasks a month, two-step Zaps only, and a check for new mail every 15 minutes. Zapier counts a task as “any successful action”, and triggers are free, so each new row costs one task. A form that brings in five leads a day uses about 150 tasks a month and outgrows the free plan.
\nSplitting the body into Name, Phone and the rest takes a step in the middle. Zapier says its Formatter steps don’t count as tasks, but a three-step Zap needs a paid plan. Professional starts at $19.99 a month billed yearly for 750 tasks, or $29.99 billed monthly, and checks every 2 minutes. If you only want the whole email body in one cell, the free plan is enough.
\nWhen you run out of tasks without pay-per-task billing, Zapier “holds new Zap runs until your billing cycle resets”. They are not lost; you can replay them later. Note that your email text passes through Zapier’s servers, which the Apps Script route avoids.
\nGoogle’s own no-code tool, Workspace Studio, builds a flow from a starter and steps. Its guide to starters and steps lists the three you need:
\nIt is the only route of the three that reacts when the email arrives instead of checking on a timer. The limits, from Google’s limits page: at most 25 flows per person, 20 steps per flow, and 25 active flows started from Gmail. A daily run limit covers all your flows together; the page doesn’t give the number. When you hit it, “your active flows stop running” until it resets 24 hours later.
\nThe catch is access. It works on business, enterprise and education editions whose admin has turned on Gemini, and on personal accounts only through Google Workspace Experiments. It reacts to new mail, so it won’t backfill the emails already in your inbox.
\nExtract is AI, too: a wrong value looks exactly like a right one, so spot-check rows against their emails for the first week. We could not test it without a Google account.
\nWhichever route you pick, the failure to fear is the quiet one: a row that arrives half empty, or an email that never arrives at all. Sort the sheet by Missing once a week and open the emails behind any entry. If one sender’s rows start missing fields, its layout changed and you need a new label in CONFIG.
For the Outlook and Excel side of the same job, see email data into Excel, which tests the same field-splitting idea on 20 emails. Before you build, our one-week tally shows whether this is the task worth automating first. Once the sheet fills, the weekly report guide can send a summary of it on a schedule, and our checks for scheduled scripts make a silent failure speak up. More guides are under automation.
\nStart by sending your own form to yourself twice, once with the phone left out, and run setup. Two rows with one Missing entry mean your labels match. Then reply to one of those emails and run it again: no new row should appear.
In our worked example, a monthly task looked like a 19-month payback until upkeep was counted; then it never paid.
Before building an automation, fill in the template with your numbers and log every fix. If payback reads never, simplify or skip it and keep the build hours.
The simple payback sum for an automation counts minutes saved and hours to build, then stops. It leaves out the hours spent fixing it afterward.
\nThose hours are built into the platforms. Power Automate turns off a cloud flow whose trigger or actions fail continuously for 14 days, and Zapier turns off a Zap that errors 95% of the time it runs. Someone then has to notice it and redo the missed work.
\nThat matters most for the small tasks people automate first. Much of upkeep is fixed: reconnecting a login or adjusting to a renamed column takes the same hour whether the task runs 12 times a year or 3,000. So upkeep can eat a small saving whole.
\nThis guide gives the formula, a spreadsheet template we built and tested, and three worked examples priced with US government wage data.
\nWrite the yearly saving in hours first, then turn hours into money. Here is the whole model, with each input named:
\n“Minutes still spent after automating” is the check you keep doing: opening the sheet and fixing a typo the tool copied in. It is rarely zero. “Fixed upkeep” is the work that comes whether or not anything breaks, such as reconnecting an expired login or re-testing after a tool update. “Minutes per failure” covers noticing the failure, fixing it and doing the missed runs by hand.
\nIf net value per year is zero or below, the automation never pays back. No build cost is small enough to save it.
\nA saved hour is worth what the employer pays for it, which is more than the hourly wage. The US Bureau of Labor Statistics measures both halves.
\nThe wage comes from the Occupational Employment and Wage Statistics survey. In the May 2025 national file, which we downloaded and read on 20 October 2026, the median hourly wage for bookkeeping, accounting and auditing clerks is $24.36. For general office clerks it is $21.64, and for all occupations $24.51.
\nThe rest comes from the Employer Costs for Employee Compensation release. In June 2026, wages and salaries made up 66.5% of total compensation for civilian workers in office and administrative support jobs, where total compensation averaged $38.27 an hour. The other third is benefits. For all private industry workers the wage share was 70.0%.
\nSo the loaded cost per hour is the wage divided by the wage share. For a bookkeeping clerk at the median: $24.36 ÷ 0.665 = $36.63. Treat it as an approximation, because it applies a group average to one occupation’s median.
\nPut labels in column A and your numbers in column B. Rows 2 to 12 are inputs; rows 14 to 23 are formulas. We tested them in LibreOffice Calc; they use only IF and MAX, which Excel and Google Sheets also have. You can also download the template as an .xlsx file, with our three examples filled in and a fifth column to type over.
\n| Row | \nColumn A | \nColumn B | \n
|---|---|---|
| 2 | \nRuns per year | \nyour number | \n
| 3 | \nMinutes per run by hand | \nyour number | \n
| 4 | \nMinutes per run still spent after automating | \nyour number | \n
| 5 | \nHours to build and test | \nyour number | \n
| 6 | \nUpkeep hours per year | \nyour number | \n
| 7 | \nFailures per year | \nyour number | \n
| 8 | \nMinutes per failure (notice, fix, redo by hand) | \nyour number | \n
| 9 | \nTool cost per year ($) | \nyour number | \n
| 10 | \nHourly wage ($) | \n24.36 | \n
| 11 | \nWages as share of total pay cost | \n0.665 | \n
| 12 | \nHorizon (years) | \n3 | \n
| 14 | \nLoaded cost per hour ($) | \n=B10/B11 | \n
| 15 | \nHours saved per year, before upkeep | \n=B2*(B3-B4)/60 | \n
| 16 | \nUpkeep and failure hours per year | \n=B6+B7*B8/60 | \n
| 17 | \nNet hours saved per year | \n=B15-B16 | \n
| 18 | \nNet value per year ($) | \n=B17*B14-B9 | \n
| 19 | \nBuild cost ($) | \n=B5*B14 | \n
| 20 | \nPayback (months) | \n=IF(B18<=0,\"never\",B19/B18*12) | \n
| 21 | \nNet over horizon ($) | \n=B18*B12-B19 | \n
| 22 | \nMost build hours that still break even | \n=MAX(0,B18*B12/B14) | \n
| 23 | \nPayback if upkeep is ignored (months) | \n=IF(B15*B14-B9<=0,\"never\",B19/(B15*B14-B9)*12) | \n
Row 22 answers the question people usually ask first: how long can I spend building this? It is the build budget over your horizon, after upkeep. Row 23 is there for comparison. It is the simple sum without upkeep, and the gap between rows 20 and 23 is the cost of ignoring upkeep.
\nIf someone else builds it at a different rate, scale the build hours. Ten hours from a contractor who costs twice the loaded rate go in row 5 as 20.
\nThese are examples. The task counts, minutes, build hours and failure rates below are our assumptions, chosen to show how the formula behaves; they are not measurements. The wage, the wage share and the tool price are real and sourced above. All three use a three-year horizon.
\nBefore reading the table, guess which one upkeep hurts most. LibreOffice Calc returned these results from the template:
\n| \n | Example A | \nExample B | \nExample C | \n
|---|---|---|---|
| Hours saved per year, before upkeep | \n175 | \n34.7 | \n5 | \n
| Upkeep and failure hours per year | \n22 | \n14 | \n6 | \n
| Net hours saved per year | \n153 | \n20.7 | \n−1 | \n
| Net value per year | \n$5,364.75 | \n$757.05 | \n−$36.63 | \n
| Build cost | \n$1,098.95 | \n$439.58 | \n$293.05 | \n
| Payback, upkeep counted | \n2.5 months | \n7.0 months | \nnever | \n
| Payback, upkeep ignored | \n2.1 months | \n4.2 months | \n19.2 months | \n
| Net over three years | \n$14,995.31 | \n$1,831.58 | \n−$402.95 | \n
| Most build hours that still break even | \n439 | \n62 | \n0 | \n
Upkeep took 13% of Example A’s gross saving and barely moved its payback. It took 40% of Example B’s and stretched payback by two thirds. Example C saves 5 hours a year and costs 6 to keep alive. Counted without upkeep, it looks like a 19-month payback; counted honestly, every hour spent building it is lost.
\nThe sensitivity is steep for mid-sized tasks. Holding everything else in Example B fixed, we varied its total upkeep and failure hours:
\n| Example B upkeep and failure hours per year | \n0 | \n7 | \n14 | \n28 | \n
|---|---|---|---|---|
| Payback | \n4.2 months | \n5.2 months | \n7.0 months | \n21.6 months | \n
At 34.7 hours of upkeep a year, Example B’s whole saving is gone. Example A could absorb 168 hours before it stopped paying.
\nWe wrote the template with Python’s openpyxl library, with formulas in the cells rather than typed results. LibreOffice 24.2 in headless mode opened and calculated it, then exported the values to CSV. A separate Python function recomputed the same model from the inputs. All 30 results (ten outputs for three examples) matched to within a cent:
\nExample C\n Net hours saved per year LO= -1 PY= -1.0 OK\n Payback (months) LO= never PY= never OK\n Payback if upkeep is ignored (months) LO= 19.2 PY= 19.2 OKThe check catches typing slips in the formulas, not wrong assumptions. If your inputs are guesses, the payback is a guess with decimals.
\nThe weakest input is upkeep, and the platforms do not total it for you. Power Automate keeps run history for 30 days, so a failure from last quarter is gone unless you wrote it down. Keep a two-column log next to the automation: date, minutes spent. Every fix and every manual redo goes in it.
\nSome upkeep is forced on you. Power Automate may turn off a cloud flow that has not been triggered for 90 days, unless the owner has a premium or capacity license. It notifies owners 30 days before, so someone has to read that email. A flow that runs quarterly or less often is the one this rule catches.
\nZapier’s shutoff needs volume too: beside the 95% error rate, it lists a Zap that has run more than 20 times in the past 7 days. Either way, a turned-off automation saves nothing until someone turns it back on.
\nFor a new automation with no history, borrow numbers from the old ones. If you have none, start with the hours you spent building it and assume a share comes back every year. Then run row 23 against row 20 and see how far apart they land. Our guide to scheduled scripts that fail silently covers making failures visible, which shortens the “notice” part of every failure.
\nMoney saved is real only if the freed hours go to other paid work. If a clerk’s time would sit idle, the saving is time, not cash. The formula also ignores the cost of an error the automation makes and nobody catches, which can exceed everything else. Our piece on five tests before buying automation covers that risk.
\nTime-only charts, such as xkcd’s Is It Worth the Time?, give a build budget from frequency and minutes saved, with no upkeep line. The same comic site’s Automation strip draws the missing line as ongoing development. The template puts a number on it, and our recomputed xkcd table applies upkeep to the comic’s own cells.
\nPick the automation you are about to build, or the one already running that annoys you most. Fill column E of the downloaded template with its numbers, and start the upkeep log the same day. If row 20 says “never”, stop or simplify it before spending more hours. If you still need a candidate, the one-week tally method finds the tasks that repeat most; more guides sit under automation.
\nIn our emulation, the tutorial email-to-Excel recipe failed on 8 of 20 test emails and botched 4 more.
Build one flow per sender format with the guarded expression below, add a Missing column, and check it weekly. Rows that break then show up instead of disappearing.
If web forms, order systems or suppliers send you emails with the same fields every time, you can stop copying those fields into Excel by hand. A Power Automate flow, a short script or an AI prompt can fill the table for you. The catch is the method nearly every tutorial teaches: cut the text after a label such as Name:. It works until one sender changes its layout.
We built 20 sample emails in six layouts that real inboxes get and ran them through three methods. The label-split recipe, as tutorials write it, got 8 of the 20 rows fully right. A script we wrote got all 20, and so did an AI prompt.
\nBelow are the steps for each, the code, and the limits Microsoft documents. All documentation was read on October 20, 2026.
\nThe no-code recipe has three moves. A flow starts when an email arrives, turns the email’s HTML into plain text, then cuts out each field with text functions. In Power Automate that means the Office 365 Outlook trigger and the Html to text action from the Content Conversion connector. Then the split() function takes everything after Phone:, and everything before the next line break.
That logic assumes every email has the label, spelled the same way, with the value on the same line. Microsoft’s documentation shows three ways the assumption fails before any sender changes anything.
\nPhone +1 213 555 0160, with no Phone: to find.text[link] unless the text and the address are the same. By that documented rule, an email address sent as a mailto link comes out as dpark@parkdental.example[mailto:dpark@parkdental.example].A missing label is worse. When the delimiter is not in the text, split() returns an array with a single element, so the tutorial expression asks for a second item that does not exist. In our emulation that counts as a failed run, and the row never reaches Excel.
We wrote 20 web-form notification emails as standard .eml files with Python’s email library, one lead per email, five fields each (Name, Email, Phone, Company, Message). That makes 100 values to get right. The names and companies are invented, on .example addresses. The layouts:
| Emails | \nFormat | \nWhat it tests | \n
|---|---|---|
| 1 to 8 | \nPlain text, Name: value on each line | \nThe happy path; email 5 has a three-line message, email 7 has no phone line | \n
| 9 to 12 | \nHTML table, label in one cell, value in the next | \nNo colons after conversion; email address as a mailto link | \n
| 13 to 15 | \nPlain text with Company Name: above Name:, and E-mail: | \nA label inside another label; a spelling variant | \n
| 16 and 17 | \nHTML, label in one paragraph, value in the next | \nValue on the line below the label | \n
| 18 and 19 | \nForwarded by a colleague | \nExtra header lines above the form | \n
| 20 | \nReplied to, with the colleague’s signature on top | \nA second Phone: and Email: before the real ones | \n
We could not run Power Automate in our sandbox, which has no Microsoft 365 tenant. So we emulated it. Our Python code converts HTML by the rules Microsoft documents for Html to text, then applies the same split logic with the labels from the first layout. Plain-text emails went to the split step directly.
\nWe tested it two ways. The tutorial form fails when a label is missing. Our guarded form, shown in step 2, returns an empty cell instead. The script ran for real, and we gave the AI prompt to a Claude model from Anthropic in our sandbox. The results:
\n| Method | \nFields right (of 100) | \nRows fully right (of 20) | \nWhat went wrong | \n
|---|---|---|---|
| Label split, tutorial form | \n47 | \n8 | \n8 runs fail, so those rows never arrive; 4 rows written wrong or blank | \n
| Label split, guarded | \n63 | \n10 | \nNo failures, but 6 rows arrive blank, 3 lose two fields and 1 message is cut | \n
| Our Python script | \n100 (99 on the first run) | \n20 | \nOne missing space, fixed | \n
| AI prompt | \n100 | \n20 | \nNothing in this run | \n
The failures follow the layouts exactly. The tutorial split failed on the missing phone line (email 7), on all four tables, and on all three E-mail: emails.
It read Carter CPA as Ben Carter’s name, because Name: first appears inside Company Name:. It kept only the first line of email 5’s three-line message. It wrote empty rows for the two stacked layouts. And on the reply, it filled the lead’s Email and Phone with the colleague’s signature.
The guarded version fixed three of those. The missing phone no longer stops the run, and by reading the last Name: and the last Phone:, it got the names and the reply right. Its failures are quieter, which is a different problem. A failed run shows up in the flow’s history; a blank row looks like a lead who skipped the form.
Two caveats are ours. We wrote the script while looking at all six layouts, so it is a best case: a new seventh layout will break it until you add the label. And we ran the AI prompt once. Twenty emails is a small sample, so 100 out of 100 says the method can work on messy emails, not that it never errs.
\nThe number of different layouts in your inbox decides this more than price does.
\n| \n | Power Automate flow | \nPython script | \nAI prompt in a flow | \n
|---|---|---|---|
| Best for | \nOne sender, one fixed layout | \nA backlog, any mailbox, mixed layouts | \nLayouts that change or come from many senders | \n
| Runs | \nBy itself when mail arrives | \nWhen you run it | \nBy itself when mail arrives | \n
| Cost | \nFree license for work and school accounts | \nFree; needs Python 3 | \nCredits per run, billed by tokens | \n
| Breaks when | \nA label changes, moves or goes missing | \nA sender uses a label you did not list | \nNot in our one run; each run costs credits | \n
| Main limit | \n25 MB workbook; don’t edit it while the flow writes | \nYou save the emails yourself first | \nEmail text goes to an AI service | \n
Our view: if one website form sends all the email, build the flow. If three suppliers each send their own layout, build three flows, each filtered to one sender, rather than one flow with clever expressions. Reach for AI when the layouts are too many to keep up with.
\nThis needs a Microsoft 365 work or school account. All three connectors used here, Office 365 Outlook, Content Conversion and Excel Online (Business), are standard connectors, which the free license covers. That license doesn’t let you share the flow, so it runs in one person’s account.
\nReceived, Name, Email, Phone, Company, Message, Missing in row 1, select them and choose Insert and then Table. The connector’s Add a row action needs a table, in an .xlsx or .xlsb file. Avoid headers that are only a number; Microsoft lists them as a cause of unexpected behavior.noreply@yourform.example, and Subject Filter to text that is always in the subject. The trigger reacts to new mail, so it fills the table from today; mail already in the inbox needs step 3.if(contains(body('Html_to_text'), 'Phone:'), trim(first(split(last(split(body('Html_to_text'), 'Phone:')), decodeUriComponent('%0A')))), '')body('Html_to_text') must match your conversion action’s name.
contains() checks that the label is there before anything is split, and it is case-sensitive, so phone: will not match. last() takes the text after the last Phone:, which skips a colleague’s signature at the top of a reply. decodeUriComponent('%0A') is a line break. Copy it for each field and change the label.
Missing that lists empty fields, for example concat(if(empty(outputs('Name')), 'Name ', ''), if(empty(outputs('Phone')), 'Phone ', '')), extended to every field.Received to the trigger’s Received Time.Send the form to yourself three times: once filled in fully, once with the phone left out, and once with a message longer than 80 characters. Then look at all three rows. The first should be complete, the second should name Phone in the Missing column, and the third shows whether the converter cut your message.
\nMicrosoft’s Excel Online (Business) reference lists these, and the first two cause most of the trouble:
\nThe script works on any mailbox, including a personal one, the new Outlook and Outlook on the web. It also clears a backlog the flow can’t see.
\nIts weakness is the first step: you save the emails yourself. In Outlook on the web, select a message, then More actions and Download, which saves it as an EML or MSG file. The script reads only .eml files.
\nDownloads/leads.email_to_csv.py. Edit FIELDS so each column lists every label your senders use for it.python3 email_to_csv.py Downloads/leads leads.csv.leads.csv, choose Import, check the preview and choose Load.\"\"\"Pull labelled fields out of a folder of .eml files into one CSV for Excel.\n\nUsage: python3 email_to_csv.py <folder of .eml files> <output.csv>\nEdit FIELDS for your own forms. Standard library only.\n\"\"\"\nimport csv, re, sys, pathlib, email, email.policy\nfrom email.utils import parsedate_to_datetime\nfrom html.parser import HTMLParser\n\nFIELDS = { # column: the labels senders use for it\n \"Name\": [\"Name\", \"Full name\", \"Contact name\"],\n \"Email\": [\"Email\", \"E-mail\", \"Email address\"],\n \"Phone\": [\"Phone\", \"Telephone\", \"Mobile\"],\n \"Company\": [\"Company\", \"Company name\", \"Organization\"],\n \"Message\": [\"Message\", \"Comments\"],\n}\nMULTILINE = {\"Message\"} # these keep reading until the next label\nQUOTE = re.compile(r\"^(-{2,}\\s*(Forwarded message|Original Message)\\s*-{2,}|On .+ wrote:)$\", re.I | re.M)\nSTOP = re.compile(r\"^(Sent from |--\\s*$)\", re.I)\n\nclass Text(HTMLParser): # HTML to lines; a table row becomes \"label: value\"\n def __init__(self):\n super().__init__(); self.out, self.cells, self.cell = [], None, \"\"\n def handle_starttag(self, tag, attrs):\n if tag == \"br\" and self.cells is not None: self.cell += \" \" # line break inside a cell\n elif tag in (\"p\", \"div\", \"br\", \"h1\", \"h2\", \"h3\", \"li\"): self.out.append(\"\\n\")\n if tag == \"tr\": self.cells = []\n if tag in (\"td\", \"th\"): self.cell = \"\"\n def handle_endtag(self, tag):\n if tag in (\"td\", \"th\") and self.cells is not None: self.cells.append(self.cell.strip())\n if tag == \"tr\" and self.cells:\n self.out.append(\"\\n\" + self.cells[0].rstrip(\":\") + \": \" + \" \".join(self.cells[1:]) + \"\\n\")\n self.cells = None\n def handle_data(self, data):\n if self.cells is not None: self.cell += data\n else: self.out.append(data)\n\ndef body_text(msg):\n part = msg.get_body((\"plain\", \"html\"))\n if part is None: return \"\"\n text = part.get_content()\n if part.get_content_subtype() == \"html\":\n p = Text(); p.feed(text); text = \"\".join(p.out)\n return text.replace(\"\\r\\n\", \"\\n\").replace(\"\\xa0\", \" \")\n\ndef label_pattern():\n alts = {re.escape(l.lower()): col for col, ls in FIELDS.items() for l in ls}\n rx = re.compile(r\"^\\s*(\" + \"|\".join(sorted(alts, key=len, reverse=True)) + r\")\\s*:\\s*(.*)$\", re.I)\n return rx, alts\n\ndef parse(text):\n m = list(QUOTE.finditer(text))\n if m: text = text[m[-1].end():] # forwarded or replied: read only the original\n rx, alts = label_pattern()\n lines = [l.strip() for l in text.split(\"\\n\")]\n row, col = {}, None\n for line in lines:\n hit = rx.match(line)\n if hit:\n col = alts[re.escape(hit.group(1).lower())]\n if col in row: col = None; continue # keep the first value of each field\n row[col] = hit.group(2).strip()\n elif col and line and not STOP.match(line):\n if not row[col]: row[col] = line # value on the next line\n elif col in MULTILINE: row[col] += \" \" + line\n else: col = None\n elif not line and col and row.get(col): col = None\n return row\n\ndef main(src, out):\n files = sorted(pathlib.Path(src).glob(\"*.eml\"))\n with open(out, \"w\", newline=\"\", encoding=\"utf-8-sig\") as f: # utf-8-sig: Excel reads å, ä, ö\n w = csv.writer(f)\n w.writerow([\"File\", \"Received\", *FIELDS, \"Missing\"])\n for path in files:\n msg = email.message_from_bytes(path.read_bytes(), policy=email.policy.default)\n when = parsedate_to_datetime(msg[\"Date\"]).strftime(\"%Y-%m-%d %H:%M\") if msg[\"Date\"] else \"\"\n row = parse(body_text(msg))\n missing = [c for c in FIELDS if not row.get(c)]\n w.writerow([path.name, when, *(row.get(c, \"\") for c in FIELDS), \" \".join(missing)])\n print(f\"{path.name}: {len(FIELDS) - len(missing)} of {len(FIELDS)} fields\" + (f\", missing {' '.join(missing)}\" if missing else \"\"))\n print(f\"wrote {len(files)} rows to {out}\")\n\nif __name__ == \"__main__\":\n main(sys.argv[1], sys.argv[2])This is its real output, run with Python 3.11 on Linux. Three runs took 0.07 to 0.08 seconds each. Email 7 has no phone line, and the script says so instead of failing:
\n01.eml: 5 of 5 fields\n02.eml: 5 of 5 fields\n03.eml: 5 of 5 fields\n04.eml: 5 of 5 fields\n05.eml: 5 of 5 fields\n06.eml: 5 of 5 fields\n07.eml: 4 of 5 fields, missing Phone\n08.eml: 5 of 5 fields\n09.eml: 5 of 5 fields\n...\n20.eml: 5 of 5 fields\nwrote 20 rows to leads.csvThe first version got 99 of 100 fields. Email 11 has a two-line message inside a table cell, split by an HTML line break, and the script glued the lines together as April.Can. We added the line that turns a break inside a cell into a space, and the second run got all 100. That is the honest picture of this method: it is exact once you have taught it every quirk, and every new quirk is a fix you make yourself.
How it handles the traps from the test: labels are matched only at the start of a line, so Name doesn’t match inside Company Name. When a label line is empty, it takes the next line as the value. And if the email contains a forwarding or reply marker, it reads only the text after the last one, which drops the colleague’s signature.
The AI route swaps the expressions for one instruction. This is the prompt we gave, once per email, with the raw body as input:
\nThis is the body of an email notifying us of a website form submission.\nIt may be HTML, forwarded or replied to. Extract the details of the person\nwho filled in the form: Name, Email, Phone, Company, Message. Use only text\nin the email. If a field is not present, return an empty string. Keep the\nmessage text exactly as written, joining lines with a single space.\nReturn JSON only.It returned all 100 values correctly, including the tables and the stacked layouts. It also skipped the colleague’s signature in the reply; the prompt only asked for “the person who filled in the form”. That run used a Claude model in our sandbox, not Microsoft’s AI tools, so treat it as evidence for the method, not for any one product.
\nInside Power Automate, the same idea is an AI Builder prompt action, and that is where the cost comes in. Microsoft’s credit management page, updated October 8, 2026, says prompts always consume credits outside testing, priced on input and output tokens and the model you pick.
\nNew customers can no longer buy the AI Builder credit add-on and must buy Copilot Credits instead. The 5,000 AI Builder credits a month that came with each Power Automate Premium license are granted only up to November 1, 2026. When an environment runs out of AI Builder credits and has no Copilot Credits to fall back on, AI Builder actions fail with errors such as QuotaExceeded.
Two more trade-offs. Every email body goes to an AI service, so check your company’s rules before you send customer data there. And a wrong answer from a model looks exactly like a right one, so keep the Missing column and spot-check rows against the emails.
\nExcel can also read a mailbox directly. Power Query’s Microsoft Exchange Online connector imports mail into a workbook, and Text.BetweenDelimiters can cut a field out of the body. That is the same label logic as the flow, with the same weak spots.
The bigger problem is the date. Microsoft’s page says the connector “will be replaced by new Exchange Mail and Calendar connectors in Excel Power Query by April 2027”. Workbook owners must migrate connections by hand.
\nThe message center notice, MC1461158, says existing workbooks “will not automatically transition”, and that the new connectors need Microsoft 365 Apps or Office 2024. Our view: don’t start a new workbook on a connector with a retirement date. If you already have one, list it now so the April deadline doesn’t surprise you.
\nWhichever method you pick, the dangerous failure is a quiet one: a row that arrives blank or half full. Sort the table by the Missing column once a week and open the emails behind any row that has an entry. A cluster of misses from one sender means its layout changed, and your flow or script needs a new label.
\nIf you are still deciding whether this is the task to automate first, our one-week tally will tell you. When the emails carry invoices as attachments, saving Outlook attachments automatically covers that half of the job. The weekly report guide can turn the finished table into a report on a schedule, and our checks for scheduled scripts make a broken run speak up.
\nIf your mail is in Gmail and your table in Google Sheets, our Gmail to Google Sheets guide does the same job with a free Apps Script. More guides are under automation.
\nStart with the three test emails from the flow section today: full, missing a phone, long message. They will show you which kind of failure your setup has before a real lead falls into it.
\nCloudflare's new Clairic model charges only for input: $0.10 per million tokens, with no output fee.
Run 20 of your own invoices through the free tier and compare each field with what you typed by hand. Route anything below your confidence cutoff to a person before it touches payments.
Cloudflare released a preview of Clairic on October 19, a model that reads documents such as invoices and returns typed values instead of written answers. It costs $0.10 per million input tokens, with no charge for output. If you pay a chatbot-style model to pull totals out of documents, this is a cheaper tool built for that job. Help Net Security also reported the release.
\nA request holds the text to read, plus up to four images, and the fields you want back, each with a type: text, number, date, duration, list, estimate or forecast. Clairic answers every field in one pass and generates no tokens, which is why Cloudflare charges only for input and says replies typically take under a second.
\nEach answer carries a confidence score and p_null, the model’s estimate that the value is missing. Missing values come back as null rather than a plausible guess. In Cloudflare’s own example, an email with no tracking number returned null for that field, even though the model’s next best guess was the tax amount, “$52.10”, at 0.42 confidence.
That matters because invoice extraction with a general language model fails quietly. The output looks right whether or not it is. A confidence number per field gives you a place to draw a line between “post it” and “check it”.
\nCloudflare’s model docs run a short sample invoice through six fields. The response reports 655 input tokens: 61 for the invoice text and 472 for the field definitions. So the field list, not the document, drove most of that bill.
\nAt $0.10 per million tokens, a request like that costs $0.0000655, or about 66 cents for 10,000 of them. The Workers AI pricing page counts Clairic at 9,091 neurons per million input tokens and gives every account 10,000 neurons a day free, on both the Free and Paid plans. By our arithmetic that is about 1.1 million tokens a day, or about 1,680 requests the size of Cloudflare’s sample. Real invoices are longer than 61 tokens, so expect fewer.
\nIn a test Cloudflare ran on a damaged-product claim, Clairic extracted the facts in 0.46 seconds against 16.1 seconds for the GLM-5.3 language model. These are the company’s own figures; we found no independent test.
\n@cf/cloudflare/clairic from a Worker or the REST API on the free allocation. An account and an API token are enough.If you have not yet decided whether invoices are the job worth automating first, our one-week tally method answers that before you write any code.
\nSaving every attachment under its own name lost two of three invoices in our 12-email test.
If your office uses Microsoft 365, build the cloud flow with an Is Inline filter and a date-plus-guid file name. New attachments then land in OneDrive without logos or overwrites.
Outlook’s rules can move, flag, forward or delete a message, but none of their actions saves an attachment to a folder. The old fix was a VBA macro, and the new Outlook for Windows doesn’t support VBA. If you still drag invoices out of your inbox by hand, three tools without macros can do it for you.
\nThey are a Power Automate cloud flow, Power Automate for desktop and a short Python script. None costs extra for an office already on Microsoft 365, and each fits a different version of Outlook. Each also faces the same three traps: signature logos that pile up as junk, files with the same name that collide, and names Windows refuses.
\nWe built 12 sample emails with those traps in them and ran them through a naive save and through our script. The naive save quietly lost two of three invoices. Below are the results, the exact settings for each tool, and the limits Microsoft documents for them. All limits and license terms were read on October 19, 2026.
\nMicrosoft’s rules page lists what a rule can do: move a message to a folder, delete it, change its importance, flag it or forward it. Saving an attachment is not on the list. Classic Outlook can run extra rule actions only through third-party add-ins, and the page says “Microsoft doesn’t provide custom action add-ins”.
\nThe answers you will find on old forums use a rule with the “Run a script” action, which calls a VBA macro. That action was switched off by a security update. An answer from Microsoft support staff on its Q&A forum explains how to bring it back with a registry value called EnableUnsafeClientMailRules, and the name tells you what Microsoft thinks of it. It also works only in classic Outlook, because the new Outlook for Windows runs neither VBA nor COM add-ins.
Our view: don’t build anything new on that route. It needs a security setting turned off on every PC that runs it, and it dies the day your company moves to the new Outlook.
\nThe right tool depends on two facts: which Outlook you use, and whether your mailbox is a work account in Microsoft 365.
\n| \n | Cloud flow | \nPower Automate for desktop | \nPython script | \n
|---|---|---|---|
| Works with | \nMicrosoft 365 work or school mailbox, any Outlook version | \nClassic Outlook on a Windows PC; not new Outlook | \nAny Outlook that saves a message as an .eml file | \n
| Cost | \nFree license for work and school accounts | \nFree; personal Microsoft accounts can sign in | \nFree; needs Python 3 | \n
| Runs | \nBy itself when mail arrives | \nWhen you start it | \nWhen you start it | \n
| Saves to | \nOneDrive | \nA folder on the PC | \nA folder on the PC | \n
| Best for | \nNew mail, from now on | \nClearing a full folder in one run | \nMac, new Outlook, the web version | \n
| Main limit | \nSkips messages over 50 MB, or your admin’s lower limit | \nNo ARM PCs; scheduling from the cloud needs a premium license | \nYou save each message by hand first | \n
Many offices will want two of these: the cloud flow for everything that arrives from today, and a one-off sweep for the backlog already sitting in the inbox.
\nWe built 12 sample emails in standard email format (.eml) with Python’s email library, covering what a real inbox throws at a “save every attachment” job.
\nThree vendors each sent a file called invoice.pdf. Two messages carried a signature logo called image001.png, and one held a pasted screenshot. One file name, Q3: \"final\" report?.pdf, used characters Windows refuses. The set also had a forwarded email with a contract inside, a resent duplicate, a Swedish file name with å, ä and ö, and a file called winmail.dat.
First we ran a naive script that saves every named attachment under its own name into one folder. It wrote 12 files, and 8 were left at the end.
\ninvoice.pdf left one file. The invoices from vendors B and C were gone, overwritten without a warning, and the survivor was vendor A’s resent copy.image001.png, and the second overwrote the first. Logos with other names would each add a file.Q3: \"final\" report?.pdf. On Windows, the colon, the quotes and the question mark are all reserved characters, and the save would fail.Then we ran our script, shown in step 3. It saved all 9 real attachments, including the contract inside the forwarded email. It skipped 3 inline images and 1 exact duplicate, and gave every file a name like 2026-10-02_vendor-b.com_invoice.pdf. A second run over the same emails saved nothing and reported 10 duplicates, so running it twice does no harm.
The skipped images include the pasted screenshot. That is the trade-off in the cloud flow and the script below: a filter that drops signature logos also drops images people paste into the body. If your team mails screenshots that matter, keep inline images and delete the logos later.
\nThis needs a Microsoft 365 work or school account. Power Automate’s free license covers it, because both the Office 365 Outlook and OneDrive for Business connectors are standard. The OneDrive connector needs a work or school account, not a personal one. We had no Microsoft 365 tenant in our sandbox, so the steps below come from Microsoft’s connector reference, not from a flow we ran.
\nFrom: invoices@vendor.com.false. It does the same job as the logo filter in our script./Email attachments, set File Content to the attachment’s Content, and set File Name to this expression:concat(formatDateTime(utcNow(), 'yyyy-MM-dd'), '_', guid(), '_', item()?['name'])The date is the day the flow ran, in UTC, and it sorts the folder. The guid() adds a randomly generated 36-character code, so two vendors’ invoice.pdf files can never land on the same name. It makes names long; that is the price of never losing a file. You don’t need to clean the name yourself, because Create file replaces characters OneDrive disallows with _.
The Office 365 Outlook connector reference lists these, and each one can leave a gap or a bad file in the folder:
\nOur view: this is the right default for a Microsoft 365 office. It runs without anyone’s PC switched on, costs nothing extra, and the folder fills as mail arrives. On the free license it can’t be shared, so it lives in one person’s account. Write down whose.
\nPower Automate for desktop drives the Outlook app on your PC, so it can work through a whole folder of old messages in one run.
\nIt needs Windows 10 or 11, Home editions included, and doesn’t run on ARM processors. Its Outlook actions work only with classic Outlook, not the new one. Installing from the Microsoft Store needs no admin rights; the MSI installer does. We had no Windows PC in this run, so we did not test these steps.
\nInbox\\Invoices), and Retrieve to Unread email messages only. Leave Mark as read on.Save attachments and Save attachments into to a folder that already exists. A missing folder stops the flow with “Directory for saving attachments not found”.Move email messages to mail folder, pointing at a folder such as Inbox\\Saved. The next run then can’t pick up the same messages.Microsoft’s reference does not say how this action names files, whether it skips inline images, or what it does when two attachments share a name. Before you point it at a full folder, send yourself two emails that each carry a file called invoice.pdf, plus one with a signature logo, and look at what lands in the folder.
The other catch is the schedule. With a free personal or work account, the flow runs when you press Run. Triggering desktop flows from the cloud needs a premium organization account and Windows Pro or Enterprise. That makes this tool best for the backlog, and the cloud flow better for what arrives next week.
\nThis route works for the new Outlook, Outlook on the web and any computer with Python 3. It is the one we ran end to end.
\nIts weakness is the first step. Outlook on the web saves a message you select through More actions and then Download, as an EML or MSG file in your Downloads folder. The new Outlook uses More actions and then Save as; Microsoft’s page doesn’t name the file type, so check that the files end in .eml. The script reads only .eml files.
\nDownloads/mail.save_attachments.py.python3 save_attachments.py Downloads/mail Downloads/attachments.\"\"\"Save the attachments from a folder of .eml files, skipping inline images.\n\nUsage: python3 save_attachments.py <folder of .eml files> <output folder>\nNames each file YYYY-MM-DD_sender-domain_original-name, never overwrites,\nand skips exact duplicates, so it is safe to run again. Standard library only.\n\"\"\"\nimport sys, re, hashlib, pathlib, email, email.policy\nfrom email.utils import parsedate_to_datetime, parseaddr\n\nBAD = r'[\\\\/:*?\"<>|\\x00-\\x1f]' # characters Windows will not accept in a file name\n\ndef clean(name):\n return re.sub(BAD, \"_\", name).strip(\" .\")[:150] or \"attachment\"\n\ndef is_inline(part):\n disp = part.get_content_disposition() # 'inline', 'attachment' or None\n return disp != \"attachment\" and (disp == \"inline\" or part[\"Content-ID\"] is not None)\n\ndef main(src, out):\n src, out = pathlib.Path(src), pathlib.Path(out)\n out.mkdir(parents=True, exist_ok=True)\n seen = {hashlib.sha256(p.read_bytes()).hexdigest() for p in out.iterdir() if p.is_file()}\n saved = inline = dupes = 0\n for eml in sorted(src.glob(\"*.eml\")):\n msg = email.message_from_bytes(eml.read_bytes(), policy=email.policy.default)\n day = parsedate_to_datetime(msg[\"Date\"]).strftime(\"%Y-%m-%d\") if msg[\"Date\"] else \"undated\"\n domain = parseaddr(msg[\"From\"] or \"\")[1].rpartition(\"@\")[2] or \"unknown\"\n for part in msg.walk():\n if part.is_multipart():\n continue # containers, including forwarded emails\n name = part.get_filename()\n if not name and part.get_content_maintype() == \"text\":\n continue # the message body\n if is_inline(part):\n inline += 1\n print(f\" skip inline {eml.name}: {name or part['Content-ID']}\")\n continue\n data = part.get_payload(decode=True) or b\"\"\n digest = hashlib.sha256(data).hexdigest()\n if digest in seen:\n dupes += 1\n print(f\" skip dupe {eml.name}: {name}\")\n continue\n seen.add(digest)\n target = out / clean(f\"{day}_{domain}_{name or 'attachment'}\")\n n = 2\n while target.exists():\n target = target.with_name(f\"{target.stem}_{n}{target.suffix}\")\n n += 1\n target.write_bytes(data)\n saved += 1\n print(f\" saved {target.name}\")\n print(f\"saved {saved}, inline skipped {inline}, duplicates skipped {dupes}\")\n\nif __name__ == \"__main__\":\n main(sys.argv[1], sys.argv[2])This is its real output on our 12 sample emails, run with Python 3.11 on Linux in under a tenth of a second (three runs took 0.080 to 0.091 seconds):
\n skip inline 01.eml: image001.png\n saved 2026-10-01_vendor-a.com_invoice.pdf\n saved 2026-10-02_vendor-b.com_invoice.pdf\n saved 2026-10-03_vendor-c.com_invoice.pdf\n skip inline 04.eml: image001.png\n saved 2026-10-05_client.com_report.xlsx\n saved 2026-10-06_client.com_Q3_ _final_ report_.pdf\n saved 2026-10-07_leverantor.se_Faktura_åäö.pdf\n saved 2026-10-08_client.com_contract.pdf\n saved 2026-10-12_builder.com_photo.jpg\n skip inline 10.eml: <shot1>\n skip dupe 11.eml: invoice.pdf\n saved 2026-10-15_client.com_winmail.dat\nsaved 9, inline skipped 3, duplicates skipped 1Python’s get_content_disposition() returns inline, attachment or nothing. The script treats a part as an inline image when it is marked inline, or when it carries a Content-ID and is not marked as an attachment, which is how our pasted screenshot arrived. A forwarded email counts as a container in Python’s library, so walk() goes inside it and saves the contract it carries. Duplicates are caught by a fingerprint of the file’s content, so a resent invoice is skipped even under a new subject.
Two limits, both from our run. The script saves a winmail.dat file as it is and does not unpack what it holds. And we ran the script on Linux only. The name cleaning follows Microsoft’s list of reserved characters, but we did not run it on a Windows PC.
Whichever way you pick, a saving job that breaks looks exactly like a quiet week with no invoices. After seven days, count the files in the folder against the emails with attachments in the inbox for the same days. A gap or a broken file points to one of the documented limits: a message over 50 MB, a signed email, an attached email the cloud flow can’t read.
\nIf you are still deciding whether attachments are the job worth automating first, a one-week tally will tell you. Our guide to scheduled scripts that fail silently has the checks that make a broken job speak up, and the weekly report guide uses the same free Power Automate license for its schedule. When the data you need sits in the email text rather than an attachment, our email-to-Excel guide tests three ways to pull it into a table. More guides like this one are under automation.
\nThen put the count in your calendar as a quarterly reminder today, before the folder fills up and nobody remembers what should be in it.
\nAt Anthropic, interactive Claude sessions spend about 80% of their time idle, waiting for a person to respond.
Before you add agents, estimate the reading load: output tokens times 0.75, divided by 250 words a minute. You see the review hours the agents will cost before you commit to them.
The company that makes Claude has measured its own staff, and the slow part of its AI work is now people. In interactive sessions, Anthropic’s agents spend about 80% of their time waiting for a human to respond. If your team is adding agents, that number is the one to plan around. More agents will not help much if nobody has time to read what they produce.
\nThe figure comes from “How employment is changing at Anthropic”, a report published on October 16 by four researchers at the Anthropic Institute. It draws on the company’s internal data on hiring, AI use, output, surveys, calendars and Slack, plus 17 employee interviews. Most coverage, including ANI’s, led with the junior-hiring numbers.
\nWe think the more useful part for a smaller company is how the work itself changed. Below is what happened, why it happened and what to take from it.
\nBy August, agents directed by individual employees at Anthropic worked six times as many hours as the people handling them, according to the report. That count covers only employee-directed interactive sessions, and it assumes each person works 40 hours a week.
\nOutput rose too. Code commits per engineer reached five times their pace of six months earlier.
\nThe gains reached sales too. One account executive said Claude automations took over around 20% of their previous tasks, such as drafting emails. Another said similar automations let them talk to 30% more of their customers.
\nQuality is the obvious worry. The report compared code written by an agent with code written by hand by the same person, in the same month and the same directory. It found no difference in how often the lines were later removed or reverted.
\nThe researchers add a caution: AI errors may be harder to spot than human ones. So “no difference” here means no difference on the proxies they could measure.
\nFaster agents create a new problem. Somebody has to read and answer them. One engineer described facing “an army of Claudes, with every one asking for my attention.” Another said people are “bottlenecking the agents.”
\nThe report puts a size on it. It converted each session’s output into reading time, at 0.75 words per token and 250 words a minute. Even for non-technical teams, reading everything their interactive sessions produced would take over half the work week.
\nThe load also keeps climbing. After new model releases, staff hand agents harder work: the share of tasks above the old model’s 90th percentile of difficulty rose from 10% to 13%.
\nSo the 80% idle figure is not a sign of lazy software. It is a queue. The agent has finished its part and is waiting for a person to look, decide and send it on.
\nPeople at Anthropic responded by building tools to manage their agents. The report calls it “meta-work”: writing specs for multi-agent runs, setting one agent to review another, and watching pipelines. It grew from 10% of the average employee’s interactive sessions in fall 2025 to 22% in spring 2026.
\nWritten standing instructions for agents grew from a few hundred in July 2025 to 8,500 a year later. One engineer set up an agent “chief of staff” to sort incoming agent requests. Another wrote a performance review for their team of Claudes.
\nThe trade-off is plain. That time comes out of the work itself. A fifth of a person’s agent sessions spent on tooling is time they are not spending on customers or code.
\nYou might expect agents to cut meetings. The opposite happened. Based on calendar data, the median Anthropic employee spends 20% more time in meetings than a year ago, and technical individual contributors 16% more. The report says part of that is company growth and a shift toward roles that meet more.
\nAgents also joined the conversation. They now appear in nearly half of Anthropic’s active public Slack channels. Human threads kept the same number of human replies, with agent replies layered on top.
\nThat creates a new rule of thumb. Agents only know what is written where they can read it. One employee’s name stayed on a months-old document about company swag, so agents kept sending them requests for t-shirts and mugs long after the job had moved on. The report puts it bluntly: private work in unlogged meetings and direct messages “is invisible, confusing and discouraged in an AI-heavy workplace.”
\nThe hiring data is the starkest part. The junior share of Anthropic’s technical hires fell from 27% to 9%. The junior share of staff in technical departments fell from 21% to 14% since early 2025. In an April 2026 survey, around a third of machine learning managers and a fifth of software engineering managers said they were hiring less because of AI.
\nWhat managers look for changed too. In 2024, interview scorecards mentioned a candidate’s record with AI tools in about 5% of technical assessments and 7% of non-technical ones. By 2026 those rates had tripled and quadrupled. For technical candidates, the biggest increases were comments on autonomy and judgment, while domain expertise shrank as a share.
\nThe authors name the gap in their own response. Anthropic tracks roles at risk and moves people between teams, but “employment protections for incumbents will not benefit those not hired to begin with.”
\nThis is a vendor studying its own use of its own product, and that deserves weight. Anthropic tripled in size in the last year, so some of its output growth may have come from business growth alone. The authors say so, and add that “tool adoption is not random.” Engineers who took up fully autonomous agents were already on a steeply rising trajectory before they did.
\nThe report also says many of Anthropic’s practices, including wide stock ownership, “cannot be replicated across the economy.” A ten-person firm is unlikely to have 8,500 standing instructions or a research team counting idle minutes.
\nWhat carries over is the mechanism. Agents produce faster than people can read, and the cost shows up as review time, tooling time and meetings.
\nThe decision most teams face is whether to add more agents or make better use of the ones they have. Anthropic’s data says the limit will be your people’s attention, so plan for that first.
\nThe trade-off cuts both ways. More review keeps quality up but caps how much the agents deliver. Less review frees people but lets more errors through, and the report warns those errors may be harder to see.
\nAt Anthropic, the agents are already waiting on people 80% of the time. That is the number to check in your own team before you add the next one.
\nRead this next to our news piece on Workers and Pages. Static files upload with the Worker, a request that matches a file is served without running any Worker code, and the page covers single-page app fallbacks, custom 404 pages and run_worker_first for the paths where your code should go first.
Link: developers.cloudflare.com
", "summary": "Read this next to our news piece on Workers and Pages. Static files upload with the Worker, a request that matches a file is served without running any Worker code, and the page covers single-page app fallbacks, custom 404 pages and run_worker_first for the paths where your code…", "date_published": "2026-10-18T23:10:00.000Z", "date_modified": "2026-10-18T23:10:00.000Z", "authors": [ { "name": "28creation Desk", "url": "https://28creation.com/authors/desk/" } ], "tags": [ "Developer tools" ] }, { "id": "https://28creation.com/articles/cloudflare-workers-over-pages/", "url": "https://28creation.com/articles/cloudflare-workers-over-pages/", "title": "Cloudflare sends new projects to Workers; static sites stay free", "content_html": "Cloudflare's own docs now tell new projects to start on Workers, not Pages.
If you start a site now, create it as a Worker, not a Pages project. Static hosting stays free, and you skip a migration later.
Cloudflare’s documentation for Pages, its hosting product for static sites and frontends, now tells readers to use something else. The Pages overview says Workers “supports most Pages use cases and offers a broader feature set” and ends: “Start new projects with Workers.” A site on Pages keeps running. New features go to Workers, and moving does not change what static hosting costs.
\nCloudflare set this course in April 2025. It said then that Pages “will continue to be supported”, but “all of our investment, optimizations, and feature work will be dedicated to improving Workers.” Now the advice sits on the Pages docs themselves, and the migration guides page opens it with “Are you sure you want to use Pages?” Neither page gives Pages an end date.
\nA Worker can host a static site on its own. The files deploy with the Worker, and a request that matches a file is served without running any Worker code.
\nThe price is the same. Cloudflare’s pricing page says requests to static assets “are free and unlimited”. Pages Functions “are charged at the same rate as Workers”, says the migration guide. The limits match as well: 20,000 files on the free plan, 100,000 on paid plans and 25 MiB per file, for both Workers and Pages.
\nThe guide’s compatibility matrix marks Cron Triggers, Queue consumers, Workers Logs, rate limiting and gradual deployments as Workers-only. Durable Objects, which on Pages need a separate Worker to bind to, work directly.
\nSome things get harder. Branch deploy controls are less configurable on Workers, and file-based routing from a functions/ folder has to be compiled with Wrangler first.
The real gap is DNS. “Unlike Pages, Workers does not support any domain whose nameservers are not managed by Cloudflare,” the guide says. If your domain’s DNS sits with your registrar, moving means moving DNS to Cloudflare first, or staying on Pages.
\nMost of the work happens in the Wrangler config file. The Pages setting pages_build_output_dir becomes assets.directory. Pages guessed your 404 behavior from index.html and 404.html; Workers wants not_found_handling set to single-page-application or 404-page, “to prevent accidental misconfiguration”. Locally, wrangler pages dev becomes wrangler dev, and the port moves from 8788 to 8787.
One change can catch you out. Pages ran Functions before static assets by default, while Workers “will default to serving static assets ahead of your Worker script.” If your code checks logins or logs requests before a file is served, set assets.run_worker_first.
That setting has a cost. Requests that match it “will always invoke your Worker script”, so they are billed. The free plan allows 100,000 requests a day, and past that those requests get a 429 error “instead of falling back to static asset serving.”
\nOn January 16, 2026 Cloudflare announced that the company behind Astro is joining it. The post describes local development running in “workerd, the open-source Cloudflare Workers runtime” and never mentions Pages. Cloudflare and Astro both say the framework stays MIT-licensed and keeps supporting other hosts. Disclosure: this site is built with Astro and hosted on Cloudflare.
\n_routes.json and middleware. The guide says to review the request order if you used either. Decide whether you need run_worker_first, and count the billed requests it adds.preview_urls to true and test on a preview link. Then turn off automatic deployments on the Pages project, add your domain to the Worker, and delete the Pages project last with npx wrangler pages project delete.Nothing on either page forces an existing site to move. Move it when you need something on the Workers-only list, and start the next one on Workers.
\nKnight Capital lost more than $460 million in about 45 minutes, after 97 warning emails nobody acted on.
Feed any workflow tool a missing field, a duplicate record and a wrong file format before you sign. If it does not stop and tell a named person, keep it away from money.
On August 1, 2012, a trading router at Knight Capital sent millions of unwanted orders into the US stock market in about 45 minutes, and the firm lost more than $460 million. The SEC’s order traced it to nothing exotic: old code nobody had deleted, a manual update nobody checked, and 97 warning emails nobody acted on.
\nThat pattern runs through two other public failures, and it scales down to a ten-person office. So a small company buying workflow software should pick the predictable, legible tool over the clever one. Legible means a person can see what the tool did and why.
\nThe automation that does damage changes without asking, hides how it reached its answer, or is right so often that people stop checking. Below are the three cases, the research on how people supervise machines, and five tests to run on any tool before you sign.
\nKnight’s router, called SMARS, still carried a feature named Power Peg that the firm had stopped using in 2003. The code stayed on the servers, “present and callable.” In 2012, Knight wrote new code for a New York Stock Exchange retail program and reused an old switch: a flag that used to turn Power Peg on.
\nStarting July 27, Knight copied the new code onto the router’s eight servers in stages. A technician missed one of them. Knight had no second person review the work, and no written procedure required one.
\nOn August 1, orders carrying the reused flag reached the eighth server and woke Power Peg up. From 212 small customer orders, it produced more than 4 million executions in 154 stocks. By the time it stopped, Knight had taken on positions worth about $3.5 billion long and $3.15 billion short.
\nThe warnings were there. From 8:01 a.m., an internal system sent 97 emails flagging an error called “Power Peg disabled” to a group of staff before the market opened at 9:30. Knight had not designed them as alerts, and staff generally did not read them.
\nThere was no procedure to halt the router when it misbehaved, either. One attempted fix, removing the new code from the seven healthy servers, made things worse. The SEC later fined Knight $12 million on top of its losses.
\nNone of those failures called for a smarter system. They called for a change someone could verify, a warning that reached a person, and a way to stop. Swap the trading router for an invoice approval flow and the shape is familiar: an old rule nobody deleted, an edit made by one person, error emails landing in a shared inbox.
\nThe UK Post Office began rolling out its Horizon IT system to branches in about September 1999. Bugs in it could show losses in a branch’s accounts that never happened. The public inquiry found that some Post Office staff “knew or, at the very least, should have known” this, yet the organization “maintained the fiction that its data was always accurate.”
\nThe people running the branches, called subpostmasters, had almost nothing to argue with. In 2019 the High Court found that their transaction logs were available for only 42 days, later 60, and could be printed on till rolls (Horizon Issues judgment, paragraph 999). With so little data, they “simply could not identify apparent or alleged discrepancies and shortfalls, their causes,” the judge wrote. He called the Post Office’s stance “the 21st century equivalent of maintaining that the earth is flat.”
\nThe inquiry’s first report, published in July 2025, estimates that about 1,000 people were prosecuted and convicted on Horizon evidence. Many thousands of people were held responsible, wrongly, for losses that were illusory.
\nThe scale was national, but the mechanism is ordinary. When the people using a system cannot see why it says what it says, the system wins every argument by default. In a small company the argument is smaller: a customer disputing a late fee, an employee questioning a payroll figure. You still need to show what happened.
\nBefore the third case, a prediction. In a 1993 experiment, people juggled a tracking task and a fuel-management task by hand while an automated system watched engine gauges for them. Sometimes the automation missed a fault. Guess what share of those misses people caught when the automation had been steadily reliable all session.
\nIt was 33%. When the automation’s reliability varied over time, people caught 82%, according to a 2010 review by Parasuraman and Manzey. When watching the automation was their only job, detection was near perfect. The trouble starts when other work competes for attention, which describes most small businesses on most days.
\nThe review has worse news for anyone counting on training. Complacency showed up in experts as well as novices and “cannot be overcome with simple practice.” Automation bias, following a machine’s advice against other evidence, “cannot be prevented by training or instructions.”
\nIn one simulator study the review cites, 75% of pilots followed an automated checklist that told them to shut down the wrong engine. With a paper checklist, 25% did.
\nOn July 19, 2024, at 04:09 UTC, CrowdStrike sent a configuration update to its Falcon security software for Windows. It pulled the update at 05:27 UTC, according to its preliminary review. Windows machines running version 7.11 or later of the software that were online in those 78 minutes, and received the update, crashed. Microsoft estimated that 8.5 million Windows devices were hit, “less than one percent of all Windows machines.”
\nThe bug was small. A detection template defined 21 input fields, while the code feeding it supplied 20, and the new content was the first to read the 21st (root cause analysis). The tests had used a wildcard in that field, so they never touched it.
\nWhy did it ship? CrowdStrike’s review names earlier testing, “trust in the checks performed in the Content Validator,” and “previous successful” deployments of the same kind. That is the complacency result, at company scale. A process that had worked several times was trusted to work again.
\nThe fixes CrowdStrike announced are the boring ones. Its root cause analysis concludes that each such update “should be deployed in a staged rollout,” starting with a canary, meaning a small group gets it first. Customers can now choose “where and when” these updates land.
\nFor this piece, clever mostly means an AI step, such as a model that reads incoming email or drafts a reply. Those steps are useful, and by design they carry both risks above. OpenAI’s own documentation says its chat completions “are non-deterministic by default (which means model outputs may differ from request to request).” It also warns that determinism may change “due to necessary changes OpenAI makes to model configurations on our end.”
\nRead that as a buyer. The same input can produce a different output, so explaining a past run gets harder, which was the Horizon problem. And the behavior can shift on the vendor’s schedule, which was the CrowdStrike problem.
\nNone of this argues for avoiding smart tools, and predictable has real costs. Rule-based tools need someone to write and maintain the rules. They also handle messy input badly: a customer who buries the order number in the third paragraph of a free-text email will beat most rules.
\nStaged rollouts cost speed as well. CrowdStrike’s fast-track content exists so its software can respond to new threats “at operational speed,” and a canary stage slows that down. Some of the time, waiting is the risk.
\nOur view is that the trade is worth making for anything that touches money, customers or staff records. Let the clever part do the reading, then hand its result to a plain, logged step a person can inspect. Require a human yes before anything leaves the building. Put the cleverness in a box with clear edges, and make the box easy to open.
\nIt is tempting to spend a trial clicking through features. Spend one afternoon of yours trying to break the tool instead. Each test below maps to one of the cases above.
\nA tool that passes all five has earned a look at its feature list. One that fails any of the first three should not touch money or customers, however good the demo was.
\nKnight’s warnings arrived between 8:01 and 9:30 that morning, 97 of them, each naming the broken feature. The cheapest test on this list asks whether your tool would have put the first one in front of someone who reads.
\nIn Microsoft's survey, 78% of people who use AI at work bring their own tools; at smaller firms, 80%.
Send each shortlisted vendor the six questions in writing, starting with whether your data trains their models. You get answers tied to a contract or a setting, not a sales-call promise.
In Microsoft’s 2024 Work Trend Index, 78% of people who use AI at work said they bring their own AI tools. At small and medium-sized companies, the share was 80%. That matters because the same vendor can write very different rules for a personal account and a business one.
\nAnthropic is a clear case. Its consumer plans keep chats for five years if the user allows them to be used for training. Its business plans don’t use inputs or outputs for training by default.
\nSo the first decision is which terms your team’s words fall under. Features come second. This guide gives six questions to put to a vendor in writing. For each, it shows what a good answer looks like, quoting four vendors’ published policies.
\nThen it lays out a two-week trial on real work and the five numbers worth measuring before anyone signs.
\nWrite down the five to ten tasks your team actually wants help with, in tedious detail. “Writing” is useless. “First drafts of replies to support emails” is useful, and so is “a summary of a 40-message client thread before a call”.
\nRank the list by how often each task happens. The top three become your trial. A tool that is brilliant at something you do twice a year is a worse buy than one that is merely decent at something you do every morning.
\nBefore you pick anything, find out which tools are already in use, and on which accounts. Ask without blame. Microsoft’s survey also found that 52% of people who use AI at work are reluctant to admit using it for their most important tasks. A survey that sounds like an audit will get polite answers.
\nThe answers tell you where your data sits today. Google’s privacy hub for the Gemini app says human reviewers, including trained reviewers from its service providers, review some chats. Reviewed chats are kept for up to three years, and the page asks users not to enter confidential information they wouldn’t want a reviewer to see.
\nThe same page says work and school accounts may have different terms. That difference is what the next three steps check.
\nPut the six questions below to every vendor in writing. Expect answers that point to a contract, a policy page or an admin setting. A promise on a sales call is worth what you paid for it.
\nQuestion 1: Is our input or output used to train or improve your models, and is that the default? A good answer is a plain no, in writing, with the exceptions named. As of October 2026, the large vendors’ business offerings put it like this:
\nNow look for the exception in the feedback buttons. Anthropic says a thumbs up or down stores the entire related conversation for up to five years. It may use that feedback to train its models. Owners of Team and Enterprise plans can switch feedback off for everyone, under Data and Privacy in the organization settings.
\nQuestion 2: Who at your company can read our content, and when? A good answer is specific. Microsoft says its Copilot services have opted out of abuse monitoring in Azure OpenAI, the process that includes human review of content.
\nQuestion 3: How long do you keep prompts, files and outputs, and who sets that? A good answer gives a number and lets an admin change it. Google Workspace keeps Gemini conversations for 90 days to indefinitely, as set by admins. On Anthropic’s business plans, deleted conversations leave its back end within 30 days. Microsoft lets admins set Copilot retention in Purview, and users can delete their own Copilot history.
\nShort retention has a cost of its own. People lose the history they search when they want last month’s draft, so agree on the number before the trial, not after.
\nQuestion 4: Where is our data processed, and which features are exceptions? Ask for the list of exceptions, because that is where the surprises sit. Microsoft keeps EU users’ Copilot traffic inside its EU Data Boundary, but Anthropic models used inside Copilot are currently excluded. Web searches are another carve-out: those queries go to Bing, where Microsoft acts as an independent data controller and the EU Data Boundary doesn’t apply.
\nOpenAI’s API offers data storage in 10 regions but in-region processing only in the US and Europe, plus the UAE for some models. One product can hold several sets of terms. An EU team that wants everything inside the boundary has more than one switch to check.
\nQuestion 5: What can the assistant see once it is connected to our email and files? The standard answer is only what the user can already see. Microsoft Copilot surfaces only data the user has at least view permission for, and Gemini won’t retrieve a document or email the user can’t access.
\nThat sounds safe. It also moves the risk to your own sharing settings. Picture a hypothetical salary sheet shared with the whole company years ago and forgotten: anyone can now ask the assistant about it. Before you connect anything, search your drive for files shared with everyone and tighten them.
\nQuestion 6: Which contract covers our use, and are you our data processor? A good answer names the document. Microsoft says organizational use of Copilot is covered by its Data Protection Addendum, with Microsoft acting as data processor. If a vendor can’t name the document, take that as the answer.
\nOne page, two lists. The first says what may go in: internal drafts, public information, your own notes. The second says what may not, at least until the vendor’s answers check out: customer personal data; passwords and keys; unreleased figures; anything under a confidentiality clause.
\nName one person who answers “can I paste this?” People will ask at five to five with a deadline at five, and a quick answer from a named human beats a policy nobody has opened.
\nIn the EU, the page also does legal work. Article 4 of the AI Act, on AI literacy, has applied since February 2, 2025. The Commission’s own Q&A takes the case of a company whose staff use ChatGPT to write ad copy or translate. Its answer: they should be informed about the specific risks, for example hallucination.
\nThe duty is lighter than it sounds. No certificate is needed; a company can keep its own internal records of training instead. The Digital Omnibus on AI, in force since July 2026, keeps the obligation but no longer sets a “sufficient” level. National market surveillance authorities supervise it from August 2026.
\nA dated rules page and a 30-minute briefing on where the tool gets things wrong make a sensible record.
\nTest two candidates at most, or one against the way you work now. More than that and the trial turns into a hobby.
\nThe log needs six columns:
\n| Date | \nTask | \nUsual minutes | \nMinutes with the assistant, fixes included | \nOutcome: used, edited or binned | \nErrors found | \n
|---|
Self-reported minutes are rough, but they are good enough to compare two tools used by the same people on the same kinds of task.
\nAn assistant that saves one enthusiast ten minutes a day and nobody else anything is a personal tool. Buy it as one.
\nWrite down the tool, the tasks it is for and the house rules it runs under. Add who administers it and who removes accounts when people leave. Set a review date three months out, when you look at usage again and decide whether to keep paying.
\nSend the six questions to your shortlisted vendors today, and start the task list while you wait for their answers.
\nIf your team uses Google Workspace or Microsoft 365, a scheduler that sends the weekly report already comes with it.
Put a check cell beside each key number that flags a week with no data, and include it in the email. A failed import then reaches everyone instead of passing as a quiet week.
If your team works in Google Workspace or Microsoft 365, a scheduler that can send the weekly report on its own already comes with it. Data Studio, the tool Google used to call Looker Studio, emails a report as a PDF on a timer. Power Automate runs a flow every week, and its free license covers work accounts at no extra cost.
\nThe timer is the easy part. What breaks these reports months later sits in the fine print. A trigger may fire at a random minute within the hour. A schedule may run on one person’s login and fail once they leave.
\nA broken automated report rarely looks broken. It looks like a quiet week. The nine steps below set up the schedule and put a guard on each weak point. Most need no code at all; one option needs six lines.
\nBuild the report by hand one more time and write down every step. Each export counts, each copy and paste, each “then I check whether sales has sent its numbers”. That list is your specification. It will be longer than you expect.
\nFor every number, add two facts: where it comes from and when it is final. “Invoices sent: accounting export, final Friday 06:00” is a useful line. “Revenue: from the system” is not.
\nThen ask who reads each section and what they decide because of it. Delete what nobody reads. A section with no reader is cheaper to remove today than to automate, schedule and maintain for the next several years. Our payback template puts hours on that upkeep before you build.
\nAll five options below can run once a week. They differ in what they can read and in how they fail.
\n| Your setup | \nScheduler | \nCode? | \nThe limit to know, as of October 2026 | \n
|---|---|---|---|
| Google, report is charts | \nData Studio scheduled delivery | \nNone | \n50 recipients; without Pro, one schedule per report and at most daily | \n
| Google, report is a sheet | \nWorkspace Studio flow | \nNone | \nBusiness Starter and up; an admin must turn on Gemini | \n
| Google, custom logic | \nApps Script trigger | \n6 lines | \n90 trigger minutes a day on a personal account, 6 hours on Workspace | \n
| Microsoft 365 | \nPower Automate Recurrence | \nNone | \nFree license: standard connectors only, and flows can’t be shared | \n
| Mixed tools | \nZapier Schedule | \nNone | \nFree plan: 100 tasks a month, two-step Zaps | \n
Our view: start with the suite your team signs in to every morning. A second platform means another login and another place to look when something fails.
\nZapier earns its place when the numbers live in tools Google and Microsoft can’t reach. Its free plan allows only two-step Zaps, one trigger and one action.
\nA Zap that reads a sheet and then emails it needs a trigger and two actions. That means Professional, at $19.99 a month billed annually for 750 tasks as of October 2026. The schedule trigger itself doesn’t count toward task usage. For what a longer workflow costs on Zapier, Make and n8n, see our pricing of one workflow on all three.
\nGive each source its own raw tab, filled only by an import or by someone pasting that source’s export. Then make one report tab that calculates everything the report shows: totals, change since last week, distance to target. No typed numbers on that tab. A typed number goes stale, and nobody knows when.
\nProtect the report tab so a helpful colleague can’t type over a formula. In Google Sheets, open Data, then Protect sheets and ranges, and pick Restrict who can edit this range. Google says protection shouldn’t be used as a security measure, so treat it as a guard against accidents.
\nOn Microsoft 365, format each raw range as an Excel table, because Power Automate’s Excel actions work on tables. Its List rows present in a table action returns up to 256 rows by default unless you turn on pagination. Without that switch, a report that grows past 256 rows comes out short and says nothing.
\nNext to each key figure, add a cell that flags data you shouldn’t trust. Two checks cover the failures that look most like a normal week: nothing arrived, or something jumped.
\n=IF(COUNTIFS(Raw!A:A,\">=\"&B1,Raw!A:A,\"<\"&B1+7)=0,\"NO DATA\",\"OK\"), where column A of the Raw tab holds dates and B1 holds the Monday of the reporting week.=IF(ABS(C5/D5-1)>0.5,\"CHECK\",\"OK\"), where C5 is this week and D5 last week. If last week was zero, the cell shows an error, which is also worth a look.Color the flags with Format, then Conditional formatting, then Custom formula is. Google notes that these formulas can only reference the same sheet unless you use INDIRECT, so keep the check cells on the report tab. Then include them in the message itself. A failed import should land in front of everyone, including the people who never open the sheet.
\nEach set of steps uses the vendor’s own menu names.
\nfunction sendWeeklyReport() {\n const ss = SpreadsheetApp.getActiveSpreadsheet();\n const rows = ss.getSheetByName('Report').getRange('A1:B12').getDisplayValues();\n const body = rows.map(r => r.join(': ')).join('\\n') + '\\n\\n' + ss.getUrl();\n MailApp.sendEmail('team@example.com', 'Weekly report', body);\n}It mails the report tab’s cells as displayed, check cells included, with a link to the sheet. Run it once from the editor before you add the trigger, because triggers must be authorized by the person who created them. MailApp can reach 100 recipients a day from a personal account and 1,500 from Workspace.
\nTimers are looser than they look. Apps Script says a trigger’s time might be slightly randomized. One set for 9 a.m. runs at a time it picks between 9 and 10, then keeps that time day to day. Zapier says its schedule should run within a few minutes of the set time.
\nTime zones are the other trap. Zapier uses your Zapier account’s time zone and shows run times in UTC in Zap history. Change the zone, and you must turn the Zap off and on again.
\nData Studio follows your operating system’s time zone, and you can’t change it inside Data Studio. Power Automate asks for a start time in a UTC format plus a separate Time zone field, so set that field.
\nSo if a source is final at 06:00, schedule for 07:30 rather than 06:05. Buy yourself the hour. Check the first run after the clocks change for daylight saving time.
\nOne more surprise for teams outside the US: Data Studio’s scheduled reports use US English formatting even if your account is set to another language. Read 10/03 as October 3.
\nThe automation can fetch and add up. It can’t write the two sentences that say revenue dipped because two large invoices slid into next week. So send the finished report to one owner at 07:30, and let them add that comment and forward it by 09:00.
\nThe owner is also where failures should land, and each tool raises them differently. When a trigger fails, Apps Script shows nothing on screen and sends an email with a link to reconfigure or switch it off. Power Automate turns off a cloud flow whose trigger or actions fail continuously for 14 days. If those alerts go to an inbox nobody reads, the report simply stops one Friday.
\nKeep building the report by hand and compare the two, number by number. A comparison tab makes it quick: =IF(Report!C5=Manual!C5,\"\",\"DIFF\") in each cell that matters.
Every difference is a bug in one of the two versions. Expect some in the manual one. Switch off the hand-built report only after three weeks in a row with no differences you can’t explain.
\nMost schedulers run as a person, not as the team. Apps Script triggers always run under the account of the person who created them. A flow built on Power Automate’s Free license can’t be shared at all.
\nData Studio schedules run with the credentials of whoever last saved them. When that account goes inactive, the schedule fails until an active editor opens it, clicks Edit and saves. Until then, nothing arrives.
\nWrite a short note at the top of the sheet. Say which account runs each schedule and who owns the report, then what to do when a check cell turns red. Add one line to your offboarding checklist: move or re-save every schedule the leaver owns before their account is closed.
\nStart with step 1 this Friday. Build the report by hand one last time, with a blank document open beside it, and write down every click.
\nPeople's estimates of their own screen time matched device logs within 5% in only 3 of 49 comparisons.
Have one volunteer keep a tally sheet by the keyboard for five days, with a tick each time a task repeats. You get counts instead of guesses, and a clear first task to automate.
In a 2002 study, 209 students at Texas A&M wore a wristwatch that chimed every hour and wrote down what they were doing and thinking. About 43% of what they recorded were habits, things done almost daily in the same place, and while doing them their minds were more often somewhere else.
\nOffice work runs on the same machinery, and that is why the hardest part of automating it is noticing what to automate. Asking a team what to automate relies on memory, and memory is least reliable for the small tasks people repeat all day. By the time a task is frequent enough to be worth automating, it has often become a habit.
\nThat gap matters for anyone who runs or builds software for a small company, because the opportunity sits in exactly those small tasks. This piece explains why people miss their own repetition, why the small tasks make the best first projects, and how to run a one-week tally that finds them.
\nThe study, by psychologists Wendy Wood, Jeffrey Quinn and Deborah Kashy, defined a habit plainly: something done just about every day, usually in the same location. In the first study, 70 students kept the hourly diary for one day and 35% of the behaviors they listed were habits. In the second, 209 students kept it for two days and the figure was 43%.
\nWhat happened in their heads was the striking part. In the first study, for 60% of the habits people recorded, they were thinking about something unrelated. For less routine actions, their thoughts matched what they were doing in 70% of cases.
\nOverall, the authors estimate, their participants did almost 50% of everything without thinking about it. The sample was college students, and the authors note that the figure could be a lower bound, since students may spend more of the day on study and new activities than other people. Nobody was told the study was about habits until the debriefing.
\nNow apply the definition to an office. Copying an order number from the web shop into the accounting system meets it. So do the same lookups before every customer call. Both are done almost daily in the same place, which by the study’s definition makes them habits.
\nThe usual way to find automation candidates is to ask: interviews, workshops, a process map on a whiteboard. All of them depend on people reporting their own behavior, and that is a weak instrument.
\nSome of the best evidence comes from screen time, where self-reports can be checked against device logs. A 2021 meta-analysis led by Douglas Parry pooled 47 studies covering about 50,000 people. Guess how often people’s average estimate of their own use came within 5% of the log. It happened in 3 of 49 comparisons, about 6%.
\nThe errors ran both ways: people over-reported in 23 comparisons and under-reported in 23 (Parry et al.). The overall correlation between what people said and what the logs showed was 0.38, which the authors call only medium in magnitude. They note that memory problems are most apparent for behavior that is frequent and woven into daily life. That is the profile of an office habit.
\nUser researchers learned this long ago. Jakob Nielsen’s 2001 essay on the first rule of usability tells designers to “pay attention to what users do, not what they say.” Watching people work in their own setting, the method called contextual inquiry, can “uncover low-level details that have become habitual and invisible,” as Nielsen Norman Group puts it.
\nAsk how someone handles a supplier invoice and you hear the process. Watch the next one arrive and you see the work.
\nThe research on what can be automated points at the same small tasks. In 2017 the McKinsey Global Institute estimated that less than 5% of occupations could be fully automated with technology already demonstrated. Yet about half of all the activities people are paid to do could be, worth almost $15 trillion in wages. The activities it rated most exposed included data collection and processing.
\nMcKinsey raised that figure in 2023. With generative AI, it estimated that work taking up 60 to 70% of employees’ time could technically be automated. That is a theoretical ceiling: McKinsey’s adoption scenarios put the halfway point somewhere between 2030 and 2060. The same report recalls a 2012 MGI estimate that knowledge workers spent about a fifth of their time, one day a week, searching for and gathering information.
\nSurveys of workers point the same way. Asana’s Anatomy of Work Index says people spend 60% of their time on “work about work,” such as searching for information, switching between apps and chasing the status of tasks. It puts duplicated work at 209 hours a year per knowledge worker.
\nTwo cautions apply. Asana sells work-management software, and its figures are self-reported, the kind of measurement the Parry study warns about. Read the shares as a direction rather than a measurement. Taken together, the sources point one way: the time worth winning back is scattered across small tasks inside jobs.
\nA small, frequent task usually follows a narrow rule, uses input that keeps its shape, and has one obvious owner. A mistake costs little and shows up fast. The big process everyone named in the workshop has the opposite profile: many people, many exceptions and rules nobody wrote down.
\nThe arithmetic also favors the small task. Randall Munroe’s chart Is It Worth the Time? works out how long you can spend making a routine task faster before you lose time over five years. Shave one minute off something done five times a day and you can spend six days on the automation. Shave 30 seconds off something done 50 times a day and the budget is four weeks.
\nThe chart counts 24-hour days and no upkeep; our recomputed xkcd table uses a working year and subtracts the hours spent keeping an automation running.
\nSmall automations have costs too. Each one is another thing that can break, and ten of them without owners is a mess of its own. Some repetition should be deleted rather than automated, such as a status report nobody reads.
\nWatching people work raises fair questions about consent, especially when software does the watching. A tally kept by the person themselves avoids most of that. Our explainer on task mining and process mining sets out what regulators say about software that records screens.
\nThe tally takes a pen, a sheet of paper and five working days. It replaces estimates with counts, which is the whole point.
\nThen wait a month and run the tally again. Once the loudest repetition is gone, the next one is easier to hear.
\nThe students in the 2002 study learned what the research was about only at the end. What they did on autopilot became visible because a watch chimed every hour and asked. A sheet of paper by the keyboard can do that job in an office.
\nAstro’s own walk-through of its built-in Fonts API, and a good one. Register a font in the project config with a provider like Fontsource or Google, or point it at local files, then put the <Font /> component in the page head, and the fonts get downloaded and served from your own site. Read the part on preloading and fallback settings if layout shift has ever annoyed you.
Link: docs.astro.build
", "summary": "Astro's own walk-through of its built-in Fonts API, and a good one. Register a font in the project config with a provider like Fontsource or Google, or point it at local files, then put the component in the page head, and the fonts get downloaded and served from your own site.…", "date_published": "2026-10-18T20:45:00.000Z", "date_modified": "2026-10-18T20:45:00.000Z", "authors": [ { "name": "28creation Desk", "url": "https://28creation.com/authors/desk/" } ], "tags": [ "Developer tools" ] }, { "id": "https://28creation.com/articles/tiny-automation-in-code/", "url": "https://28creation.com/articles/tiny-automation-in-code/", "title": "Scheduled scripts fail silently; seven checks make them speak up", "content_html": "In 2017 GitLab lost about six hours of data: its backups had been failing, and the alert emails bounced.
Add a ping after each successful run to a dead man's switch on another machine, such as Healthchecks.io's free plan. If the script fails or stops running, you get an alert.
On January 31, 2017, an engineer at GitLab.com wiped a database directory on the primary server, “errantly thinking” it was the secondary. The storage bucket meant to hold the backups was empty, and GitLab lost about six hours of data. Its backup job, set to run every 24 hours, had been failing, and the alert emails it sent were rejected by the receiving server.
\nGitLab’s own summary: “we were never aware of the backups failing, until it was too late.” That is the risk in every scheduled script. It runs where nobody watches, so a failure stays silent unless someone builds it a voice.
\nWe think that is where most of the effort in a small automation belongs, and a 34-line script that chases late invoices shows why. The checklist at the end works for any script you schedule.
\nA hypothetical small company’s accounting system drops a CSV export of invoices into a shared folder every night. The columns are number, customer, amount, due and status. Someone opens it each morning, sorts by due date and tells the team about anything late, except on busy days.
The script below does that every weekday at 08:00 and posts to the team chat through an incoming webhook. It runs on Node.js 22 or newer, with no packages.
\n// overdue.mjs: post overdue invoices from a CSV export to a chat webhook.\n// Expects columns number,customer,amount,due,status, with due as YYYY-MM-DD\n// and no commas inside fields.\nimport { readFile } from 'node:fs/promises';\n\nconst file = process.argv[2] ?? 'invoices.csv';\nconst webhook = process.env.WEBHOOK_URL;\nif (!webhook) throw new Error('WEBHOOK_URL is not set');\n\nconst today = new Date().toISOString().slice(0, 10); // UTC date\nconst [header, ...lines] = (await readFile(file, 'utf8')).trim().split(/\\r?\\n/).filter(Boolean);\nconst cols = header.split(',');\nconst invoices = lines.map((line) =>\n Object.fromEntries(line.split(',').map((value, i) => [cols[i], value.trim()])),\n);\n\nconst isDate = (s) => /^\\d{4}-\\d{2}-\\d{2}$/.test(s ?? '');\nconst open = invoices.filter((inv) => (inv.status ?? '').toLowerCase() !== 'paid');\nconst overdue = open.filter((inv) => isDate(inv.due) && inv.due < today);\nconst unclear = open.filter((inv) => !isDate(inv.due));\n\nif (overdue.length === 0 && unclear.length === 0) process.exit(0);\n\nconst row = (inv) => `${inv.number} ${inv.customer} ${inv.amount} due ${inv.due || '?'}`;\nconst parts = [];\nif (overdue.length) parts.push(`Overdue (${overdue.length}):`, ...overdue.map(row));\nif (unclear.length) parts.push(`Check by hand, no readable due date (${unclear.length}):`, ...unclear.map(row));\n\nconst res = await fetch(webhook, {\n method: 'POST',\n headers: { 'content-type': 'application/json' },\n body: JSON.stringify({ text: parts.join('\\n') }),\n});\nif (!res.ok) throw new Error(`Webhook answered ${res.status}`);Guess how many of its 28 non-blank lines decide which invoices are late. Two: the filters that build open and overdue.
Seven lines exist only because something can go wrong, from the check for a missing secret to the check on the webhook’s answer. Two of those are comments that state assumptions. Five more do the job with a guard built in, so 12 of the 28 deal with failure, including both lines that do the job.
\nAmazon’s S3 outage on February 28, 2017 started with input. At 9:37AM PST an authorized team member following an established playbook ran a command, and “one of the inputs to the command was entered incorrectly.” It removed a larger set of servers than intended, and S3 in the region did not finish recovering until 1:54PM PST. AWS’s fix went into the tool, which now removes capacity more slowly and refuses to take a subsystem “below its minimum required capacity level.”
\nA small script needs the same habit of refusing input that cannot be right. The CSV format’s specification, RFC 4180, ends each record with a carriage return and a line feed. A file that follows it puts an invisible carriage return before every line break.
\nWe deleted the script’s handling for that character and ran a test file. A paid invoice showed up as overdue, because the status column’s name now ended in the stray character.
Our tests also found a hole in the script itself. A file with only a header row made it exit cleanly and post nothing, which is exactly what it does on a good day. It never checks the file’s date either, so if the nightly export stops, the script keeps reading the last one. Two more refusals, for zero rows and for a file older than a day, would close both holes.
\nThe same RFC says fields containing commas “should be enclosed in double-quotes”, which the script’s plain split on commas would break. The comment at the top says the export has no such fields. That is fine as long as it stays true, and the written assumption tells the next person where to look when it stops being true.
\nDates get the same treatment. Any due date that is not YYYY-MM-DD goes to a “check by hand” list. Without that list, a row where someone typed 30/09 would never count as overdue, and the script would say nothing about it every morning.
The date comparison is plain text. RFC 3339 notes that dates written this way, in a single time zone, “may be sorted as strings”, and toISOString() is always UTC. For a run at 08:00 in a time zone an hour or two ahead of UTC, that is the same calendar day. Just after local midnight it would still be yesterday in UTC, and an invoice due yesterday would wait a day.
Put the webhook URL in a .env file next to the script, and run it once by hand before you schedule anything:
# .env holds one line: WEBHOOK_URL=https://chat.example.com/hooks/your-hook\nnode --env-file=.env overdue.mjs invoices.csv\n\n# Then add it to cron with crontab -e: weekdays at 08:00\n0 8 * * 1-5 cd /srv/overdue && /usr/bin/node --env-file=.env overdue.mjs /data/exports/invoices.csv >> run.log 2>&1Each part of that cron line answers a failure. Cronie’s cron daemon sets its own PATH rather than inheriting one, and its manual offers a -P flag for the opposite. So the line names /usr/bin/node in full instead of hoping node is found (which node shows where yours is).
The >> run.log 2>&1 keeps every error in a file. Without it, cron mails output to the crontab’s owner, or writes it to the system log when sendmail is not installed. GitLab’s alerts went by mail too.
Then there is the clock, because 0 8 * * 1-5 names a time without a time zone. GitHub Actions runs schedules “in UTC” by default. Kubernetes reads them in the controller’s “local time zone” unless .spec.timeZone is set, and cronie lets a crontab pick one with CRON_TZ. Run date on the server before you trust that 08:00 means your 08:00.
Daylight saving time is worse, because cronie’s two manuals disagree. Its crontab page says jobs in the “missing hours” are “not to be run” and jobs in a repeated hour run twice. Its daemon page says skipped jobs “will be run immediately” and double runs are avoided. Whichever is right, we would schedule nothing in the hour the clocks change.
\nCron assumes the machine is always on. That assumption is why anacron exists: its manual says that “unlike cron(8), it does not assume that the machine is running continuously.”
\nBigger schedulers say so outright. Kubernetes creates a job “approximately once” per scheduled time, because “two Jobs might be created, or no Job might be created.” Its advice is that jobs “should be idempotent”, which means safe to run twice.
\nGitHub Actions warns that under heavy load “some queued jobs may be dropped”. In a public repository, it turns schedules off after 60 days without activity.
\nFor the invoice script, a double run posts the same list twice, which is annoying and harmless. A script that sends invoices or charges cards cannot shrug it off. It needs a record of what it already did. In our view, that record is the point where a script should grow into a service.
\nOn a bad morning the team sees this message. The body below is what our test run sent:
\n{\n \"text\": \"Overdue (2):\\n1042 Acme Freight 12400 due 2026-09-24\\n1047 Example Studio 3150 due 2026-09-30\\nCheck by hand, no readable due date (1):\\n1051 Harbor Print 8900 due 30/09\"\n}On a good morning it sees nothing. It would see the same nothing if the server had died three weeks ago. Google’s SRE book says monitoring should answer “what’s broken, and why?”, and that “it’s better to spend much more effort on catching symptoms than causes.” For a scheduled script the symptom is simple: it did not finish, and one alert on that covers every cause at once.
\nThat alert is a dead man’s switch: the job checks in after every success, and silence sets off the alarm. Healthchecks.io, one such service, says it “works as a dead man’s switch for processes that need to run continuously or on a regular, known schedule.” Its free Hobbyist plan covers 20 jobs.
\nIts cron guide adds one command after the job: && curl -fsS -m 10 --retry 5 -o /dev/null https://hc-ping.com/your-uuid-here. The && sends the ping only when the job exits with code 0. If no ping arrives within the grace time, the check goes down and the service sends its alerts.
This is why the script throws instead of logging and carrying on. An uncaught error makes Node exit with code 1, so no ping goes out. We tested it with no WEBHOOK_URL set, and with a webhook that answered 410: both runs exited with 1. Slack’s webhooks answer with errors such as channel_is_archived when a channel is archived, which the res.ok check turns into that exit code.
The alarm must not share the script’s fate. During the S3 outage, AWS could not update its own status dashboard “because of a dependency the SHD administration console has on Amazon S3.” A check that runs on the same server as the script dies with it.
\nThe decision is how much failure handling a small script deserves. Too little and it fails like GitLab’s backups; too much and the alerts turn to noise. The SRE book warns that when pages come too often, “employees second-guess, skim, or even ignore incoming alerts.” Its rule is that “every page should be actionable”, and we would hold a chat channel to the same rule.
\nSo aim for two kinds of message. One says the data needs a person, like the “check by hand” list; the other says the script did not run. Everything else goes to the log.
\nBefore you schedule a script, run it past this list:
\ndate on the server, set the time zone where the scheduler allows it, and kept clear of the hour the clocks change.GitLab’s response in 2017 points the same way. Among its follow-up work it listed “Prometheus monitoring for backups”, and it started working on a public backup monitoring dashboard. The backup script was never the hard part. Knowing whether it had worked was.
\nThe actual numbers, straight from Google’s web.dev: Largest Contentful Paint within 2.5 seconds, Interaction to Next Paint at 200 milliseconds or less, Cumulative Layout Shift at 0.1 or less. A page passes when it hits all three at the 75th percentile of page loads, measured separately for mobile and desktop. Keep it open for the next time someone wins a performance argument with one test run.
\nLink: web.dev
", "summary": "The actual numbers, straight from Google's web.dev: Largest Contentful Paint within 2.5 seconds, Interaction to Next Paint at 200 milliseconds or less, Cumulative Layout Shift at 0.1 or less. A page passes when it hits all three at the 75th percentile of page loads, measured…", "date_published": "2026-10-18T20:15:00.000Z", "date_modified": "2026-10-18T20:15:00.000Z", "authors": [ { "name": "28creation Desk", "url": "https://28creation.com/authors/desk/" } ], "tags": [ "Developer tools" ] }, { "id": "https://28creation.com/notes/pagefind-static-search/", "url": "https://28creation.com/notes/pagefind-static-search/", "external_url": "https://pagefind.app/", "title": "Pagefind adds search to a static site without a search server", "content_html": "Pagefind indexes your built HTML after the build and drops a static search bundle into the output, so search runs in the visitor’s browser and there is no search server to keep alive. The index is split into chunks, so a search only downloads the pieces it needs. This site’s search runs on it.
\nLink: pagefind.app
", "summary": "Pagefind indexes your built HTML after the build and drops a static search bundle into the output, so search runs in the visitor's browser and there is no search server to keep alive. The index is split into chunks, so a search only downloads the pieces it needs. This site's…", "date_published": "2026-10-18T20:00:00.000Z", "date_modified": "2026-10-18T20:00:00.000Z", "authors": [ { "name": "28creation Desk", "url": "https://28creation.com/authors/desk/" } ], "tags": [ "Developer tools" ] } ] }