# How to Vibe Code Your Own Bardeen (and Stop Paying for It)

> AI-powered browser automation and workflow platform

- Site: https://bardeen.ai
- Category: Browser Extension / Sales Automation
- Platforms: Browser extension, Web app
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 3-4 weeks of focused development

## Verdict

You can build a personal workflow automation and scraping extension in a few weeks, but keeping scrapers functional as target websites change layout requires constant maintenance.

Writing a Manifest V3 browser extension that injects scripts, communicates via background workers, and connects to an LLM API is straightforward with AI coding tools. The real friction point is web scraper resilience—when target sites update their CSS classes or DOM hierarchy, your extraction rules break instantly. For personal use, building a bespoke local extension for your own prospecting workflows saves money and works wonderfully, but maintaining enterprise-grade scraper stability is a full-time engineering treadmill.

### What you can't replicate

- Maintained library of thousands of pre-built scraper templates for major sites
- Enterprise security certifications (SOC 2, CASA)
- Deep native integrations across hundreds of third-party sales platforms

## What it does

Bardeen is an intelligent browser extension and automation layer that lets go-to-market teams scrape dynamic web pages, enrich lead data, run AI qualification prompts, and sync results straight into spreadsheets or CRMs.

### Core features

- Manifest V3 Chrome extension popup and background worker runtime
- DOM element scraping and table extraction via injected content scripts
- AI prompt execution using natural language (Magic Box)
- Contact enrichment via third-party validation APIs
- Local state orchestration and credit tracking
- Spreadsheet and webhook exports (Google Sheets, Airtable, Notion)

## The business

### Pricing

- Free: $0/mo
- Basic: $10/mo
- Premium: $50/mo
- Enterprise: Custom

### Funding

$21.8M - $25M raised.
- Seed
- Extension rounds (including $3M injection in August 2024)
Investors: Venture capital funds

Founded 2020.
Team size: ~35 employees.

## The hard parts

- Surviving continuous DOM mutations and anti-bot blocks on complex target sites like LinkedIn or Zillow
- Managing local browser storage quotas and reliable background script message passing
- Handling OAuth credential flows and secure API token management inside an extension

## How to vibe code Bardeen

### Prerequisites

- Node.js (Free): Required for building extension bundles and tooling.
- GitHub (Free): Version control and repository hosting.
- Google Chrome (Free): Local testing environment for loading unpacked Manifest V3 browser extensions.

### Recommended AI tools

- Claude Code: Best-in-class agent for scaffolding complex multi-file TypeScript extension architectures and debugging background worker state.
- Cursor: Ideal for inspecting DOM interaction scripts and refining extension UI popup components.

### Stack

- Frontend: React + Tailwind CSS (Extension Popup UI)
- Backend: Chrome Extension Background Service Worker (TypeScript)
- Database: IndexedDB / Chrome Storage Local
- Auth: Local API key storage
- Payments: None (Personal use clone)
- Other: Vite (Extension bundling), OpenAI API or Anthropic API (AI qualification)

### Hosting

- Cloudflare (Hosting optional backend webhooks and lightweight license verification API): $0/mo

### Build guide

1. **Scaffold Chrome Extension Manifest V3 Project** — Initialize a TypeScript project using Vite with a multi-page/multi-entry configuration supporting a popup interface, background service worker, and content scripts.

```
Create a new browser extension project using TypeScript, Vite, React, and Tailwind CSS configured for Manifest V3. Set up the manifest.json with permissions for 'activeTab', 'scripting', 'storage', and host permissions for target domains. Structure the repository with directories for popup, background service worker, and content scripts. Include a build script that outputs a clean dist folder ready for loading as an unpacked extension in Chrome.
```

2. **Implement DOM Extraction Content Script** — Build resilient content scripts capable of querying DOM elements, extracting table rows and profile links, and transmitting structured JSON back to the background script.

```
Write a content script in TypeScript that listens for extraction messages from the extension background worker. Implement robust DOM traversal functions that target list items, profile headers, and table structures using fallback selectors (data attributes, aria labels, and semantic tags). Handle dynamic lazy-loading pages by scrolling or waiting for element mutations before compiling the scraped array into structured objects.
```

3. **Build Background Service Worker & Message Router** — Create the central background service worker that coordinates workflow steps, manages local state queues, and invokes content scripts in sequence.

```
Develop a robust background service worker in TypeScript that acts as a workflow state machine. Implement message passing between the React popup and active content scripts. Support sequential multi-step execution: Step 1 scrape search results, Step 2 iterate over profile URLs to scrape details, Step 3 send data to an AI evaluation queue, and Step 4 store results in chrome.storage.local.
```

4. **Integrate LLM AI Qualification & Prompt Engine** — Connect the extension to an LLM API provider (OpenAI or Anthropic) to evaluate scraped lead profiles against a natural language Ideal Customer Profile (ICP).

```
Implement an AI qualification module inside the background service worker that accepts user-defined ICP criteria and scraped profile JSON. Construct clean prompts sent securely via fetch to the OpenAI or Anthropic API using an API key stored securely in chrome.storage.local. Parse the JSON response to return a boolean qualification status and detailed reasoning for each lead.
```

5. **Build Extension Popup UI & Workflow Dashboard** — Design a clean React popup interface displaying workflow steps, execution progress bars, credit usage counters, and table previews of scraped leads.

```
Build a sleek React dashboard UI for the extension popup using Tailwind CSS. Create views for selecting workflow templates, configuring ICP prompts, viewing a live data table of scraped and qualified leads, and exporting results directly to CSV or copying them to the clipboard. Display real-time progress indicators and credit usage counters based on local state.
```

6. **Add Spreadsheet & Webhook Export Integrations** — Implement export utilities that push structured lead data directly into Google Sheets via API or user-configured webhook endpoints.

```
Add export modules to the extension background worker that can send structured lead lists to external endpoints. Implement a Google Sheets API OAuth integration allowing users to push scraped rows directly into a designated spreadsheet, along with a fallback raw CSV file download utility.
```

### Cost vs paying

**Starting costs (one-time):**

- AI coding assistant (Claude Pro): $20
- Total: $20 one-time

**Ongoing costs (monthly):**

- LLM API usage (OpenAI / Anthropic): ~$5-15/mo
- Total: ~$10/mo

- Paying for the SaaS instead: $50/mo (Premium Plan)
- Build time: 35-45 hours
- AI tool credits: $20 (Claude Pro)
- Break-even: Less than 1 month if replacing Premium tier

## Sources

- [Bardeen Official Website](https://www.bardeen.ai)
- [Bardeen Pricing & Credits Documentation](https://www.bardeen.ai/pricing)
- [GetLatka Bardeen Financial & Company Profile](https://getlatka.com/companies/bardeen)