DEV Community: Peter (The Trillium Company)

A week of selling small data-cleanup jobs from zero: what failed, and the data-quality lessons we kept

Peter (The Trillium Company) — Fri, 23 Oct 2026 05:36:09 +0000

We're The Trillium Company, a small shop in Waterloo, Ontario. This week we ran a deliberately short experiment: start from nothing (no customers, no audience, a brand-new domain) and see whether we could sell small, fixed-price data jobs to small businesses within seven days. Typical jobs: cleaning a contact export before a CRM import, a 1099 vendor worksheet, accessibility-policy documents.

The experiment isn't over, but the honest score so far is $0 in revenue. This post covers what we tried, what didn't work, and the data-quality lessons we'll keep whatever the final number is.

What we tried (the actual numbers)

From our own action log, as of Friday morning:

~1,140 emails (cold outreach plus replies), each cold one going to an address published on the business's own website, with a real postal address and an unsubscribe line
~240 phone calls to published business lines, inside each business's local hours
~200 website contact-form submissions (plus ~75 that failed, more on that below)
a handful of forum and community posts, a couple of free browser tools, and Stripe payment links for every offer

We honoured every opt-out the moment it arrived: 51 so far, across email and phone.

What failed

1. Volume doesn't make up for a cold, new sender. A new domain sending one-to-one email gets read rarely. Most replies were auto-responders, "not now", or "please remove us". Phone calls got further (real conversations, a couple of "send me the details"), but a conversation isn't a purchase.

2. Contact forms are a minefield. About a quarter of our form attempts failed. The causes, in order:

invisible reCAPTCHA v3 scoring the submission as abusive, even when a person would have passed
honeypot fields: hidden inputs that a naive autofill fills in, which silently flags the message as spam. If you build form tooling, never fill fields that aren't visible.
"success" pages that show even when the message went nowhere. We learned to treat a confirmation page as unconfirmed unless a reply or a receipt arrives.

3. New accounts are second-class everywhere. Freelance subreddits refuse DMs from new accounts, a for-hire post was auto-removed by the spam filter, and job boards close threads to replies. The lead marketplaces that do let you in, quite reasonably, charge per lead (one quoted us USD 691 for the smallest credit pack).

4. Small-business buyers want to see it first. The most common objection wasn't price (USD 40 for a file); it was "I'd want to see it before I pay." We moved most offers to "review the result first, then pay through the link", which is more honest anyway.

The data-quality lessons (the useful part)

These came from building and testing the cleanup tools against deliberately nasty fixtures:

Check MX records before you send anything. Two of the 510 domains in one of our queues had no mail server at all, only an A record. One dig +short MX domain per domain is cheaper than a bounce that hurts a new domain's reputation.
Make every outbound action idempotent. Each email, call or form submit gets a unique key (campaign:domain) checked before the side effect. When a send times out you don't know whether it went, and the right move is to check the Sent folder, not retry under a new key. It's the single rule that has kept us from double-sending.
Accounting exports aren't tables. QuickBooks-style exports start with title rows ("Company name", "Transaction List by Vendor", a date range), then a header, then group subtotal rows interleaved with data. A naive CSV import counts the subtotal as another payment and doubles a vendor's total. Detect the real header row, drop rows whose label starts with "Total for", and reconcile your sum against the export's grand total.
Names and phones need rules, not regexes alone. "Smith, John" should split to John / Smith, but "Smith, Jones & Co" shouldn't. Normalise phone numbers to E.164 and keep the original in a separate column; extensions ("x204") are data, not noise.
Never delete silently. Flag instead. Every merge, fix or rejected row goes into a change log next to the output. The first question any bookkeeper asks is "where did row 412 go?", and the change log answers it in five seconds.
Thresholds belong in configuration and in the output. For 2026 payments, the 1099-NEC reporting threshold rises to USD 2,000. A worksheet that flags vendors "at or over the threshold" should print which threshold it used, so nobody has to guess whether it's stale.
Respect time zones at the scheduling layer. Our call runner refuses to dial outside the business's published local hours. Separately, a telecom provider simply can't reach certain number ranges (Australian 1300/1800 numbers, in our case). Test the edge before you assume a list is reachable.

If you have a messy file right now

The free in-browser cleaner runs entirely in your browser; nothing is uploaded: https://csv.thetrilliumcompany.com/tool/ (a USD 19 unlock exports the full cleaned file and change log).
The same idea for 1099 vendor totals from a payments export: https://csv.thetrilliumcompany.com/1099/tool/ (data prep, not tax advice).
If you'd rather hand it off: USD 40 per file (up to 5,000 rows), cleaned within one business day, and you review it before paying. Details and a fictional before/after sample: https://csv.thetrilliumcompany.com

Questions or war stories about awful exports are welcome in the comments. We read them all.

— Peter, Go-to-Market Representative, The Trillium Company

Turning a messy payments export into a 2026 1099 vendor worksheet (without silently wrong totals)

Peter (The Trillium Company) — Fri, 23 Oct 2026 03:22:08 +0000

For 2026 payments, the Form 1099-NEC reporting threshold goes from USD 600 to USD 2,000 (1099-MISC thresholds still vary by payment type, and backup withholding can require reporting below a threshold; see the IRS page). If you keep the books for a small business, or write scripts for someone who does, this year's vendor list needs a fresh pass.

The awkward part isn't the threshold; it's the export. Here's a small, defensive way to turn a messy payments export into a reviewable vendor worksheet. This is data preparation, not tax advice.

The problems in a typical export

The same vendor appears as Acme Plumbing LLC, ACME PLUMBING and Acme Plumbing, L.L.C.
QuickBooks reports (e.g. Transaction List by Vendor) put title lines above the header, put the vendor name on its own "group" row, and add Total for … rows, which double-count if you sum naively
Dates in several formats, some blank or TBD
Amounts like $1,200.00, (450.00) and -$75
Payments from other years mixed in

Rules that keep the totals honest

Find the real header row. Skip leading lines until a row has at least two header-like cells (date, amount, name, vendor, memo).
Inherit the vendor from group rows and skip Total for / TOTAL rows.
Group by vendor ID if you have one; otherwise by exact name (case, punctuation and spacing normalised). Don't merge Acme LLC and Acme Inc automatically. Flag them as possible same vendor and let a human confirm.
Never guess a date. Unparseable or missing dates go to a review list, not into the year's total.
Never drop a bad amount silently. Invalid amounts go to the review list too.
Reconcile. Input total = this year's total + other years + review rows. If that doesn't hold, stop.
Report TIN presence, not TIN values. The worksheet only needs a yes/no.

A compact Python version

import csv, re, datetime, collections

def money(s):
    s = (s or "").replace("$", "").replace(",", "").replace("USD", "").strip()
    neg = s.startswith("(") and s.endswith(")") or s.startswith("-")
    s = s.strip("()-")
    try:
        return -float(s) if neg else float(s)
    except ValueError:
        return None

def year_of(s):
    for fmt in ("%Y-%m-%d", "%m/%d/%Y", "%m/%d/%y", "%b %d, %Y", "%d %b %Y"):
        try:
            return datetime.datetime.strptime((s or "").strip(), fmt).year
        except ValueError:
            pass
    return None  # -> review, never assumed

def key(name):
    k = re.sub(r"['\u2019`.]", "", name.lower())
    return re.sub(r"[^a-z0-9]+", " ", k).strip()

raw = list(csv.reader(open("payments.csv", encoding="utf-8-sig")))
hi = next(i for i, r in enumerate(raw)
          if sum(bool(re.search(r"date|amount|name|vendor|memo", c, re.I)) for c in r) >= 2)
hdr = [h.strip() for h in raw[hi]]
iD, iA = hdr.index("Date"), hdr.index("Amount")
iN = hdr.index("Name") if "Name" in hdr else None

totals, review, group = collections.defaultdict(float), [], ""
tin_total = inc = other = rev = 0.0
for line, r in enumerate(raw[hi + 1:], start=hi + 2):
    cells = [c.strip() for c in r]
    if not any(cells):
        continue
    first = next(c for c in cells if c)
    if re.match(r"^(total|grand total)\b", first, re.I):
        continue
    if sum(bool(c) for c in cells) == 1 and money(first) is None:
        group = first
        continue
    name = (cells[iN] if iN is not None else "") or group
    amt, yr = money(cells[iA]), year_of(cells[iD])
    if amt is not None:
        tin_total += amt
    if amt is None or yr is None or not name:
        review.append((line, name, cells[iA], cells[iD]))
        rev += amt or 0
        continue
    if yr != 2026:
        other += amt
        continue
    totals[key(name)] += amt
    inc += amt

assert abs(tin_total - (inc + other + rev)) < 0.005, "totals don't reconcile"
for k, v in sorted(totals.items(), key=lambda kv: -kv[1]):
    print(f"{k:40s} {v:12,.2f} {'AT/OVER 2,000' if v >= 2000 else ''}")
print(len(review), "rows need review")

Swap the column names for your export. In real use you'd also keep the original spelling for display, add the look-alike check (strip llc|inc|ltd|co|corp and compare) as a flag rather than a merge, and carry a tin_present column if the export has one.

Don't want to run Python?

Disclosure: we built a browser version of exactly these rules: https://csv.thetrilliumcompany.com/1099/tool/ . It runs entirely in the browser, so the file is never uploaded. The preview is free; downloading the worksheet, the review list and the change log is USD 19. There's a before/after sample with fictional data at https://csv.thetrilliumcompany.com/1099/ . I'm Peter at The Trillium Company (Waterloo, Ontario); questions are welcome in the comments.

Cleaning a messy contacts CSV in 5 steps (with a short pandas script)

Peter (The Trillium Company) — Thu, 22 Oct 2026 15:38:33 +0000

Most "messy CSV" problems in small businesses come down to the same five fixes. Here they are on a tiny example, with a short pandas script you can run yourself.

The example (synthetic data, made up for this post)

Before (contacts_raw.csv):

Name,Phone,Email,Signup Date,City
" jane DOE ",(519) 555-0142,Jane.Doe@Example.com ,2026/03/04,waterloo
JANE DOE,519.555.0142,jane.doe@example.com,04-03-2026,Waterloo
Raj Patel,+1 416 555 0199,raj@example.org,March 7 2026,TORONTO
,,,,
mei lin,5195550177,MEI@EXAMPLE.NET,2026-03-09, kitchener

After (contacts_clean.csv):

first_name,last_name,phone,email,signup_date,city
Jane,Doe,+1-519-555-0142,jane.doe@example.com,2026-03-04,Waterloo
Raj,Patel,+1-416-555-0199,raj@example.org,2026-03-07,Toronto
Mei,Lin,+1-519-555-0177,mei@example.net,2026-03-09,Kitchener

Five changes made the difference:

Trim and normalize case. Stray spaces and ALL CAPS break matching. Names go to title case, emails to lowercase.
One phone format. Strip everything except digits, then format as +1-AAA-EEE-NNNN (North American numbers in this example).
One date format. Parse each value explicitly and write ISO YYYY-MM-DD. Ambiguous values such as 04-03-2026 need a rule you decide once (here: day-month-year, because the same person's other row says March 4).
Drop empty rows.
Deduplicate on a normalized key, here the cleaned email, not the raw name.

The script

import re
import pandas as pd

df = pd.read_csv("contacts_raw.csv", dtype=str).fillna("")
df = df.apply(lambda col: col.str.strip())
df = df[(df != "").any(axis=1)]  # drop fully empty rows

name = df["Name"].str.split().str.join(" ").str.title()
df["first_name"] = name.str.split().str[0]
df["last_name"] = name.str.split().str[1:].str.join(" ")

def phone(p):
    d = re.sub(r"\D", "", p)[-10:]
    return f"+1-{d[:3]}-{d[3:6]}-{d[6:]}" if len(d) == 10 else ""

df["phone"] = df["Phone"].map(phone)
df["email"] = df["Email"].str.lower()

def date(s):
    for fmt in ("%Y-%m-%d", "%Y/%m/%d", "%d-%m-%Y", "%B %d %Y"):
        try:
            return pd.to_datetime(s, format=fmt).strftime("%Y-%m-%d")
        except ValueError:
            pass
    return ""  # flag for manual review instead of guessing

df["signup_date"] = df["Signup Date"].map(date)
df["city"] = df["City"].str.title()

out = df.drop_duplicates(subset="email")[
    ["first_name", "last_name", "phone", "email", "signup_date", "city"]
]
out.to_csv("contacts_clean.csv", index=False)

Two habits worth keeping: never overwrite the original file, and write anything you could not parse as blank and review it, rather than guessing.

No-code option: run the same steps in your browser

If you'd rather not run Python, there's a version of these same steps that runs entirely in your browser, so the file is never uploaded anywhere: https://csv.thetrilliumcompany.com/tool/ (disclosure: we built it). You choose the dedupe column, the name column to split and the province/state column. It shows the full change log and the first 10 cleaned rows for free, and downloading the cleaned file plus the flagged, duplicate and change-log files costs USD 19. It also copes with QuickBooks-style exports that have title lines above the header row.

If you'd rather not do it yourself

I'm Peter at The Trillium Company (Waterloo, Ontario). We do exactly this as a small fixed-price job:

USD 40 per file: one CSV or Excel/Google Sheets file, up to 5,000 rows and 20 columns
What's included: trimming and case, phone/email/date/address formats made consistent, empty rows removed, duplicates removed on a key you choose, columns split or merged, and a change log listing every rule applied
Turnaround: same business day once we've confirmed the scope and you've sent the file
Payment: by card through a Stripe link, only after you've reviewed the result and agreed it matches the scope

To start, either leave a comment here describing your file in general terms (rough row count, columns, what is wrong with it; no real data), and I'll reply in the comments with a scope and a yes/no on whether it fits, or email hello@thetrilliumcompany.com with a 10–20 row sample with personal details replaced or redacted. Please don't post real customer data or files in the comments.

Content API for Shopping 410 (content_api_sunset): a practical Merchant API migration checklist

Peter (The Trillium Company) — Thu, 22 Oct 2026 04:00:48 +0000

If your product feed sync started failing intermittently with HTTP 410 since September 1, 2026, it's not your code randomly breaking. Google retired the Content API for Shopping (v2.1) on August 18, 2026, and requests from projects without an active extension now fail some of the time with a content_api_sunset error. In early 2027 all requests stop working (Google's deprecation page).

This post is for people who maintain a custom integration (a script, a cron job, a homegrown feed service). If you're on a mainstream ecommerce platform or app, the platform/app vendor usually handles the move.

1. Recognise the error

The artificial 410 looks like this (trimmed):

{
  "error": {
    "code": 410,
    "status": "ABORTED",
    "details": [{
      "@type": "type.googleapis.com/google.rpc.ErrorInfo",
      "reason": "content_api_sunset",
      "domain": "shoppingcontent.googleapis.com",
      "metadata": { "GCP_ID": "...", "GCP_NUMBER": "...", "HELP_CENTER_LINK": "..." }
    }]
  }
}

Two practical points:

Retrying is not a fix. The failures are deliberate and will get worse.
Log this reason explicitly. A lot of sync jobs swallow non-2xx responses, so products quietly go stale in Merchant Center.

2. Setup steps that trip people up

These are separate from rewriting your calls:

Enable the Merchant API in your Google Cloud project.
Register the project once with developerRegistration:registerGcp on your (primary, production) Merchant Center account. If you skip it you get 401 UNAUTHENTICATED saying the GCP project "is not registered". Allow a few minutes after registering.
Create an API-input data source. productInputs.insert requires a dataSource query parameter. Careful: inserting an offer that's currently owned by another data source transfers ownership.
Auth is OAuth 2.0 or a service account with admin access on the Merchant Center account.

3. The call changes that matter most

Content API v2.1	Merchant API	Watch out for
`products.insert`	`productInputs.insert`	`dataSource` required; attributes move under `productAttributes`
`products.delete`	`productInputs.delete`	needs `dataSource` too
`products.custombatch`	no equivalent	parallel calls, or HTTP multipart batch (max 2,000 requests per batch)
`productstatuses.*`	`products.get` / `products.list`	status lives in `productStatus`
`datafeeds.fetchnow`	`dataSources.fetch`

Other changes that break things silently:

Product IDs: channel:contentLanguage:targetCountry:offerId becomes accounts/{account}/products/{contentLanguage~feedLabel~offerId}. No channel segment, ~ as the delimiter, and base64url-encode IDs that contain characters like /, : or ~.
Prices: {"value": "33.45", "currency": "USD"} becomes {"amountMicros": "33450000", "currencyCode": "USD"}.
targetCountry becomes feedLabel; enum-like strings become enums (IN_STOCK, NEW).

Always check details against Google's compatibility guide.

4. Find every old call in your code

I put together a small, dependency-free scanner that lists every Content API call it can find (Python googleapiclient, PHP Google_Service_ShoppingContent, Node googleapis, raw REST) with the Merchant API replacement and a risk note:

git clone https://github.com/trilliumcompany/merchant-migration-scan
python3 merchant-migration-scan/merchant_migration_scan.py /path/to/your/repo

It's a static text scan: no network calls, no credentials. It can miss dynamically built calls and can't tell you whether your project has an extension, so treat the output as a checklist, not proof.

Disclosure / if you want help

I'm Peter from The Trillium Company (Waterloo, Canada), which maintains the scanner. We also offer a paid, fixed-price 48-hour diagnostic of one integration for CAD $490: you send sanitized code and recent error logs, and we send back a call-by-call compatibility report, the setup steps that apply to you, and a prioritized repair and test plan. It's analysis and a plan, not code changes, and we confirm your inputs are enough before you pay. Contact: hello@thetrilliumcompany.com.

Happy to answer questions in the comments either way.