This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

PlainSight is a command-line tool that runs a passive security checkup on a small business's website and produces a plain-English report written entirely by a local open-weight model. No cloud APIs. No client data leaves the machine.

bun plainsight.ts checkup example-business.com

Who would pay for it? CPAs, law firms, dentists, contractors, realtors — the small businesses that handle sensitive client data all day and have no IT department. They can't afford a penetration test ($5k+), but they can afford a one-page "here's what's wrong with your website, in English" report for $49–129. That's the side hustle: run the tool, deliver the report, offer a quarterly recheck.

The tool checks the things that actually matter at that scale:

• TLS certificate health and expiry
• Security headers (CSP, HSTS, X-Frame-Options, and friends)
• Email spoofing protections (SPF/DMARC) — the #1 way small businesses get impersonated
• Accidentally exposed files (.git, .env, config backups)
• HTTP→HTTPS redirects, mixed content, cookie flags
• Whether a security.txt exists so researchers can report problems responsibly

Every check is passive — the same requests any browser makes. There's an explicit ethics section in the README: you only scan sites you own or have written permission to test.

The scan produces structured findings, and then the interesting part happens: a local model writes the report. Not a template — an actual readable document, prioritized into "Fix these first," "Worth fixing soon," and "Good to know," in language a dentist's office manager understands.

Demo

Real run against my own other project's demo site (more on that below):

The full artifacts from that run:

• 📄 Sample report (written locally by an open-weight model)
• 🔍 Raw findings JSON the report was generated from

Code

bun plainsight.ts checkup example.com

The whole thing is one TypeScript file (~250 lines) running on Bun, with zero npm dependencies. Deliberately boring: the scanner is deterministic code, the model only does the writing.

How I Built It

Two halves, each doing what it's good at:

The scanner is code, not AI. All checks are plain TypeScript: fetch the page, inspect headers and TLS, probe a short list of well-known sensitive paths, query DNS TXT records for SPF/DMARC. Deterministic, auditable, no hallucination risk in the findings. A security tool that invents vulnerabilities is worse than useless.

The report writer is an open-weight model via Ollama. The scanner hands the model the structured findings JSON plus a prompt that demands plain English, calm tone, and no alarmism. Default model is llama3.1:8b; I also ran it on gemma3 — any Ollama model works via one env var:

OLLAMA_MODEL=gemma3:1b bun plainsight.ts checkup example.com

The model never sees anything except the findings list — no cookies, no page bodies, nothing sensitive beyond "this header is missing." The report ends with a footer stating exactly which model wrote it and that no data left the machine. Transparency is the product.

Why Does Open Innovation Matter?

This project only works because the model is open and runs locally. Three reasons, in order of how much they'd kill the business:

1. Confidentiality is the whole job. A security report is, by definition, a list of a client's weaknesses. If I generate that report by shipping the findings to a closed third-party API, I've just taken a small business's vulnerability inventory and handed it to infrastructure neither of us controls. As the person selling security, that's the one thing I can't do. A local open-weight model makes the ethically correct architecture also the easiest one to build.

2. Marginal cost is zero, so the price point works. At $49–129 per report, a per-token API bill is survivable but annoying — and it scales the wrong way. With a local model, the hundredth report costs exactly what the first one did: nothing. That changes what the business can be — free "first checkup" lead magnets, quarterly rechecks, batch runs across a whole book of clients, all without watching a meter.

3. No lock-in, no deprecation roulette. A closed provider can change pricing, deprecate a model, or decide my use case violates a policy revision. When the model is a file on my machine, the tool I sell today still works in two years, and I can swap llama3.1 for gemma3 for whatever comes next by changing one environment variable. The open ecosystem — Ollama, the open weights themselves, Bun — is the supply chain, and none of it can be taken away.

My First User

Me — and it caught real problems.

I maintain another open-source project, SolAudit (a security scanner for Solana programs, because apparently I only build one kind of thing), with a demo site at solaudit-web.vercel.app. PlainSight's first real scan was against it, and the report flagged missing Content-Security-Policy, HSTS, X-Frame-Options, X-Content-Type-Options, and Referrer-Policy headers — on the demo site of a security tool. Embarrassing? A little. Exactly the kind of finding a small business needs? Absolutely.

I fixed the headers in vercel.json, redeployed, and re-ran the checkup:

The only remaining finding is "no security.txt file" — fair enough, that's next. The before/after artifacts are in the repo's examples/ folder.

Did they pay? I invoiced myself $0 and left a tip jar full of lessons. But it validated the core promise: the tool finds real, fixable issues and explains them in language you'd actually act on. The first external user is the next step — the report format is the deliverable for a freelance checkup service I'm piloting with local small businesses.

Prize Categories

• Best Use of Gemma — Gemma 3 is a tested report-writer backend (OLLAMA_MODEL=gemma3:1b, verified end-to-end against the sample scan — Gemma wrote a complete plain-English report from the findings JSON), alongside Llama as the default. Open weights all the way down.

Built during the challenge window (October 14–15, 2026). Scanner: TypeScript + Bun, zero dependencies. Reports: open-weight models via Ollama. MIT licensed — if you want to run this side hustle in your own town, the repo is yours.