DEV Community: T.M. Gunderson

I Stopped Manually Sorting Receipts — Here's the AI Workflow That Categorizes Every Expense

T.M. Gunderson — Fri, 25 Sep 2026 09:02:20 +0000

I Stopped Manually Sorting Receipts — Here's the AI Workflow That Categorizes Every Expense

Every month, I'd spend an entire Sunday afternoon sorting receipts. Download from email, check the vendor, figure out the category, type it into a spreadsheet. 30–50 receipts. 4–8 hours gone.

Multiply that across every small business owner I know and you're looking at millions of hours wasted on what is fundamentally a pattern-matching problem. The vendor name, amount, and date are all right there in the email. The category follows predictable rules. This is exactly the kind of work AI should eat for breakfast.

So I built an n8n workflow that watches my receipt emails, extracts the key data, categorizes each expense, and logs everything to a Google Sheet. Time per month: 0 hours of manual sorting, maybe 15 minutes of spot-checking.

Here's the full build.

Why Expense Categorization Is a Bigger Problem Than You Think

Most small business owners handle expenses in one of two ways:

Shoebox method — throw every receipt in a folder and panic at tax time
Manual spreadsheet — spend hours each month typing line items

Both cost real money. The average small business owner spends 4–8 hours per month on expense management, according to a QuickBooks survey. At $75/hour opportunity cost, that's $300–$600/month in lost productivity.

And the stakes are higher than time. The IRS estimates that incorrect expense categorization triggers audits and missed deductions worth thousands. Misclassify a capital expense as an operating expense and you lose depreciation deductions. Put a meal with a client under "travel" and you lose the 50% deduction cap protection.

The right category matters. And getting it right shouldn't take your Sunday.

The 5 Categories That Cover 90% of Small Business Expenses

Before building the workflow, I mapped every expense from the past 12 months. Here's what I found:

Category	% of Total	Common Vendors
Software & Subscriptions	28%	AWS, Stripe, GitHub, Google Workspace
Office & Operations	22%	Staples, Amazon, USPS
Marketing & Advertising	19%	Meta Ads, Google Ads, Mailchimp
Travel & Meals	14%	Uber, Hilton, restaurant receipts
Professional Services	17%	Lawyer invoices, CPA fees, consultants

Five categories. That's it. The long tail — office plants, random software, one-off purchases — accounted for less than 10% and almost always fell into "Office & Operations" as a catch-all.

This matters because AI categorization works best with a small, well-defined target set. You don't need 47 QuickBooks categories. You need 5–8 that map to your actual spending patterns.

The Workflow: Email → Extract → Categorize → Log

Here's the architecture:

Gmail Trigger (new receipt emails)
    ↓
AI Extract Node (vendor, amount, date, description)
    ↓
AI Categorize Node (maps to 5 categories)
    ↓
Google Sheets Node (log the row)
    ↓
Slack Notification (daily summary)

Step 1: Gmail Trigger

Set up a Gmail trigger that watches for emails matching:

subject:(receipt OR invoice OR order confirmation OR payment receipt)
from:(stripe OR amazon OR uber OR paypal OR square)

This catches 80%+ of automated receipt emails. Add your own vendors as you discover them.

Step 2: AI Extract Node

Use an OpenAI node with this system prompt:

You are an expense data extractor. Given an email body, extract:
1. vendor_name: The company name (e.g., "Amazon", "Stripe", "Uber")
2. amount: The total amount as a number (e.g., 49.99)
3. currency: ISO currency code, default USD
4. date: The transaction date in YYYY-MM-DD format
5. description: A 10-word summary of what was purchased
6. payment_method: Last 4 digits if visible, otherwise "unknown"

Return ONLY valid JSON with these fields. If a field cannot be determined, use null.

The key insight: ask for structured JSON output, not prose. This makes the next step deterministic.

Step 3: AI Categorize Node

A second OpenAI call with the extracted data:

You categorize business expenses into exactly one of these categories:
- software_subscriptions: SaaS, cloud services, domains, hosting
- office_operations: supplies, shipping, equipment, furniture
- marketing_advertising: ads, email tools, design, social media management
- travel_meals: flights, hotels, rideshares, client dinners
- professional_services: legal, accounting, consulting, freelance contractors

Given the vendor name, amount, and description, return ONLY the category key.
If uncertain, default to office_operations.

Why a second call instead of combining extraction and categorization? Separation of concerns. The extraction step needs to be accurate — wrong amounts are worse than wrong categories. The categorization step can tolerate fuzziness. Combining them makes both worse.

Step 4: Google Sheets Log

Map the combined output to a row:

Date	Vendor	Amount	Category	Description	Payment
2026-06-25	AWS	127.43	software_subscriptions	Monthly cloud hosting	•••4821

Step 5: Daily Slack Summary

A scheduled node sends a daily digest:

📊 Today's Expenses (3 items, $412.67 total)
• AWS — $127.43 (software_subscriptions)
• Uber — $23.50 (travel_meals)
• Staples — $261.74 (office_operations)

This takes 5 seconds to scan. If something looks wrong, you fix it in the sheet. Otherwise, you're done.

The n8n Workflow JSON

{
  "name": "Expense Categorizer",
  "nodes": [
    {
      "parameters": {
        "pollTimes": { "item": [{ "mode": "everyMinute", "value": 15 }] },
        "filters": {
          "from": "stripe OR amazon OR uber OR paypal OR square",
          "subject": "receipt OR invoice OR order confirmation"
        }
      },
      "name": "Gmail Trigger",
      "type": "n8n-nodes-base.gmailTrigger",
      "position": [250, 300]
    },
    {
      "parameters": {
        "model": "gpt-4o-mini",
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are an expense data extractor. Given an email body, extract:\n1. vendor_name: company name\n2. amount: total as number\n3. currency: ISO code, default USD\n4. date: YYYY-MM-DD\n5. description: 10-word summary\n6. payment_method: last 4 digits or 'unknown'\n\nReturn ONLY valid JSON."
            },
            {
              "role": "user",
              "content": "={{ $json.snippet }}"
            }
          ]
        },
        "options": { "responseFormat": "json_object" }
      },
      "name": "Extract Data",
      "type": "n8n-nodes-base.openAi",
      "position": [470, 300]
    },
    {
      "parameters": {
        "model": "gpt-4o-mini",
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "Categorize this expense into exactly one:\n- software_subscriptions\n- office_operations\n- marketing_advertising\n- travel_meals\n- professional_services\n\nReturn ONLY the category key."
            },
            {
              "role": "user",
              "content": "={{ $json.vendor_name }} — ${{ $json.amount }} — {{ $json.description }}"
            }
          ]
        }
      },
      "name": "Categorize",
      "type": "n8n-nodes-base.openAi",
      "position": [690, 300]
    },
    {
      "parameters": {
        "operation": "append",
        "documentId": "YOUR_SHEET_ID",
        "range": "Expenses!A:F",
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "Date": "={{ $('Extract Data').item.json.date }}",
            "Vendor": "={{ $('Extract Data').item.json.vendor_name }}",
            "Amount": "={{ $('Extract Data').item.json.amount }}",
            "Category": "={{ $('Categorize').item.json.text }}",
            "Description": "={{ $('Extract Data').item.json.description }}",
            "Payment": "={{ $('Extract Data').item.json.payment_method }}"
          }
        }
      },
      "name": "Log to Sheets",
      "type": "n8n-nodes-base.googleSheets",
      "position": [910, 300]
    },
    {
      "parameters": {
        "channel": "#expenses",
        "text": "📊 New expense: *{{ $('Extract Data').item.json.vendor_name }}* — ${{ $('Extract Data').item.json.amount }} ({{ $('Categorize').item.json.text }})"
      },
      "name": "Slack Alert",
      "type": "n8n-nodes-base.slack",
      "position": [1130, 300]
    }
  ],
  "connections": {
    "Gmail Trigger": { "main": [[{ "node": "Extract Data", "type": "main", "index": 0 }]] },
    "Extract Data": { "main": [[{ "node": "Categorize", "type": "main", "index": 0 }]] },
    "Categorize": { "main": [[{ "node": "Log to Sheets", "type": "main", "index": 0 }]] },
    "Log to Sheets": { "main": [[{ "node": "Slack Alert", "type": "main", "index": 0 }]] }
  }
}

Copy this into n8n, add your Gmail and Google Sheets credentials, and you're running.

The Numbers: What This Actually Saves

For a business processing 50 expenses/month:

Task	Before	After	Saved
Opening & reading receipts	2.5 hrs	0 hrs	2.5 hrs
Categorizing expenses	1.5 hrs	0.25 hrs (spot-check)	1.25 hrs
Data entry into sheets	1.5 hrs	0 hrs	1.5 hrs
Finding missed receipts	1 hr	0.25 hrs	0.75 hrs
Total	6.5 hrs	0.5 hrs	6 hrs/month

At $75/hour: $450/month saved. At scale with 200+ expenses: $1,200+/month.

And this is before tax-season benefits. When your CPA asks for expense categories, you hand them a clean spreadsheet instead of a shoebox. That alone can save $500–$1,000 in CPA fees.

3 Mistakes I Made Building This (So You Don't Have To)

Mistake 1: Combining extraction and categorization into one prompt.
The AI would sometimes hallucinate categories into the amount field, or combine vendor names with descriptions. Two separate calls with clear, single-purpose prompts fixed this completely.

Mistake 2: Too many categories.
I started with 15 categories matching our chart of accounts. The AI got confused between "office supplies" and "office equipment" and "office furniture." Reducing to 5 broad categories pushed accuracy from ~70% to ~95%.

Mistake 3: Not handling multi-item receipts.
Amazon receipts often have 3–5 items in one order. The workflow now splits multi-item receipts into separate rows, each with its own category. This required a small loop node but was worth the accuracy gain.

What This Connects To

Expense categorization is step one. Once your expenses are structured data, you can:

Flag anomalous spending — "You spent 40% more on software this month"
Auto-generate P&L reports — monthly profit & loss without manual rollups
Predict cash flow — feed categorized expenses into a simple forecasting model
Catch duplicate charges — same vendor, same amount, within 7 days = alert

Each of these is another n8n workflow layered on top of the same clean data foundation.

Start with categorization. Get your expenses into a shape a computer can reason about. Then stack the next automation on top.

If you're building expense automation or want the full n8n workflow with error handling and multi-item receipt parsing, drop a comment or reach out. I share complete workflows with working JSON — no gated PDFs.

Your Team Already Creates Content — Here's How to Turn It Into a Growth Engine

T.M. Gunderson — Fri, 25 Sep 2026 09:01:47 +0000

Most small businesses treat content marketing as the owner's job. The owner hates it, posts irregularly, and gets crickets. Meanwhile, five employees are posting personal stuff to social media every day — and reaching exactly the audience the business needs.

The fix isn't "make everyone post on LinkedIn." The fix is a structured game that makes employee content creation fun, measurable, and worth doing.

The Model: A Point System, Not a Mandate

The Tenex Creator Cup runs a quarterly competition where employees earn points for creating content. The prize pool is $5,000 — split across winners. But here's the math that matters: if one employee's content leads to a single quality hire, that $5K already paid for itself.

Scale this down for a 5-20 person business:

Prize pool: $500–$1,000 per quarter
Point system: Assign points per action (see below)
Duration: 4-week sprints, not open-ended marathons
Rule: No mandatory participation — opt-in only

The opt-in rule is critical. Forced content sounds like homework. Voluntary content sounds like a game people might win.

The Point System

Assign point values to content actions that map to actual business value:

Action	Points	Why
Write a short post about your work	10	Lowest barrier to start
Post a behind-the-scenes photo	10	Authenticity > polish
Record a 60-second video tip	25	Video reaches further
Write a how-to article	50	Long-form builds authority
Get 10+ engagements on a post	20 bonus	Rewards quality, not just volume
Mention a coworker or the business	5 bonus	Cross-pollination grows reach

Keep it simple. Five action types, two bonuses. Don't build a 20-row spreadsheet — nobody will read it.

Why This Works for Small Businesses

Your employees already have the audience you're paying ads to reach. A landscaper's crew chief knows other landscapers. A salon stylist follows hundreds of potential clients. A restaurant server's personal network includes people who eat out.

Employee content reaches warm audiences — people who already trust the person sharing it. That trust transfers to the business.

One good hire = full ROI. If your mechanic posts a 30-second reel about working at your shop and it attracts one qualified applicant, you just saved $3,000–$5,000 in recruiting costs. The prize pool is already justified.

It builds culture. When people see their coworkers creating content and getting recognized, it shifts the vibe. The business stops feeling like "the place I go to work" and starts feeling like "the place that values what I say."

The AI Shortcut

Here's where AI makes this actually feasible for small teams:

Content prompts: Feed your business type into any AI assistant and ask for 30 days of post ideas tailored to your industry. Distribute one idea per employee per week.
Draft assistance: Employees who say "I don't know what to write" can paste their rough thoughts into an AI tool and get a polished first draft in 30 seconds. They edit, approve, and post.
Tracking: Use a simple shared spreadsheet or free project board. Employees drop links to what they posted. Calculate points weekly. Post a leaderboard somewhere visible — a group chat, a whiteboard, wherever your team already looks.
Repurposing: One employee's 60-second video becomes three short clips, a text post, and a how-to article draft. AI can extract key points from video transcripts and spin them into multiple content pieces.

Launching It: The 4-Week Sprint

Week 1 — Soft launch. Announce the game. Share the point system. Give everyone their first content prompt. Don't expect a flood — expect 3-5 people to try it.

Week 2 — First results. Post the leaderboard. Highlight what's working. Share a specific post that got engagement and explain why it worked.

Week 3 — Momentum. More people join because they see others having fun and getting recognized. The competitive instinct kicks in.

Week 4 — Close and celebrate. Tally points, announce winners, distribute prizes. Do a quick retro: what got the most engagement? What felt easy? What felt forced?

Then start sprint two with the lessons from sprint one.

What Not To Do

Don't script people. Give ideas, not scripts. Scripted employee content is obvious and off-putting.
Don't gatekeep. Don't require management approval before every post. Trust your team or don't run the program.
Don't make it about virality. A post that reaches 50 of the right people beats a post that reaches 5,000 random accounts.
Don't forget to promote the program internally. If nobody knows the game exists, nobody plays.

The Bottom Line

Your business already employs its best content creators. They just don't know it yet — and nobody's asked them to think of themselves that way.

A $500 quarterly prize pool, a simple point system, and four weeks of low-pressure competition can turn your team into a content engine that produces more authentic, effective marketing than any agency contract.

Start this month. Run one sprint. See what happens. The worst case is you spend $500 and your team learns something about social media. The best case is you attract your next great hire through a 30-second video your cashier filmed on a Tuesday afternoon.

Your Inbox Is a Triage Problem — Not a Communication Problem

T.M. Gunderson — Fri, 25 Sep 2026 09:01:14 +0000

The average small business owner spends over 5 hours a week on email. Not writing thoughtful responses — just sorting, skimming, and deciding what to ignore.

That's not communication. That's triage. And triage is a process, which means it's automatable.

The Three-Bucket Email Problem

Every email that lands in your inbox falls into one of three buckets:

Bucket 1: Noise — Newsletters, promotions, cold outreach, CC'd FYIs. No action required. Delete or archive.

Bucket 2: Quick Response — "Can you confirm the meeting time?" "Here's the invoice." "Thanks for the update." These need 1-2 sentences and under 60 seconds.

Bucket 3: Real Work — Client requests, proposal questions, project decisions. These require thought, context, and careful replies.

Most SMB owners spend 80% of their email time on Buckets 1 and 2. That's the automation opportunity.

How to Automate Email Triage

Step 1: Audit Your Last 50 Emails

Pull up your inbox. Categorize the last 50 messages into the three buckets. Count them.

Typical SMB breakdown:

Bucket	Count	% of Inbox
Noise	20-25	40-50%
Quick Response	15-20	30-40%
Real Work	5-10	10-20%

If your numbers look like this, half your email doesn't need you at all.

Step 2: Set Up Rules for Bucket 1

Before you touch AI, use what you already have. Gmail, Outlook, and most email clients support rules and filters.

Create rules that automatically:

Archive newsletters you never read
Move transactional emails (receipts, confirmations) to a dedicated folder
Label cold outreach from unknown senders
Flag emails where you're CC'd (not the primary recipient) for bulk review

This alone typically cuts 30-40% of inbox volume before AI enters the picture.

Step 3: Add an AI Agent for Bucket 2

This is where automation gets powerful. Set up an AI agent that:

Monitors incoming email via your email API or a tool like Zapier
Classifies each message using a simple prompt: "Is this a quick response, real work, or noise?"
Drafts responses for Bucket 2 emails using your business context
Flags Bucket 3 emails for your attention with a brief summary

The agent doesn't send anything automatically. It drafts, you approve. Over time, you'll trust it with more.

Step 4: Measure Weekly

Track two numbers each week:

Time spent on email (set a timer, don't estimate)
Emails handled without you (drafted by AI, approved and sent)

The goal: reduce your email time by 50% within 30 days. If you're currently at 5 hours/week, that's 2.5 hours reclaimed — every single week.

What to Automate First

Start with the highest-volume, lowest-judgment email types in your business:

Appointment confirmations and reschedules — Template responses with schedule links
Invoice and payment acknowledgments — "Received, processing" auto-replies
Project status requests — Pull data from your project tool, draft a summary
Vendor/supplier routine communications — Order confirmations, shipping updates
Review and testimonial follow-ups — Timed reminders with draft text

Each of these follows a pattern. Patterns are what AI handles best.

What NOT to Automate Yet

Client complaints or escalations
Negotiations on pricing or scope
Sensitive personnel matters
Anything requiring legal or compliance judgment

These need human nuance. The AI agent should surface these for you immediately, not attempt to handle them.

The Quick-Start Checklist

[ ] Categorize your last 50 emails into Noise / Quick Response / Real Work
[ ] Set up email rules for the Noise bucket (archive, label, filter)
[ ] Identify your top 3 Quick Response email types by volume
[ ] Create draft templates for those 3 types
[ ] Set up an AI agent to classify incoming email and draft Quick Responses
[ ] Approve all AI drafts for the first 2 weeks (no auto-send)
[ ] Measure time saved weekly

Email triage is the lowest-hanging fruit in SMB automation. It's high-volume, repetitive, and low-judgment — exactly the pattern where AI agents deliver fast, measurable results.

Stop sorting. Start automating.

Building an email triage agent and want a classification prompt template? Drop a comment — I'll share what's working for SMBs.

Google Paid $10M for a Bankrupt Airline's Data. Yours Is Worth More Than You Think.

T.M. Gunderson — Fri, 25 Sep 2026 09:00:43 +0000

When Spirit Airlines went under, the planes and routes got the headlines. The quieter sale was stranger: Google paid $10 million for the airline's data — de-identified business records, software code, and operations history — at the bankruptcy auction, and said it plans to use the trove to improve its AI models (Reuters, Axios).

Nobody paid eight figures for Spirit's desks. They paid it for the records. That's the clearest signal yet of what business data has become: not a byproduct of doing business, but an asset in its own right.

You don't have an airline's worth of data. But the same logic applies at the scale of a 10-person shop — and the AI era makes your data pay twice. Here's why, and here's the 30-minute audit that puts it to work.

Why Buyers Care About Data Now

When a small business sells, the price is mostly a multiple of earnings. But the multiple itself moves with risk. A service business that depends entirely on the founder's daily involvement might sell for two to three times earnings; a business with recurring revenue, a strong team, and diversified clients can command five or six times (Forbes).

What's inside that gap? Transferability. A buyer is asking one question: does the value of this business leave when the owner does?

Clean, organized, exported data is the most underrated answer to that question:

Customer history — who buys, how often, at what price points
Operational records — job history, costs, turnaround times, warranty claims
Pricing rules — documented rate logic instead of "it's in the owner's head"
Vendor and contract terms — renewable agreements a buyer inherits

A business where that information lives in the owner's inbox sells at a discount, if it sells at all. A business where it's organized sells at a premium. Buyers price risk relentlessly — and messy data is risk.

The Second Payoff: AI Readiness

The Spirit sale points at the second reason this matters now. Google bought that data to train AI. The same shift is happening at every scale: businesses want to put AI to work, and AI can only work with what it can read.

Every AI automation — drafted follow-ups, invoice chasing, lead qualification, demand forecasting — runs on the same fuel: your data, in a usable form. A business whose records live in five SaaS tools, twelve spreadsheets, and one founder's memory has nothing an AI agent can use. The 30-minute audit below is, not coincidentally, also step one of almost every automation project.

That's the double payoff: the same data hygiene that makes a business sellable is what makes it automatable.

The 30-Minute Data Audit

This isn't a data-science project. It's a map. Set a timer and answer four questions.

Step 1: Where does data live? (10 minutes)

List every place your business information is stored. Most small businesses end up with five buckets:

SaaS tools — CRM, scheduling, invoicing, email marketing, POS
Spreadsheets — the tracking files nobody admits they rely on
Email and text threads — pricing quotes, client decisions, supplier terms
Paper and notes — job-site notes, receipts, the notebook in the truck
People's heads — pricing logic, supplier terms, "who we don't work with anymore"

Write the buckets down. Don't fix anything yet — just see the sprawl honestly.

Step 2: What's exportable? (10 minutes)

Go down your SaaS list and run the export test for each: can you get a full export — right now, without contacting support?

A CSV export button and an API key are the baseline. If the only path to your own data is "email our success team," that's a flag — your data lives in someone else's vault. Note each tool as exportable or locked.

This matters in a sale (buyers ask for data rooms, not logins) and it matters for automation (your AI can't use what it can't reach).

Step 3: Who owns each piece? (5 minutes)

For each bucket, note who depends on it and what breaks if that person leaves. The spreadsheet only one person can read, the pricing logic only the founder knows — these are your single points of failure, and they're exactly what buyers and lenders probe.

Step 4: Write the one-page data map (5 minutes)

Turn your notes into a single page:

Data	Where it lives	Exportable?	Owner
Customer list	CRM	Yes	Ops
Job history	Spreadsheets	Yes	Owner
Pricing logic	Owner's head	No	Owner

That single page is the deliverable. It becomes the backbone of a data room if you ever sell, and the starting point for any AI automation you attempt.

What to Do With the Map

Once the audit exists, three moves pay for themselves:

Close the export gaps. Move anything sitting in a locked tool to a place you control, or at minimum set a recurring export. Recurring monthly exports of every SaaS tool is the cheapest insurance in business.
Get the head-data out. The pricing rules and supplier terms that live in your head are worth more written down than stored. A one-hour session with an AI assistant dictating "how we price" produces a document a buyer — or an AI — can actually use.
Feed the map to an AI agent. Hand your data map to any capable AI assistant with a prompt like: "Here's where my business data lives. List the five automations this data supports, ranked by hours saved." That's a faster route to an automation roadmap than most paid audits.

Honest Limits

A few caveats, because this topic attracts over-promising:

Google's $10M purchase is an outlier. It involved millions of operational records from a national carrier. Your data won't sell at auction — its value shows up as a smoother sale, a better multiple, and lower diligence risk, not a headline number.
A data audit doesn't create value out of nothing. If the underlying business is unhealthy, clean books won't fix it. Data hygiene multiplies value; it doesn't substitute for it.
Doing the audit once isn't the win. The win is the habit — quarterly, 30 minutes, re-run the map.

The Bottom Line

Spirit Airlines' most interesting asset turned out to be its records. For a small business, the lesson isn't "someone might buy your data" — it's that your data is the part of the business that survives you, and it's the fuel every AI tool needs. Most owners are sitting on both a sellability gap and an automation opportunity, and they're the same gap.

Thirty minutes and one page closes both.

Want help with step three — turning your data map into working automations? The Boring Automation Pack includes ready-to-use templates for the follow-up, review response, and reminder workflows your audit will surface.

Stop Logging Into Your Software: The Buying Question Nobody Asks Yet

T.M. Gunderson — Fri, 25 Sep 2026 09:00:12 +0000

At Salesforce's flagship conference this year, the headline theme wasn't a feature. It was the absence of one: don't log into the app. Point an AI at the work and let it run the software for you.

When the company whose entire product is a screen you stare at makes "never open our UI" the keynote message, the direction is settled. The value of business software is shifting from the interface to the work the software does — and increasingly, that work will be triggered by an AI assistant instead of a human with a mouse.

That changes the question you should ask before buying any tool for a small business. It used to be "is it easy to use?" The better question now is: can my AI operate this?

Why a 10-Person Business Should Care

You don't need an enterprise transformation to feel this. The first place it lands in a small business is admin work — chasing invoices, updating the CRM, scheduling, copying data between tools. Every one of those jobs gets dramatically cheaper when an AI agent can do it directly.

But whether that takes an afternoon or a vendor negotiation depends entirely on decisions you already made when you bought the software. Most owners have signed up for tools that quietly lock agents out — and they won't find out until the automation fails.

The fix is cheap: ask five questions before you buy, and re-ask them at every renewal.

The Five Green Flags

Look for these when evaluating any tool:

1. Clean Exports

Can you get your data out — full data, in a real format — without filing a support ticket? A CSV export button and an API endpoint are the baseline. If the only path out is "contact our success team," your data lives in someone else's vault.

Check: Try exporting something before you commit. If you can't do it during the trial, that's the answer.

2. API Access on Your Tier

An API that exists but is gated to the enterprise plan is a data hostage with better marketing. Check the pricing page: is API access included at the tier a business your size would actually buy?

3. Automation-Platform Connectors

Does the tool have native connectors for Zapier, Make, or an MCP-style integration? Connectors to automation platforms are the bridge agents use to act. A tool with no connectors forces everything through its own UI — which an agent can't click.

4. Public, Readable Documentation

Docs you can paste into an AI assistant are becoming more valuable than docs you can read. Public documentation means any agent can learn to operate the tool in seconds. Login-walled docs mean it can't.

5. Machine-Friendly Pricing

Seat-based pricing punishes you for adding non-human workers. The vendors adapting fastest are moving toward usage- or outcome-based pricing, where an agent running a workflow costs the same whether a human triggered it or not. Ask how the vendor prices API and automation usage — the answer tells you which decade they're living in.

The Red Flags

"Contact us" for data export. That's not a process, that's a wall.
Reports that only render in-app. If it can't leave the product, you don't own it.
API listed as an enterprise feature. Same tool, different hostage.
Everything requires a logged-in human. No webhooks, no triggers, no scheduled runs — a tool that can only be operated by a person clicking is a tool your AI can't touch.

The 10-Minute Test

Before buying — or at every renewal — spend ten minutes:

Export something right now. Full data, real format. Time it.
Ask the vendor or check the docs: "Can an automation platform trigger this without a human logged in?"
Find the API pricing. Is it on your tier, or three upgrades away?
Search for a Zapier or Make connector. Absence is information.
Check if the docs are public. Try opening one in a logged-out browser.

Score the answers. Two or more failures means the tool will cost you far more than its subscription price the moment you try to automate around it.

The Cheap Insurance

None of this means ditching tools you like, or demanding features you don't need yet. It means making agent-readiness a standard part of the buying decision — the same way "does it work on mobile" became a checkbox nobody skips.

The cheapest time to ask "can my AI run this?" is before you sign. The second cheapest is at the next renewal. The most expensive is after you've built your workflow on top of a tool that won't let the agent in.

Want a reusable audit for scoring every tool in your stack? The Boring Automation Pack includes software-evaluation checklists, automation setup guides, and templates built for small businesses.

Your CRM Is a Graveyard — How to Stop Drowning in Data Entry

T.M. Gunderson — Thu, 24 Sep 2026 09:02:18 +0000

You know that CRM you paid for six months ago? The one your team was "definitely going to use this time"? Go look at the last 10 entries. I'll wait.

Half of them are probably incomplete. Three have wrong phone numbers. Two are duplicates. And the one contact you actually need to follow up with? Missing the deal amount entirely.

This isn't a discipline problem. It's a systems problem. Data entry is the most hated task in any small business, which means it's the task most likely to be skipped, rushed, or done wrong.

The Real Cost of Bad CRM Data

A CRM with garbage data isn't just useless — it's actively harmful:

Missed follow-ups: The "call next Tuesday" note that never got entered means a $4,000 job walks out the door
Duplicate outreach: Two salespeople call the same prospect because the entry exists twice with slightly different names
Lost institutional knowledge: When an employee leaves, their contacts live in their phone, not in your system
Bad forecasting: You can't plan next quarter's revenue when half your deals have no estimated close date

The average SMB loses 5-8 hours per week on manual CRM work — or, more commonly, loses that much value by not doing it.

The Automation Pipeline

Stop trying to get humans to type data into forms. Build a pipeline that captures, cleans, and files information automatically.

Step 1: Capture at the Source

Every business has 3-5 points where customer information enters. Map them:

Web forms — estimate requests, contact forms, quote requests
Email — prospect emails, inquiry threads
Phone calls — voicemails, call logs
In-person — business cards, trade shows, walk-ins
Referrals — "my friend John mentioned you"

For each entry point, set up a capture rule:

Web forms → Direct to CRM. Most form tools (Gravity Forms, Typeform, whatever your site uses) can push directly into your CRM. No copy-paste. Set this up once and it runs forever.

Email → AI extraction. Route new inquiry emails to an AI agent that pulls out name, company, phone, service interest, and urgency level, then creates a draft CRM entry. You just review and approve.

Phone → Quick voice note. After a call, record a 15-second voice memo: "New lead, Sarah, roofing job, call back Thursday." An AI transcription agent converts it to a CRM entry with all fields populated.

Business cards → Photo + AI. Snap a photo of the card. AI extracts every field. This has been possible for years — the technology isn't new, most people just don't have the workflow set up.

Step 2: Clean and Deduplicate

Capturing data is half the battle. The other half is making sure it's not a mess.

Set up a weekly automation that:

Flags duplicates — matches on name + phone or name + email
Standardizes formats — phone numbers, addresses, company names
Fills gaps — if you have a company name but no industry, AI can infer it and add it
Scores completeness — marks records as "complete" or "needs follow-up info"

Most CRM platforms have built-in deduplication. Turn it on. If yours doesn't, a simple AI agent can run this as a weekly batch job.

Step 3: Update Without Asking

The biggest CRM sin is stale data. Contacts change jobs, companies change names, phone numbers go dead.

Set up a quarterly automation that:

Checks email bounce rates on your last campaign — bounced emails get flagged
Runs company names against a business directory API — catches name changes and closures
Flags contacts with no activity in 90+ days — either re-engage or archive

You don't need to do this manually. A scheduled script does it while you sleep.

What This Looks Like in Practice

Before automation:

Monday: 3 new leads come in via website form. You see them Thursday. Two have gone cold.
Wednesday: Trade show. 12 business cards collected. 3 get entered by Friday. The rest sit in a desk drawer.
Friday: You remember you were supposed to follow up with someone. Search the CRM. Can't find them. Search email. Find thread. No deal amount recorded. Guess.

After automation:

Monday: 3 new leads auto-populate in CRM with full contact info, service interest, and source. AI drafts a personalized follow-up email for each. You click send on all three by 10 AM.
Wednesday: 12 business cards photographed and processed. All 12 entries exist in CRM by Thursday morning with extracted details and suggested next actions.
Friday: Dashboard shows 3 deals needing follow-up this week, sorted by value. Click, call, close.

Same business. Same leads. Different system.

The Setup Effort

This isn't a weekend project, but it's not a six-month initiative either:

Component	Setup Time	Ongoing Effort
Web form → CRM integration	1-2 hours	None
Email → AI extraction	2-3 hours	10 min/week review
Voice note → CRM entry	1 hour	None
Business card → AI extraction	30 minutes	None
Weekly deduplication	1 hour	Automated after setup
Quarterly data cleanup	2-3 hours	Automated after setup

Total initial setup: 8-12 hours. Total ongoing effort: 10-15 minutes per week.

Compare that to the 5-8 hours per week you're currently spending (or losing by not spending).

What Not To Do

Don't over-customize fields. A CRM with 40 custom fields is a CRM nobody will use. Start with 8-10 fields that actually matter.
Don't require manual entry for things that can be automated. If the data exists in an email, it should end up in the CRM without a human touching it.
Don't build a perfect system on day one. Start with the biggest leak (usually web forms or email) and automate that first. Add more entry points over time.
Don't skip the review step. AI is great at extraction, but it will occasionally misread a phone number or confuse two similar contacts. A 2-minute daily review catches errors before they compound.

The Bottom Line

Your CRM isn't a graveyard because your team is lazy. It's a graveyard because manual data entry is a terrible use of human attention.

The fix is simple: capture information where it enters, use AI to extract and clean it, and review rather than type. Set it up once, maintain it in minutes per week, and spend those reclaimed 5+ hours actually talking to customers instead of typing their details into a form.

Start with whatever leaks the most leads today — web forms, email inquiries, or business cards — and automate that one pipeline. Then add the next one. Within a month, your CRM goes from a chore to a tool you actually trust.

SMB Scale Up helps trades and service businesses cut admin time with practical automation. No hype, just tools that work.

Stop Losing Money to Auto-Renewals: Build a Contract Renewal Tracker with AI

T.M. Gunderson — Thu, 24 Sep 2026 09:01:47 +0000

The Silent Revenue Drain

Every SMB has contracts they forget about until the renewal notice hits — or worse, until the charge hits. Software subscriptions, vendor agreements, service contracts, lease terms. Most get auto-renewed at whatever rate the vendor feels like charging.

The math is brutal: a 20-person company typically carries 30–50 active contracts. Missing just one unfavorable renewal can cost thousands. Missing several across a year? Tens of thousands in avoidable spend.

The fix isn't "be more organized." It's building a system that never forgets.

What a Contract Renewal Tracker Needs to Do

At minimum, you need three things:

Capture: Get contract details into a single place — vendor, term, renewal date, auto-renew status, cost, and notice period
Alert: Surface renewals before the notice window closes (typically 30–90 days out)
Decide: Give someone enough context to make a renegotiate, cancel, or renew decision

This is a perfect AI automation problem because the inputs are semi-structured (contracts, emails, PDFs), the timing is date-driven, and the action is always the same shape: "review this before [date] or it renews automatically."

Building It: The Architecture

Here's a practical setup using tools most SMBs already have or can get cheaply:

Step 1: Centralize Contract Data

Create a structured store — a Google Sheet, Airtable, or Notion database with these fields:

Field	Why It Matters
Vendor name	Obvious
Contract type	Software, service, lease, etc.
Annual cost	For prioritization
Start date	Context for negotiation
Renewal date	The critical trigger
Auto-renew?	Changes urgency completely
Notice period	How many days before renewal you can cancel
Status	Active, under review, cancelled
Owner	Who's responsible for the decision

Step 2: Set Up Monitoring with an AI Agent

Use an AI agent (OpenClaw, n8n, or similar) to handle two jobs:

Ingest: When a new contract email or PDF comes in, the agent extracts key terms and populates the database. No manual data entry. Point it at your contracts inbox or shared drive.

Monitor: The agent runs a daily check against renewal dates. When a contract hits its notice window (e.g., 60 days before renewal), it fires an alert to the contract owner with a summary: what's renewing, when, for how much, and whether it auto-renews.

Step 3: Build the Decision Workflow

For each flagged contract, the agent presents three paths:

Renegotiate — If the cost is above market or usage is low. The agent can draft a renegotiation email.
Cancel — If the tool isn't being used. The agent generates a cancellation notice.
Renew as-is — If the value justifies the cost. One click, done.

The key insight: the agent doesn't make the decision. It surfaces the decision at the right time with enough context that the human can decide in 60 seconds instead of 60 minutes.

The Prompt That Does the Heavy Lifting

Here's the core extraction prompt for pulling contract details from emails and PDFs:

Extract contract renewal details from the following document. Return as JSON:
{
  "vendor": "",
  "contract_type": "",
  "annual_cost": "",
  "start_date": "YYYY-MM-DD",
  "renewal_date": "YYYY-MM-DD",
  "auto_renew": true/false,
  "notice_period_days": number,
  "key_terms": ""
}
If any field is ambiguous, note it in key_terms. Be conservative with auto_renew — only mark true if explicitly stated.

Wire this into your document pipeline. Every contract that touches your inbox gets logged automatically.

What This Saves in Practice

Consider a realistic SMB scenario:

40 active contracts averaging $3,000/year each
Typical auto-renewal markup: 10–25% if you don't renegotiate
Without tracking: you miss the notice window on maybe 8–12 contracts per year
With tracking: you review every contract before the window closes

Conservative estimate: catching just 5 unfavorable renewals per year and renegotiating or cancelling them saves $7,500–$15,000. That's a meaningful number for a 20-person company.

Implementation Checklist

[ ] Set up your contract database (Sheet, Airtable, or Notion)
[ ] Define the schema with all fields from the table above
[ ] Build or deploy an AI agent for contract ingestion
[ ] Configure daily renewal monitoring (60-day notice window)
[ ] Set up alert routing (email, Slack, whatever your team uses)
[ ] Add decision templates (renegotiate, cancel, renew)
[ ] Backfill existing contracts into the system
[ ] Test with 3–5 contracts before going live

Start with your top 10 contracts by annual cost. You don't need to track everything on day one. Get the system working for the contracts that matter most, then expand coverage.

The Bottom Line

Contract renewals are a quiet, consistent money leak for SMBs. The fix isn't better memory or a shared calendar — it's a system that watches every deadline and surfaces decisions before windows close. Build it once, and it pays for itself every single year.

The companies that save money on contracts aren't the ones with the best negotiators. They're the ones that never miss a deadline.

Stop Losing Clients in Week One — Automate Your Onboarding Handoff

T.M. Gunderson — Thu, 24 Sep 2026 09:01:15 +0000

Stop Losing Clients in Week One — Automate Your Onboarding Handoff

You signed the contract. The invoice went out. And then... silence.

The client waits three days for a welcome email. Nobody sends them the intake form. The project brief lives in someone's head. By Friday, they're already second-guessing the engagement.

That's not a branding problem. That's an onboarding problem.

For small businesses especially — agencies, consultancies, service shops — the first seven days after a signed contract are where you either build trust or bleed it. The good news: onboarding is one of the easiest workflows to automate, and the payoff is immediate.

The Problem with Manual Onboarding

Here's what "onboarding" typically looks at a 5-15 person shop:

Sales closes the deal and sends a Slack message: "Hey, we got Client X!"
Someone remembers (or doesn't) to send a welcome email.
An intake form gets shared — maybe Google Forms, maybe a Word doc, maybe nothing.
The PM gets looped in a day or two late, already behind.
The client follows up asking what happens next. Awkward.

Every step is a person-dependent handoff. Miss one and the client feels it.

The Automated Onboarding Stack

Here's a setup that runs without you touching it. Total cost: your existing tools plus $0-20/month.

Step 1: Trigger on Deal Won

Connect your CRM (HubSpot, Pipedrive, whatever) so that when a deal moves to "Closed Won," it fires a webhook.

In Zapier, that's your trigger:

Trigger: New Deal in Stage "Closed Won" (HubSpot/Pipedrive)

If you don't use a CRM, a Google Form submission works too — "New Client Intake" form, submitted by sales.

Step 2: Send the Welcome Email

Action one in Zapier:

Action: Send Email (Gmail / SMTP)
To: Deal contact email
Subject: Welcome aboard, {{company_name}} — here's what happens next
Body: [template with next steps, timeline, intake form link]

Write this email once. It goes out within 60 seconds of the deal closing. No more "we'll follow up Monday."

Step 3: Create the Project Workspace

Action two:

Action: Create Page (Notion) / Create Folder (Drive) / Create Board (Trello)
Template: Client Onboarding Template
Variables: {{company_name}}, {{contact_name}}, {{deal_value}}, {{close_date}}

Now there's a workspace ready before the PM even knows about the deal.

Step 4: Send the Intake Form

Action three:

Action: Send Email (or Slack notification)
To: Client contact
Content: Link to your intake form pre-filled with {{company_name}}, {{contact_name}}

Use a pre-fill URL so the client doesn't re-type what you already know. This alone doubles form completion rates.

Step 5: Notify the Team

Action four:

Action: Send Slack Message
Channel: #new-clients
Message: 🎉 New client: {{company_name}} ({{deal_value}}). Welcome email sent. Intake form dispatched. Project workspace created.

Everyone's aligned. No Slack ping pong.

The Full Zapier Flow

Deal Closed Won
  → Welcome email to client
  → Create Notion project page
  → Send pre-filled intake form
  → Post to #new-clients Slack channel

Four steps. Zero human delay. Every time.

What This Actually Fixes

No more 3-day gaps between signing and first contact
No more "who's handling this?" — the team channel covers it
No more copy-paste errors — variables pull from the CRM
No more lost intake forms — the pre-fill link goes out automatically
No more "I thought you sent that" — it's sent before anyone can forget

Tips from the Trenches

Keep the welcome email short. 4-5 sentences max. Link to the intake form and say when they'll hear from their PM. That's it.
Don't over-automate. The PM's first call should still be human. Automate the handoff, not the relationship.
Add a delay step (1-2 hours) between the workspace creation and the team notification if you want a chance to review first.
Track form completion. Add a Zapier step that watches for form submissions and notifies the PM. If the client hasn't filled it out in 48 hours, trigger a follow-up email.

What to Measure

After you set this up, track these for two weeks:

Metric	Before	After
Time from deal close to first client contact	___	___
Intake form completion rate	___	___
Days to project kickoff	___	___
Client satisfaction (week 1 survey)	___	___

If you're not seeing improvement, the automation isn't the problem — the form or email copy is.

Bottom Line

Client onboarding is the first experience someone has working with you. If it's slow, scattered, or silent, you're starting from a trust deficit that takes months to climb out of.

Automate the handoff. Keep the human touch where it matters. And stop losing clients in week one over something a Zapier workflow could handle in 60 seconds.

Building automation playbooks for small businesses. More at smb-scaleup.com.

Stop Installing Other People's AI Skills — Build Your Own

T.M. Gunderson — Thu, 24 Sep 2026 09:00:42 +0000

You've seen the lists. "10 AI Skills You Need Right Now." "Install These 5 Plugins and Watch Your Business Grow." Every week, someone drops a roundup of pre-built AI skills you should add to your workflow.

Here's the problem: pre-built skills are generic by design. They solve everyone's problems, which means they solve your problems — imprecisely.

The Generic Skill Trap

When a developer builds an AI skill for public distribution, they optimize for the widest possible audience. That means:

Vague triggers — "when a customer messages you" instead of "when a lead from Google Business Profile messages after hours"
One-size outputs — "write a professional reply" instead of "reply using your brand voice, reference your current promo, and log the lead in your CRM"
Missing context — No access to your pricing sheet, your service area, your scheduling rules

The result? You install a skill, it works okay, and you spend time manually fixing its output every time. That's not automation. That's a new kind of busywork.

What Building Your Own Actually Means

Building a custom AI skill sounds intimidating. It isn't. You're not writing software. You're writing instructions — the same kind of instructions you'd give a new employee.

A custom AI skill is just a structured prompt that tells your AI assistant:

When to act — The specific trigger (e.g., "a new review appears on my Google Business Profile")
What to do — The exact steps (e.g., "analyze the sentiment, draft a personalized response, and flag if it's negative")
How to sound — Your brand voice, tone, and formatting rules
What to reference — Your pricing, policies, service descriptions

A Practical Example

Say you run a landscaping company. A generic "customer response" skill might generate bland replies like "Thank you for your feedback."

A custom skill you build yourself:

Recognizes the service mentioned (lawn care, hardscaping, irrigation)
References your seasonal availability and current wait times
Uses your brand tone (friendly, not corporate)
Automatically categorizes the lead by service type and urgency
Flags any mention of competitors for follow-up

Same trigger. Completely different result. The generic skill saves you 30 seconds. The custom skill saves you 5 minutes and produces a better outcome.

How to Start

Step 1: Identify your highest-volume repetitive task. Not the most complex one. The one you do most often. Customer replies, estimate follow-ups, review responses — pick one.

Step 2: Write down how you do it now. Not how a tutorial says to do it. How you actually do it. Your steps, your language, your exceptions.

Step 3: Turn that into a skill. Most AI platforms (Claude, ChatGPT, Gemini) let you save custom instructions or projects. Paste your process in. Add your business specifics. Test it on 10 real cases.

Step 4: Iterate. The first version won't be perfect. Adjust the instructions based on what it gets wrong. After 2-3 rounds of fixes, you'll have something that works better than any downloaded plugin.

The Real ROI

A generic AI skill saves you the time of writing a prompt from scratch. A custom AI skill saves you the time of fixing a generic output. That difference compounds.

When you build your own:

You own the logic — no vendor changes breaking your workflow
You control the quality — every output matches your standards
You can evolve it — as your business changes, your skill changes with it

Pre-built skills are training wheels. Useful for learning what's possible. But at some point, you need to ride on your own.

Your business is unique. Your AI should be too.

Building custom AI workflows for your small business? SMB Scale Up helps you design automation that fits — not force-fits.

The AI Price War Is Your Cost Window

T.M. Gunderson — Thu, 24 Sep 2026 09:00:11 +0000

The smartest AI model lost to the cheapest one. That's the headline from this week's AI pricing data, and it's the most important thing happening in small business technology right now.

What Just Happened to AI Prices

In one week:

Gemini 3.7 Flash launched at half its predecessor's price
DeepSeek V4-Pro moved to off-peak pricing at 50% of normal cost
Grok 4.6 matched GPT-5.6 Sol's capability at lower per-task pricing
OpenAI previewed 14x faster inference (which effectively cuts per-task cost dramatically)
Anthropic's Fable 5 is the most capable model — and gets only 6% of business tokens

The pattern is clear: capability is commoditizing. Price is winning.

Why This Matters for Your Small Business

Six months ago, the AI tools that could genuinely automate your operations — dispatch, customer communication, scheduling, document processing — were priced for enterprise budgets. A small plumbing company or dental practice couldn't justify $200/month per AI agent when the ROI was uncertain.

That math just flipped.

When models cost 50% less to run, the tools built on top of them cost less too. The AI receptionist that was $300/month is now $150. The document processor that was $500/month is now $250. The gap between "nice to have" and "must have" just got cut in half.

The Cost Window Is Open — But It Won't Stay Open Forever

Price wars happen in cycles. Here's what the pattern looks like:

Competition drives prices down (we're here now)
Consolidation happens — two or three providers dominate
Prices stabilize or rise — the winners have pricing power
New disruption starts the cycle again

You're in step 1. That's the cost window. It could last 12–18 months before consolidation starts pushing prices back up.

What to Do Right Now

Audit your monthly AI spend. If you're paying 2025 prices for any AI tool, you're overpaying. Check whether your provider has moved to a cheaper model tier.

Start the automation you've been putting off. The ROI math that didn't work at $200/month works at $100/month. The customer service bot, the appointment reminder system, the proposal generator — pick one and start this month.

Don't chase the cheapest model. This isn't about finding the lowest per-token price. It's about finding the tool that solves your actual business problem at a price that makes the ROI obvious. Cheap and useless is still useless.

Lock in annual pricing if you can. If a tool you need is offering annual pricing at current rates, take it. Prices will stabilize, and you want to be locked in at the low point.

Measure the ROI from day one. Every AI tool should answer: "How many hours does this save, and what's that worth?" If a $100/month tool saves 5 hours of admin work at $30/hour, that's $150/month in value. The math works. Track it.

The Bottom Line

The AI price war isn't a tech story. It's a small business opportunity story. The tools that were "someday" purchases six months ago are "this month" purchases now. The cost window is open. Use it.

Stop Writing Proposals by Hand — This n8n Workflow Turns Lead Data into Polished Proposals in Minutes

T.M. Gunderson — Wed, 23 Sep 2026 15:51:32 +0000

You get a lead at 2 PM. By the time you've gathered requirements, written the proposal, formatted it, had someone proofread it, exported the PDF, and emailed it — it's Thursday. The lead has already talked to three competitors who responded faster.

Speed wins deals. Not flashy designs. Not 40-page documents. Speed.

According to a Zendesk benchmark, responding to a lead within an hour makes you 7x more likely to qualify them. Most small businesses take 2–3 days to send a proposal. That's 2–3 days of the client shopping around, forgetting about you, or going with the first responder.

The fix isn't hiring a proposal writer. It's automating the mechanical parts so you can focus on the 20% that actually requires human judgment.

Here's an n8n workflow that takes submitted lead data, generates a formatted proposal document, creates a PDF, and emails it to the prospect — all within minutes of their initial inquiry.

The Problem: Proposals Are 80% Boilerplate

Look at your last 10 proposals. I'll bet they share 80% of the same structure:

Introduction and company overview
Scope of work (with a few line items swapped)
Pricing section (pulled from a rate card)
Timeline and milestones
Terms and conditions
Next steps

The only parts that change per proposal are the client name, specific deliverables, pricing for their scope, and timeline. Everything else is copy-paste — and copy-paste is exactly what automation should handle.

When you write proposals manually, you're spending 4–5 hours on what should take 30 minutes of review and 2 minutes of generation.

The Architecture: Lead Form to Sent Proposal

Here's the end-to-end flow:

Webhook Trigger (lead form submission)
  → Validate and enrich lead data
  → Look up pricing from rate card (Google Sheets)
  → Select template based on service type
  → Populate proposal template (Docu-templating or Google Docs)
  → Generate PDF
  → Send proposal email to prospect
  → Log proposal to CRM/tracking sheet
  → Notify team in Slack
  → Schedule follow-up reminder (3 days)

The entire pipeline runs in under 5 minutes from form submission to proposal in the client's inbox.

Step 1: Webhook Trigger — Catch the Lead

Start with a Webhook node that receives form submissions from your lead intake (Tally, Typeform, or a custom form).

{
  "node": "Webhook",
  "parameters": {
    "httpMethod": "POST",
    "path": "generate-proposal",
    "responseMode": "lastNode"
  }
}

The webhook receives a payload like:

{
  "name": "Jordan Rivera",
  "email": "jordan@riveraconsulting.com",
  "company": "Rivera Consulting Group",
  "service": "monthly-retainer",
  "budget_range": "5000-10000",
  "notes": "Looking for ongoing marketing support, 6-month engagement"
}

Validate the basics right away — required fields present, email format valid. If validation fails, send a polite error response and skip the rest of the workflow. No point generating a proposal for an incomplete lead.

Step 2: Look Up Pricing from Your Rate Card

Connect a Google Sheets node that reads your rate card. This is where you maintain your pricing by service type, tier, and any add-ons.

Your rate card sheet might look like:

Service	Tier	Monthly Price	Setup Fee	Deliverables
monthly-retainer	standard	$3,500	$1,000	Strategy + 12 posts/mo
monthly-retainer	premium	$6,000	$2,000	Strategy + 20 posts + ads
project-based	standard	$5,000	—	Audit + report
project-based	premium	$8,500	—	Audit + report + implementation

The workflow matches the service field from the form to the rate card, then picks the tier based on the budget_range. This means your proposals always reflect current pricing — update the sheet once, and every proposal from that point forward uses the new numbers.

No more "oops, I quoted last year's rate."

Step 3: Generate the Proposal Document

Use an HTTP Request node or a document-generation service (like Docu-templating or the Google Docs API via n8n) to populate your proposal template.

The template has placeholders like {{client_name}}, {{company_name}}, {{scope_description}}, {{monthly_price}}, {{setup_fee}}, and {{deliverables}}. The workflow maps the lead data and rate card lookup results into these fields.

Here's the key design decision: keep the template simple and modular. Three sections max — scope, pricing, and next steps. Clients don't read 15-page proposals. They read the pricing page and the deliverables bullet list. Optimize for that reality.

If you're using Google Docs as your template engine, the n8n Google Docs node can duplicate a template document and perform find-and-replace operations on the copy:

{
  "node": "Google Docs - Copy Template",
  "parameters": {
    "operation": "copy",
    "fileId": "YOUR_TEMPLATE_FILE_ID",
    "name": "Proposal - {{company_name}} - {{date}}"
  }
}

Then a follow-up node replaces the placeholders:

{
  "node": "Google Docs - Replace Placeholders",
  "parameters": {
    "operation": "replaceAll",
    "fileId": "{{$('Copy Template').json.id}}",
    "replacements": [
      { "find": "{{client_name}}", "replace": "={{$json.name}}" },
      { "find": "{{company_name}}", "replace": "={{$json.company}}" },
      { "find": "{{monthly_price}}", "replace": "={{$('Rate Card').json.monthly_price}}" },
      { "find": "{{deliverables}}", "replace": "={{$('Rate Card').json.deliverables}}" }
    ]
  }
}

Step 4: Create the PDF

Use a PDF conversion node. If you went the Google Docs route, n8n's Google Drive node can export as PDF:

{
  "node": "Google Drive - Export PDF",
  "parameters": {
    "operation": "download",
    "fileId": "{{$('Copy Template').json.id}}",
    "mimeType": "application/pdf"
  }
}

If you prefer self-hosted document generation, the n8n-nodes-document-generator community node or a simple Puppeteer-based microservice work well. The key is getting a clean PDF with your branding — logos, colors, fonts.

Step 5: Send the Proposal Email

Use the Send Email node (or Gmail/SMTP node) to deliver the proposal:

{
  "node": "Send Email",
  "parameters": {
    "fromEmail": "proposals@smbscaleup.com",
    "toEmail": "={{$json.email}}",
    "subject": "Your Proposal from SMB Scale Up — {{$json.company}}",
    "body": "Hi {{$json.name}},\n\nThanks for reaching out. We've put together a proposal based on your requirements.\n\nPlease find it attached. We'd love to chat through the details — feel free to book a call at your convenience.\n\nBest,\nThe SMB Scale Up Team",
    "attachments": "={{$('Export PDF').json.data}}"
  }
}

Keep the email short. The proposal PDF does the heavy lifting. The email's only job is to get the attachment opened.

Step 6: Log and Notify

Two final nodes:

Google Sheets — Log Proposal: Append a row to your proposal tracking sheet with the client name, service, price, date sent, and status ("sent").
Slack — Notify Team: Post a message to your sales channel: "NewProposal sent to {{$json.company}} — {{$json.service}} @ {{$json.monthly_price}}/mo"

This gives your team visibility without anyone having to remember to update a spreadsheet manually.

Step 7: Schedule the Follow-Up

Add a Wait node set to 3 days, then a follow-up email:

Wait (3 days)
  → Send follow-up email ("Checking in on your proposal...")
  → Update tracking sheet status to "followed-up"

Three days is the sweet spot — long enough that they've read the proposal, short enough that you're still top of mind. Most small businesses never follow up on proposals. Automating the follow-up alone puts you ahead of 80% of your competitors.

The ROI: Hours Back, Deals Closed Faster

Here's what this workflow delivers:

Metric	Manual Process	Automated Workflow
Time from lead to proposal	2–3 days	5 minutes
Hours per proposal	4–5 hours	15 minutes (review only)
Follow-up consistency	Maybe	Always, day 3
Pricing accuracy	Manual lookup	Rate card synced
Proposal tracking	Spreadsheet you forget to update	Automatic logging

At 10 proposals per month, that's 35–40 hours reclaimed. And faster proposals mean more deals — not just because you're first, but because you're responsive. Responsiveness signals professionalism. Professionalism wins contracts.

Getting Started

Build your rate card in Google Sheets first. This is the single most important piece — if your pricing is messy, your proposals will be messy regardless of automation.
Create a clean proposal template. Three sections: what you'll do, what it costs, what happens next. That's it. Don't overcomplicate the template.
Set up your lead form. Make sure it captures service type and budget range — those two fields drive the entire proposal generation.
Build the workflow in stages. Start with webhook → template → PDF → email. Add the rate card lookup and follow-up scheduling once the core pipeline works.
Review every proposal before it goes out. Automation handles the boilerplate. You handle the 20% that needs a human touch — custom scope adjustments, relationship-building language, strategic pricing decisions.

The goal isn't to remove yourself from proposals entirely. It's to remove the 80% that's pure mechanical repetition so you can spend your time on the parts that actually close deals.

Have questions about setting up proposal automation for your business? Drop a comment — happy to share more specifics on the n8n configuration.

How an AI Agent Handled 66% of a Support Inbox — And How Yours Can Too

T.M. Gunderson — Wed, 23 Sep 2026 15:51:01 +0000

Your support inbox is eating your mornings. Every day, you start with 20, 50, 100 emails — most of them the same questions you've answered a hundred times. What if an AI agent could read, triage, draft replies, and only escalate the tricky ones to you?

That's not hypothetical. Nate B Jones recently gave an AI agent full access to his customer support inbox. The result: two-thirds of the work disappeared. Not a chatbot on a website — an actual agent that reads inbound messages, sorts them, drafts responses, and flags what it can't handle.

Here's how to replicate that for your business.

The Difference Between a Chatbot and an Agent

Most businesses that have tried "AI for support" installed a website chatbot. It answers FAQs and not much else. That's Level 0.

An AI agent is different. It:

Reads every incoming email or message
Classifies it (billing question, feature request, bug report, complaint)
Drafts a response using your brand voice and policies
Sends routine replies autonomously
Escalates anything ambiguous, angry, or high-value to a human

Think of it as a front-line support employee who works 24/7 and costs a few dollars a month.

Step 1: Audit What's Actually in Your Inbox

Before setting anything up, sort your last 200 support emails into categories. You'll find that 60-70% fall into 5-8 recurring patterns:

"Where's my order?"
"How do I reset my password?"
"Can I change my subscription?"
"What's your refund policy?"
"I need an invoice for last month"

Write these down. These are your agent's bread and butter.

Step 2: Build a Decision Tree

For each recurring category, define:

What the agent should do — draft a reply, pull data from your system, forward to a specific person
What information it needs — order lookup, account status, policy text
When to escalate — any hint of legal threat, any amount over $500, any VIP customer

This is your playbook. The agent follows it; humans handle the exceptions.

Step 3: Connect Your Tools

Your agent needs access to:

Your inbox (Gmail, Outlook, or helpdesk like Zendesk/Help Scout)
Your business data (order status, subscription info, refund eligibility)
Your brand voice (a short style guide: "We say 'we' not 'I', we're warm but concise, we never promise refunds without manager approval")

Most modern AI platforms (OpenAI, Anthropic, or agentic tools like Lindy, Relevance AI, or even Zapier + ChatGPT) can connect to these via API or built-in integrations.

Step 4: Start in Shadow Mode

Don't let the agent reply to customers on day one. Run it in shadow mode first:

The agent reads and drafts replies
You review every draft before it goes out
You correct mistakes and feed those corrections back as training

Do this for 1-2 weeks. You'll see the agent improve fast. When it's getting 90%+ of drafts right without edits, turn on autonomous mode for the easy categories.

Step 5: Handle the 33%

The agent won't handle everything. That's fine — it's not supposed to. The goal is to remove the bottom two-thirds so you can focus your human attention on:

Complex account issues
Escalations from unhappy customers
Strategic conversations
Anything the agent flags as uncertain

Set up a clear escalation inbox or Slack channel. When the agent is unsure, it routes the message there with a note: "I think this is a billing dispute, but the customer is upset. Over to you."

What This Costs

A support hire in North America runs $35-50K/year. An AI agent handling 66% of that workload costs roughly $50-200/month depending on volume and platform. The ROI speaks for itself.

Even if you only automate password resets, order status checks, and refund policy questions — that's easily 30-40% of a typical SMB inbox. Time you get back every single day.

The Setup Checklist

[ ] Categorize your last 200 support emails
[ ] Identify the top 5-8 recurring patterns
[ ] Write a decision tree for each (action → data needed → escalation trigger)
[ ] Choose a platform (OpenAI custom GPT, Lindy, Relevance AI, or Zapier + ChatGPT)
[ ] Connect your inbox and business data
[ ] Write a 1-page brand voice guide
[ ] Run in shadow mode for 1-2 weeks
[ ] Review and correct agent drafts daily
[ ] Enable autonomous mode for easy categories
[ ] Monitor escalation quality weekly

Start with one category. Get it working. Add the next one. Before you know it, your mornings are yours again.

Your support inbox shouldn't be the thing that owns your schedule. Set up an AI agent to handle the routine stuff — and keep the conversations that actually need a human touch.