Big product ideas die in Notion. Small tools ship on a Thursday night.
That is not a productivity slogan. It is how MetaGrid, BulkFix, and the free utilities on my site actually started — not with a platform vision, but with a painful click I was tired of repeating for clients.
If you build Shopify and AI work from Karachi like I do, your calendar fills with client delivery. Side products only survive if the first version fits in an evening and runs without a backend. That is why I ship in-browser utilities first: a JSON formatter, a slug generator, a metafield validator — learn in public, steal back hours, notice which pain shows up twice.
The pattern: repeated pain → thin tool
Client work is a radar. The same friction across two or three stores is a product hint.
Examples that turned into something real for me:
- Bulk-editing metafields in Shopify admin is miserable → spreadsheet mental model → MetaGrid / BulkFix
- Visa document questions that need structured guidance → VisaChamp
- Pricing AI features on paper every kickoff → AI API cost calculator and the rest of the Playbook calculators
Notice what those share: a sharp job, a clear input, a clear output. Not “an AI platform for commerce.”
When I catch myself saying “someone should build X,” I put X on a sticky note. If the same sticky note appears after another project, it graduates from note to weekend spike.
Why in-browser first
A utility that runs entirely in the browser has unfair advantages for a solo builder:
- No auth to babysit. You are not resetting passwords at midnight.
- No server bill while you validate demand. Static hosting is enough.
- Privacy is easier to explain. Paste JSON, format locally, leave — nothing stored.
- Ship speed. HTML + a bit of JavaScript beats scaffolding an API, database, and deploy pipeline for a formatter.
- Fewer moving parts. No queue workers, no stale Redis, no “it works on my VPS.”
When the tool needs Shopify Admin API access or multi-user sync, you graduate. You do not start there.
BulkFix as a Chrome extension is the same philosophy: meet the merchant where they already work (the admin), keep the surface small, avoid boiling the ocean. MetaGrid took the next step into the App Store once the workflow proved sticky.
What I actually ship as “small”
A useful first cut is embarrassingly narrow:
| Tool shape | Job it steals | Done when |
|---|---|---|
| JSON / Liquid formatter | Stop pasting broken snippets into Slack | Pretty-print + basic validate |
| Handle / slug generator | Consistent product handles from titles | Unicode-safe, Shopify-ish rules |
| Metafield validator | Catch type mismatches before import | Schema vs sample row |
| Cost calculator | Stop hand-waving API spend | Model pick + volume → monthly $ |
| Chunk preview | See how a PDF will split for RAG | Character windows + overlap |
Each of those teaches you something about the domain. The metafield validator taught me which type mistakes merchants make. The API calculator taught me which defaults people wrong-guess (output tokens, retries). That learning compounds into better client proposals — and better paid products.
I keep a folder of “almost tools” that never shipped. That is fine. The point of small is cheap abandonment.
Learn in public without fake metrics
I publish tools and write about how I use them. I do not invent “10,000 merchants saved $2M” stories. Traffic and App Store installs tell their own story over time; until then, honesty travels further with the people you want as customers.
What I do share:
- The job the tool does
- The constraints (browser-only, no data stored, Shopify plan assumptions)
- What I will not build yet (and why)
- One screenshot of the happy path, not a fake dashboard full of vanity charts
That tone matches how I write this Playbook. Practical beats theatrical. If a tool is rough, I say it is rough. Merchants and founders have seen enough glossy landing pages that hide empty products.
How small tools feed client work (and the other way around)
Client projects subsidize product discovery. Products sharpen client delivery.
When a merchant asks for “AI on the store,” I can point at a calculator and a scoped pipeline instead of vibes. When three stores complain about metafield bulk edits, I already have scar tissue from MetaGrid. When document QA comes up, VisaChamp-shaped refuse-when-empty patterns transfer straight into support bots and internal ops tools.
The mistake is waiting until client work is “done” to start products. Client work is never done. Steal two hours a week for a thin tool instead. Put it on the calendar like a standup — same respect, smaller scope.
A one-evening build checklist
Before I open the editor:
- Name the job in one sentence. “Turn a product title into a Shopify handle.”
- Define done. Happy path + two failure messages. No settings page.
- Stay local. LocalStorage only if it clearly helps; prefer stateless.
- Make it linkable. A clean URL on the Playbook or main site beats a hidden CodePen.
- Write three lines of usage copy. If you cannot explain it, the scope is wrong.
- Ship ugly. Typography can wait. Correct output cannot.
- Add a “what this is not” line. It cuts support questions and keeps you honest.
After it ships, watch which link people actually open. Ignore vanity. If nobody returns, archive without guilt. If people keep pasting weird edge cases into your inbox, you found a wedge worth a second evening.
When to stop being “just a utility”
Promote the tool when:
- The same users ask for save/sync across devices
- You need authenticated access to Shopify or another API
- The workflow needs collaboration (roles, undo history, audit)
- Support volume suggests people depend on it weekly
That is how MetaGrid outgrew a personal script. Spreadsheet-style bulk metafield editing needed persistence, undo, and App Store distribution. The first insight was still a small, sharp pain.
Until those signals appear, resist the platform rewrite. A finished formatter beats a half-built “ops suite.” I have killed more rewrite projects than I have finished, and that is a feature.
Tie-in to the Playbook calculators
The calculators on this site are the same strategy applied to scoping:
- AI API cost calculator
- Agent ROI calculator
- RAG cost estimator
- Shopify build cost estimator
- Page speed revenue calculator
Each one started as “I am tired of doing this on a whiteboard.” Shipping them publicly forces clarity: inputs, assumptions, outputs. That clarity is the product. If a calculator cannot explain its assumptions in plain language, it is not ready — same bar as a client proposal.
Start this week
Pick one annoyance from your last client week. Give it a URL. Keep it in-browser. Tell one colleague.
You do not need permission, a brand deck, or a perfect design system. You need a sharp job and a Thursday night. If it helps you twice, publish it. If it helps strangers once, you already beat most “startup ideas” stuck in a doc.
I am Faraz Hussain — Shopify, React/Next.js, and AI automation from Karachi. The Playbook is where those small tools and the longer field guides live side by side. If a utility on your desk should exist on the open web, build the thin version first.