The extension was done. Then the rejection email arrived.
A team builds the extension internally. It works in their own browser, does exactly what they need, and ships to the Chrome Web Store. Three days later the rejection email lands, citing a policy section by number, and nobody on the team can decode what it actually wants.
The code was never the hard part. The permission model, the single-purpose framing, and the privacy policy that has to match what the extension really does with data: that is what the review team reads, and that is where internal builds stall.
An extension lives one tab away from every workflow your users have. Getting it there means clearing the review, not just clearing the compiler.
Web apps run inside their own tab. Mobile apps run inside their own icon. Extensions run inside every tab the user opens. That proximity is the whole point. It's also the reason browsers police them carefully, and why building one well means understanding the security model, the permission system, and the review process before you write the first line of code, not after.
The Chrome Web Store is one of the highest-distribution software channels there is. Reaching that installed base means clearing store policy from day one, not treating it as a formality after the code already works.
- 1.69B+
- Chrome Web Store extension installs, all-time
- chrome-stats.com, 2025
- ~180K
- Extensions listed on the Chrome Web Store
- chrome-stats.com, 2025
- Jul 2025
- Manifest V2 stopped running on stable Chrome (v138)
- Chrome for Developers, MV2 timeline
RaftLabs has shipped production software since 2015 and holds a 4.9/5 rating on Clutch. We've also built and shipped our own browser extension: Draftly, an AI-assisted LinkedIn content tool with a native Chrome extension that worked inside the LinkedIn UI itself, no separate dashboard to context-switch to. RaftLabs sold Draftly in 2024 and no longer operates it, but the team that scopes your extension project is the same team that built and shipped that one.
Most teams that try to build an extension internally underestimate one of three things: how much of the work is store policy compliance rather than application logic, how much the Manifest V3 service worker model changes the assumptions you can make about background state, or how different the Safari distribution model is from Chrome. We scope every extension project around all three from day one, not as an afterthought once the code already works.
An extension pays off when it lives inside a workflow, and has to clear the store to get there.
Everything on the left should already be true for your build. Even one thing on the right, and a script or a bookmarklet is the smarter first step.
A fit01You need an extension that lives inside Chrome, Edge, Firefox, or Safari, built on Manifest V3 from day one.
02The extension touches real workflows: an AI assistant, a CRM or sales prospecting tool, or an internal automation across tools your team already uses.
03You want the Chrome Web Store submission and review handled end to end, with a fixed price before code is written.
Not a fitYou need a quick script or bookmarklet, not a store-published, maintained extension.
You want a Manifest V2 build; Chrome stopped accepting new MV2 submissions in 2024 and is phasing out the rest.
The idea depends on remotely hosted code executing inside the extension, which MV3 store policy prohibits.
What we build
What our browser extension development service covers
01Chrome extension development
Production Chrome extensions built on Manifest V3 with a clean service worker architecture, declarativeNetRequest for network behavior, and a popup UI in React or Svelte with TypeScript throughout. The permission model is designed for least privilege from day one, and Chrome Web Store submission is handled end to end, from listing copy and screenshots to privacy policy; if a submission is rejected, we revise and resubmit, typically within 48 hours.
02Edge and Firefox extension development
When a project needs Edge or Firefox alongside Chrome, we build from the same Manifest V3 codebase with the smallest possible per-browser delta. Edge accepts a Chrome build almost verbatim via the Microsoft Partner Center; Firefox resolves the browser.* namespace with webextension-polyfill so application code stays unified, and because Mozilla review is stricter on obfuscation we ship source maps and unminified source by default.
03Safari Web Extensions for macOS and iOS
When a project needs Safari, we wrap the same Manifest V3 codebase in a native Swift shell as a macOS and iOS app via Xcode. Because Safari distributes through the Mac App Store and iOS App Store, that means Xcode setup, code signing, notarization, and App Store Connect submission on top of the shared TypeScript codebase, so the extension logic stays the same across every browser even though the packaging doesn't.
04AI assistant and productivity extensions
Extensions that put an AI assistant inside the user's existing workflow: a sidebar beside any page, selection-based prompting from a keyboard shortcut, and output inserted back into editable surfaces like Gmail, Google Docs, Notion, and Salesforce. LLM API calls route through a backend service so keys never ship in the bundle and cost controls live server-side, while productivity extensions store data locally via chrome.storage rather than syncing to a server the user didn't ask for.
05Sales and CRM browser extensions
Extensions for sales prospecting and CRM workflows that live where the team already works: LinkedIn prospecting tools that push contacts into Salesforce or HubSpot with one click, and Gmail or Outlook sidebars that surface deal context next to every thread. For CRMs with public OAuth APIs we authenticate with OAuth 2.0 and PKCE; for platforms without them, a backend proxies requests, and bulk operations retry with backoff when the CRM throttles.
06Extension store submission and approval
End-to-end submission handling for the Chrome Web Store, Edge Add-ons, Firefox Add-ons, and the Mac and iOS App Stores, each with its own policy framework and review criteria. The Chrome package includes a privacy policy, a justification for every requested permission, listing copy, and screenshots, all of which we write; if a submission is rejected, we revise against the cited policy section and resubmit, usually within 48-72 hours.
Have an extension the store keeps rejecting?
Send us the rejection email and the manifest. We'll tell you why it failed and what it takes to pass the next review.
How it works
From scope to shipped
Every project follows the same four phases. Scope is locked and price is fixed before development starts.
- Week 1
01Discovery and permission model
We map the workflow the extension lives in, the browsers it needs to support, and the data it touches. You leave week 1 with a written scope document, a Manifest V3 permission model, and a fixed-price quote. No development starts without your sign-off.
- Weeks 2-3
02Architecture and UI design
Extension UI wireframes before production code. The permission scope, the service worker lifecycle, and the content script injection points are all locked here. Design decisions made in week 2 cost ten times less than the same decisions made in week 8.
- Weeks 4-12
03Build, integrate, and QA
Working extension installable from a staging build by end of sprint one. Bi-weekly demos. QA runs in parallel with every sprint, testing each browser target independently, not as a phase at the end.
- Weeks 12+
04Store submission and post-launch support
We handle the full store submission package and manage the review process. 8 weeks of post-launch support included in every project. If the store review triggers a rejection, we revise and resubmit within 48 hours.
One Manifest V3 codebase covers all four, but the store, the review, and the packaging are not the same everywhere. This is where an internal build usually loses a week it did not budget for.
| Chrome and Edge | Firefox | Safari |
|---|
| Manifest | Manifest V3, shared codebase | Manifest V3, browser.* namespace | Manifest V3 wrapped in a native app |
| Distribution | Chrome Web Store and Microsoft Partner Center | Firefox Add-ons (AMO) | Mac App Store and iOS App Store via Xcode |
| Review sticking point | Permission justification, single purpose | Source review, no obfuscation | App Store review plus Apple Developer Program |
| Cost to add | Baseline | Small API and manifest delta | Xcode shell, code signing, notarization |
- Manifest V2 migration
- No Manifest V2 extension has run on stable Chrome since Chrome 138 in July 2025, and the Chrome Web Store removes the last MV2 listings on 31 August 2026 (Chrome for Developers, MV2 deprecation timeline). An MV2 build is not a config tweak away from MV3. It is a rewrite of the background logic, the network interception layer, and often the storage model, so we scope it as its own project.
- Store rejection
- The common rejections are permission scope the described feature does not justify, a privacy policy that does not match real data use, single-purpose violations, and remotely hosted code, which MV3 prohibits. We write the listing, the privacy policy, and every permission justification to pass, and revise against the cited policy section within 48 hours if a review still fails.
- Permission scares
- An install prompt that asks for access to all sites costs you installs. We design for least privilege, request host access per-site or on demand through the activeTab pattern, and keep the prompt small enough that users say yes.
- Auto-update breakage
- Extensions update silently, so a bad release ships itself to every user at once. We stage rollouts, keep the service worker resilient to being stopped and restarted, and version any external API the extension depends on so a platform change does not brick it in the field.
What clients say
What our clients say
Three-year average engagement. Founders and operators describing the work in their own words. No marketing varnish.
Charles E.
USAEntrepreneur at Aggie Technologies
“All of the sprints were completed on schedule and on budget. We highly recommend RaftLabs!
We give you a fixed cost before any code is written, not a time-and-materials estimate. Where you land in that range depends on scope, not negotiation:
- Single-browser build, $15,000-$35,000
- One core feature, a popup UI, content scripts, and Chrome Web Store submission handled end to end, in 4 to 6 weeks.
- Cross-browser and backend, from there up
- Chrome, Edge, and Firefox from one codebase adds roughly 15-25%. Safari Web Extensions add $8,000-$15,000. AI assistant, CRM, or data-layer backends are scoped in with the extension.
What it costs
Browser extension development, starting at $15,000.
A single-browser extension, cross-browser from one Manifest V3 codebase, or a full build with a backend and store submission handled end to end.
Starts at $15,000Priced by project, not time-and-materials, quoted before any code is written. Most launch a validated v1 in 6-12 weeks. Many teams start with a single browser and add cross-browser or Safari support once they've validated demand.
Start with a single-browser extension, then expand to cross-browser or add Safari support once you've seen adoption. Store submission, and any rejection appeal, is handled either way.
No hourly billing
Once we scope the work, that price is locked in writing. No hourly billing, nothing absorbed quietly into the final invoice.
Store approval handled
We handle the full store submission package and manage the review. If it triggers a rejection, we revise against the cited policy section and resubmit within 48 hours, with 8 weeks of post-launch support included.
A browser extension rarely stands alone. AI assistant and CRM extensions usually need a backend: see API development for the integrations layer, or web application development if the extension is the entry point to a larger product. An extension is one piece of a broader build; for the rest of the system, see custom software development.