Browser Extension Development

The shortcut: Don't build $500 Chrome extensions. Build AI-integrated MV3 extensions for SaaS companies and internal business tools at $3,000-$8,000 — and put a $250-$500/month maintenance retainer on every one.

Industry: Software & Tech | Investment level: Small — $2,000-$8,000 | Time to launch: 4-8 weeks (LLC + first published extension + 1-2 paying clients gate the launch) Best for: A working JavaScript/TypeScript developer who's shipped a frontend before and is comfortable reading Chrome's developer docs end-to-end. You're a fit if you can ship a Manifest V3 extension with a service worker, a content script, and an OpenAI or Anthropic API call without hand-holding — and you're willing to talk to clients instead of just code. What you'll likely make: $1,500-$3,000 month 3, $3,500-$6,000 month 6, $6,000-$10,000 month 12. Math is in Section 4.

Market Opportunity

Most frontend developers leave $5,000-$8,000 browser extension projects sitting on the table because they assume extensions need a separate tech stack to learn. They don't. The Chrome Web Store runs on the same JavaScript and TypeScript you already write — the only real difference is the MV3 manifest and a service worker instead of a persistent background page. The devs quoting $500 for extension work aren't underqualified, they're just underselling work that SaaS companies and internal tools teams are paying $3,000-$8,000 to get done right.

The Chrome Web Store one-time developer fee is $5 (devconsole). That's the entire platform overhead. No annual Apple Developer fee, no app-store revenue cut, no native build chain.

The wedge right now is AI integration. Roughly 78% of new Chrome extension projects on freelance boards in 2025 include an OpenAI, Anthropic, or local-LLM feature — summarization, page extraction, smart auto-fill, in-context chat. A solo dev who ships an MV3-compliant extension with a clean OpenAI integration in 2-4 weeks commands $3,000-$8,000. Devs still quoting basic MV2-era extensions get $500-$1,000 for similar effort.

Two real buyers: (1) businesses that want an internal tool — a Chrome extension that pulls CRM data and overlays it on Salesforce or Zendesk, and (2) SaaS founders who want a companion extension as a distribution channel (text capture into Notion, page summarization, autofill for HR or legal SaaS). Behind both: steady MV2-to-MV3 migration work after Google's public-store MV2 sunset (MV3 migration checklist).

Launch With AI

Pro section. AI is the entire reason an extension that used to take 4 weeks ships in 10 days at $4,000. Cursor scaffolds the WXT project, drafts the manifest, generates the OpenAI integration handler, and writes the privacy policy. You spend the saved time where AI cannot help: testing on a real Chrome profile with 8 other extensions installed, walking the client through host permissions without scaring them, and answering Google's "explain why your extension needs activeTab" follow-up email that decides whether you ship next Monday or in 3 weeks.

The trap most first-year extension devs fall into: they assume Cursor knows MV3. Cursor confidently generates persistent background pages, remotely hosted code patterns, and webRequest blocking — all of which Google rejects on review. AI is for the manifest boilerplate, the content script scaffolding, the AI integration code, and every word you write to the client and the Chrome reviewer — but every host-permission request, every storage-API choice, every server-side proxy decision gets your eyes on it.

Important up-front: AI cannot read the Chrome Web Store reviewer's mind, predict whether Google rejects activeTab vs , or fix the LinkedIn DOM change at 9pm when your client's outreach extension breaks. It will also confidently embed an OpenAI API key in the extension bundle — which Google will reject AND which leaks the key to anyone who unpacks the .crx. You own every host-permission decision, every API-key handling pattern, every Chrome Web Store submission; AI scales the boilerplate and the client docs.

AI Tools You'll Use

Tool	Price	What it does
ChatGPT Plus	$20/mo	Store listing copy, privacy policy first drafts, client emails, sales follow-ups
Claude Pro	$20/mo	Long-context manifest review, multi-content-script architecture analysis
Cursor + Copilot Business	$40-$60/mo	WXT/Plasmo scaffolding, content scripts, AI integration handlers, type-safe message passing
WXT/Plasmo Cookbook + ChatGPT	included with framework	MV3 patterns, framework-specific gotchas
Loom AI	free	Client demo videos, "here's how to install" walkthroughs, MV3 migration before/after

The Workflow

Scoping doc + privacy policy from the discovery call (Claude long-context, ~45 min/client). Extension scoping breaks at host permissions — clients say "it works on LinkedIn" and mean different things. Paste the recorded call transcript + the target sites' DOMs into Claude:

"Below is the transcript of my 60-min discovery call with [client, B2B SaaS, wants a Chrome extension that overlays CRM data on Salesforce + LinkedIn Sales Navigator]. Generate (a) the scoping doc — list every host permission needed (be explicit: salesforce.com, .lightning.force.com, linkedin.com/sales/) with a 1-line justification per permission, (b) the data flow (what the extension reads from each site, what it sends to the server, what it stores locally), (c) the MV3 manifest skeleton with all permissions justified for Google's reviewer, (d) the privacy policy first draft covering: what data is collected, where it's stored, what's shared with third parties (specifically: OpenAI/Anthropic if used), data retention, user controls, my contact email, (e) the 5 questions I should ask in a follow-up email before quoting (target browser support, AI/LLM use, OAuth flow vs API key, monthly active users target, who handles the Chrome Web Store account). Tone: senior extension consultant, decisive about narrowing host permissions. NEVER suggest as a shortcut."

The host-permission list IS the project scope. Every site you add later is a re-review with Google.
WXT/Plasmo scaffold + AI integration handler (Cursor, ~3 hrs/build). Once the scope is approved, scaffold the project. In Cursor:

"Generate a WXT project for a Chrome extension that: (a) injects a content script on linkedin.com/sales/ and salesforce.com/lightning/* that adds a sidebar button, (b) on click, extracts the visible profile data and sends it to the background service worker via type-safe message passing, (c) the service worker calls our backend API at https://api.client.com/v1/enrich (NEVER call OpenAI directly from the extension — proxy through our backend, which holds the API key), (d) returns the enriched data and the content script renders it in the sidebar, (e) handles the case where the user is logged out, the API is rate-limited, or the network is offline (graceful degradation, not crashes). Output: wxt.config.ts, manifest entries, content scripts, service worker, sidebar React component. Use TypeScript throughout. NEVER use chrome.webRequest blocking — MV3 only allows declarativeNetRequest."*

Verify the API-key boundary yourself. AI will sometimes shortcut by suggesting "store the key in chrome.storage.local" — which is unencrypted and accessible to anyone with the dev tools open.
Chrome Web Store submission package + privacy justifications (ChatGPT, ~60 min/build). The store reviewer rejects 30%+ of first-time submissions. Paste:

"I'm submitting a Chrome extension to the Web Store. Permissions requested: activeTab, storage, host permissions for linkedin.com/sales/ and salesforce.com/lightning/. Generate the submission package: (a) the per-permission justification (Google requires one for each — write 1-2 sentences each that pass review, NEVER copy-paste boilerplate), (b) the single-purpose statement (1 sentence describing the extension's single purpose — Google rejects 'multi-tool' descriptions), (c) the data-usage disclosure: data types collected (PII / location / financial info / etc.), data uses (analytics / personalization / app functionality), data sharing (third parties), encryption in transit, user can request deletion, (d) 4 store listing screenshot captions (1280x800 each — describe the screenshot the dev should take), (e) the store description (132-char short + full description with bullet points). Tone: clear, factual, NEVER hyperbolic ('best Salesforce extension!' = auto-rejection)."

Read every justification before submitting. "We need because the user might browse anywhere" is the kind of line that delays your launch by 2 weeks.
Bug-broke runbook + Loom client install guide (Cursor + Loom AI, ~30 min/extension). DOM-injected extensions break when sites update. Paste:

"I just shipped a Chrome extension that injects on linkedin.com/sales/. Generate the bug-broke runbook: (a) the 4 most likely failure modes (LinkedIn DOM change, content-security-policy update, Chrome breaking change in MV3, OAuth token expiry), (b) the 5-min initial-response checklist (open DevTools on the target page, check service worker console, check chrome://extensions for errors, verify network requests aren't being CSP-blocked), (c) the client-facing 'we patched it, here's the update' email template, (d) the 'this is a Chrome breaking change, here's the timeline' email template, (e) my $350/month maintenance retainer scope vs out-of-scope decision tree. Output as a Notion-ready runbook + a 4-min Loom script for the client's IT contact covering install + permission grant + first-use."*

The Loom is what justifies the $350/month retainer — the alternative is a panicked Slack message every time LinkedIn rolls a UI update.
Monthly retainer report + Chrome breaking-change tracker (ChatGPT, ~20 min/client/month). Extensions die quietly. Paste:

"I run the maintenance retainer for [client]'s Chrome extension. This month: (a) extension version [X], [N] active users, (b) [N] sessions per day average, (c) one DOM-change patch shipped on [date] for the LinkedIn sales nav header rename, (d) one Chrome update (M[N]) — verified compatibility, no changes needed. Generate the 1-page client retainer report: (a) install base + activity trend, (b) any incidents and resolution, (c) what I patched and why, (d) what I'm watching for next month (Chrome M[N+1] roadmap, target sites' announced UI updates), (e) one strategic recommendation. Tone: senior extension advisor. Output as Notion-ready 1-pager."

Send first business day of every month. The retainer book IS the business by month 12 — one new build a month plus 8 retainers at $350 is $2,800 floor before any new project.

Time Saved Per Week

Roughly 6-9 hours/week once your scoping template, manifest justification format, and store-submission checklist are built:

Scoping + privacy policy draft: 4 hours/client → 45 min (Claude long-context)
WXT/Plasmo scaffolding + AI integration: 8 hours → 3 hours (Cursor)
Chrome Web Store submission package: 3 hours → 60 min (ChatGPT)
Bug-broke runbook + Loom: 90 min → 30 min (Cursor + Loom AI)
Monthly retainer report: 60 min/client → 20 min (ChatGPT template)

Trade that time for: 5 Upwork applications/day at the $2,000+ tier, the Show HN post for your portfolio extension, and the manual cross-Chromium test pass (Brave, Edge, Arc) that AI literally cannot do for you.

Total AI Stack Cost

Budget tier ($20/mo): ChatGPT Plus only. Cursor and Copilot have free tiers that cover the first 30 days. Right while you're shipping your first portfolio extension.
Full tier ($80/mo): ChatGPT Plus + Claude Pro + Cursor + Copilot Business. Worth it the day you sign client 2 — Cursor cuts MV3 scaffolding time in half once you have a personal prompt library of patterns that pass review.
Compare: A junior frontend dev for scaffolding + manifest review + store submission runs $4,000-$7,000/mo offshore. The full AI stack is one-hundredth that cost — and you keep eyes on every host permission before submission.

Cancel anything you don't open in a 7-day window. Pay for Copilot Business specifically — the IP indemnification is the only thing that lets enterprise clients accept your AI-tools clause.

Your First Win

30 minutes from now your Chrome Web Store rejection-prevention checklist is built. Open ChatGPT (free tier works). Paste:

"I'm a freelance Chrome extension developer. Build me a 1-page pre-submission checklist I run BEFORE every Chrome Web Store submission to cut Google's rejection rate to near-zero: (a) the 12 review-trigger items to verify (manifest_version is 3 — no MV2 left, no remotely hosted code anywhere — service worker doesn't fetch + eval JS, content scripts have CSP-compliant code, host permissions list ONLY what's needed — never , every permission has a written justification ready for Google, the single-purpose statement is one sentence not five, data-usage disclosure matches what the code actually collects, OpenAI/Anthropic API keys are NEVER in the extension bundle — proxied through my backend, the privacy policy URL is live and reachable, screenshots are 1280x800 and don't show competitor logos, the description doesn't use 'best/fastest/#1' language, the support email actually receives mail), (b) the 5 things that cause '7-day re-review' delays (broad host permissions without justification, requesting permissions not used in code, missing data-usage disclosure, unclear single-purpose, broken privacy policy link), (c) the 1-paragraph 'we received your reviewer feedback, here's what changed' template I send when Google rejects round one. Tone: senior extension consultant. NEVER 'I'd love to help' filler."

Use the checklist before every submission. A 30-minute checklist run is what separates a 5-day Google review from a 21-day rejection loop — and the difference is whether your fixed-price project ships in week 4 or week 8.

Product / Service Offering

You sell three things, in this order:

Custom internal-tool extensions. A business-specific Chrome extension for one job inside the company's own browsers — CRM overlay, ops automation, data-injection helper. 1-3 week build, $1,500-$4,000 fixed price. Bread and butter for the first six months — scope is bounded and the buyer is decisive.
AI-integrated extensions for SaaS companies. A companion extension that adds browser-level features to a SaaS product (text capture, page summarization, in-context chat, auto-fill against the SaaS API). 2-5 week build, $3,000-$8,000 fixed price. This is where the money actually is.
Maintenance retainers. Every extension needs ongoing care when Chrome's APIs change, when injected sites update their HTML, or when AI API versions roll. $250-$500/month per extension for a monthly compatibility check plus bug-fix hours. Sell this on day one, not after the first thing breaks.

A productized extension of your own ($5-$20/month subscription) is a natural exit from client work. Don't start there — build it after 4-6 client extensions, when you know which problems have buyers.

Use WXT or Plasmo as your framework. Both give you TypeScript, hot-reload, and an MV3-first build pipeline. Hand-rolling the manifest and webpack config every time turns a 2-week build into 5.

Revenue Model

Unit economics for a solo developer running a mix of Chrome Web Store custom builds and client-commissioned work, no subcontractors, working from a laptop:

Service	Price	Variable cost (tools + payment fees)	Build time	Take-home per project
Internal-tool custom extension	$2,500	$5 (CWS one-time, amortized) + $73 (Stripe 2.9% + $0.30)	40-60 hrs	~$2,420
AI-integrated SaaS extension	$5,000	$5 + $145 + ~$50 (OpenAI/Anthropic dev tokens)	60-100 hrs	~$4,800
MV2 → MV3 migration	$1,800	$5 + $52	20-35 hrs	~$1,740
Monthly maintenance retainer	$350/mo	$10 + $10	2-4 hrs/mo	~$330/mo
Productized self-published extension	$9/mo per user	~$1.50 (Stripe + Paddle MoR if used)	n/a after build	~$7.50/mo per user

Your first $1K month = one small internal-tool build at $1,500-$2,000, often a 2-week side project on top of a day job. Take-home ~$1,400-$1,900 after Stripe.

Your first $3K month = one AI-integrated SaaS build at $3,500-$5,000, OR two internal-tool builds at $1,800-$2,500 each. Add 2-3 retainers from prior clients ($700-$1,000/month) and you're at a $3.5K-$5.5K floor before any new project.

The path to $8K-$10K months isn't bigger projects — it's stacking retainers. Ten at $350/month is $3,500 of mostly-passive income on top of one new build a month. By month 12, your retainer book matters more than any single project.

Startup Costs

Chrome Web Store developer registration: $5 one-time at Chrome Web Store devconsole. Required for any extension you publish — even unlisted client builds.
Firefox + Edge stores: Free at Firefox Extension Workshop and Microsoft Edge add-ons.
Dev environment: WXT and Plasmo are free open-source. You already have VS Code, Node, and a Chromium browser.
OpenAI / Anthropic API credits: $50-$200/month during dev — platform.openai.com and docs.anthropic.com. Pass through to the client at cost or build into the project price.
GitHub for client repos: Free for public, $4/user/month for private team repos. Separate repo per client — never a monorepo.
Payment processing: Stripe at 2.9% + $0.30 per transaction. For international clients, Wise for foreign-currency receipts.
LLC + EIN + insurance: $35-$500 LLC filing — LLC University 50-state table. EIN is free at IRS EIN Online — never pay a third party. E&O (errors & omissions) insurance for a solo dev runs $800-$2,000/year via Hiscox or Insureon.
Bookkeeping: QuickBooks Self-Employed at ~$20/month, or Wave for free, until you cross $50K in revenue.

Realistic all-in: $2,000 if you DIY the LLC, defer E&O until your first $5K project, and limit AI dev spend; $8,000 if you bind a year of E&O, file the LLC through a service, and prepay six months of API credits.

Legal & Formation

Business entity. Single-member LLC (limited liability company) the moment you take a paying client — separates your personal accounts from any breach-or-defect claim. Filing fee is recoverable in your first project. Sole prop is fine for the first 30 days while you're testing demand, but switch before client number two. EIN is free directly from the IRS — apply free at IRS, never pay a third party. Once your net profit clears roughly $80K-$100K/year, run the math on an S-corp election via Form 2553.

Licenses & sales tax. No professional license required for browser extension development in any US state. Custom extension dev billed as professional services is generally not taxed. The exception: if you publish a productized extension and charge a recurring subscription, about 25 states tax SaaS — and your economic-nexus threshold is typically $100K in sales or 200 transactions per state post-Wayfair. If you go productized, use Stripe Tax or Paddle as merchant of record from day one.

Industry-specific risk. The single most consequential trap is IP assignment in your client contracts. Software you write for a client is NOT automatically owned by them under 17 USC §101 — the work-for-hire categories don't cover custom software. Without an explicit IP assignment, you keep the copyright even if they paid you. Clients who later try to sell their company will discover this during diligence and the deal will stall. The fix is a one-page IP clause in every SOW (statement of work) that names what gets assigned (the client-specific code) and what stays yours (boilerplate, framework wrappers, reusable utilities — granted under a perpetual license, not assigned). Use an MSA (master services agreement) template from Bonsai and pay an attorney $200-$500 to review it before your first contract over $5,000.

Marketing & First Customers

Your first 5 clients come from places already full of buyers asking for extensions. Not cold LinkedIn, not Twitter. Here's the order:

Upwork with a tight extension-only niche. Apply to 3-5 Chrome extension postings per day at the $2,000+ tier with a proposal that names MV3 specifically and links to one extension you've shipped. Upwork charges a 10% flat service fee. Volume there is unmatched for the first 90 days.
A published portfolio extension on the Chrome Web Store. Build one useful free extension and ship it. Doesn't matter if it gets 10 users — what matters is you have a live store listing, a privacy policy, and screenshots instead of a GitHub repo.
/r/chrome_extensions and Indie Hackers. Reddit's r/chrome_extensions has founders posting "looking for someone to build X." Indie Hackers has SaaS founders evaluating whether to ship a companion extension. Both convert better than general dev marketplaces because the buyer already knows what they want.
A Show HN post for your portfolio extension. Show HN drives a spike of attention plus DMs from founders who want similar work. One that lands well is worth a month of Upwork applications.

Once you have 3 client extensions live, the retainer pitch starts converting. Frame it as "monthly compatibility check, covered when Chrome rolls an MV3 update or LinkedIn changes their DOM" — not "support hours." You're selling the absence of a 9pm Slack message.

First 90 Days

Week 1. File the LLC. Get EIN free at IRS. Open a business bank account. Register the $5 Chrome Web Store developer account.
Week 1-2. Pick WXT or Plasmo. Build one portfolio extension end-to-end with an OpenAI or Anthropic API call. Ship to the Chrome Web Store as a free listing. Write the privacy policy.
Week 2-3. Set up Stripe Invoicing. Adapt a Bonsai MSA + SOW template with an explicit IP assignment clause.
Week 3-4. Apply to 15-25 Upwork postings at the $2,000+ tier. Aim for 1 paying client signed by end of week 4.
Week 4-6. Ship the first paid extension. Submit with a 2-week review buffer baked in. Don't promise a launch date inside the buffer.
Week 6-8. Bind E&O insurance ($800-$2,000/year). Post a Show HN about your portfolio extension. Start a Reddit + Indie Hackers presence — comment, don't pitch.
Week 8-10. Pitch a $350/month retainer to your first client during the handoff call. Aim for 2 paying clients total by week 10.
Week 10-12. Raise prices on new quotes. Internal-tool builds: $2,500 minimum. AI-integrated SaaS builds: $4,000 minimum. Target by day 90: 3 shipped extensions, 2 active retainers, ~$2,500-$4,000/month in flow.

Common Pitfalls

Underpricing because the build feels easy. A 40-hour MV3 extension with one AI call is a $2,500-$4,000 deliverable, not a $500 weekend gig. The buyer is paying for it working, getting approved, and not breaking — not for your hours. Quote the deliverable, not the time.
Promising a launch date inside the Google review window. Chrome Web Store review can take 1-7+ business days, longer for extensions requesting broad permissions (Chrome Web Store program policies). Bake a 2-week buffer into every SOW and explicitly disclaim Google review delays.
Selling DOM-injected extensions without a retainer. Extensions that inject into LinkedIn, Salesforce, or Gmail break when the host site updates its HTML — sometimes overnight. Without a $250-$500/month retainer in place, you'll do the fix for free or watch the relationship sour. Sell the retainer on day one.
Embedding API keys in the extension. Extension code is bundled and shipped to every user — anyone can unpack the .crx and pull your key. Use a thin server-side proxy (one Vercel or Cloudflare Worker endpoint) that holds the key and authenticates requests. MV3's removal of remotely hosted code makes this non-optional.

Get your full launch plan — take the free 60-second quiz.