I Built 3 Chrome Extensions That Automate My $4000/Month Freelance Workflow (Free Tools + Code)
Last month I watched myself copy-paste the same client outreach template for the 47th time and realized I was an idiot. I’m a developer who builds automation tools for clients, yet I was doing mind-numbing manual work every single day.
So I built three simple Chrome extensions that now handle the repetitive stuff automatically. My monthly income jumped from $2800 to $4000 because I’m spending time on actual work instead of admin tasks.
Why I Stopped Using Existing Extensions
Most productivity extensions suck for freelancers. They’re built for generic office workers, not people juggling 6 clients with different workflows. Grammarly can’t research my prospects. Todoist can’t auto-generate invoices from my time tracking. RescueTime can’t scrape job boards for leads.
I needed tools that understood my specific chaos. So I built them.
Extension 1: Smart Client Outreach Tool
This extension transformed my lead generation. Instead of manually researching prospects and crafting personalized emails, it does the heavy lifting.
What it does:
– Scrapes LinkedIn profiles and company websites for context
– Uses OpenAI’s API to generate personalized outreach messages
– Tracks which templates perform best
– Auto-fills contact forms with customized pitches
The tech stack:
– Chrome Extension Manifest V3
– OpenAI API (free tier gives you $18/month)
– Chrome’s built-in storage API
– Simple HTML/CSS/JavaScript
Key code snippet for the content scraping:
// Scrape LinkedIn profile data
function scrapeLinkedInProfile() {
const name = document.querySelector('h1.text-heading-xlarge')?.textContent?.trim();
const title = document.querySelector('.text-body-medium.break-words')?.textContent?.trim();
const company = document.querySelector('.pv-text-details__right-panel .hoverable-link-text')?.textContent?.trim();
return { name, title, company };
}
// Generate personalized message with OpenAI
async function generateOutreachMessage(profileData, serviceType) {
const response = await fetch('https://api.openai.com/v1/chat/completions', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${API_KEY}`
},
body: JSON.stringify({
model: 'gpt-3.5-turbo',
messages: [{
role: 'user',
content: `Write a personalized outreach email for ${profileData.name}, ${profileData.title} at ${profileData.company}. I offer ${serviceType} services. Keep it under 100 words, friendly but professional.`
}]
})
});
const data = await response.json();
return data.choices[0].message.content;
}
Results: My response rate went from 8% to 23%. I send 40% more outreach messages because the research is automated.
Extension 2: Content Research Assistant
Research used to eat 3-4 hours daily. This extension turns it into background work that happens while I browse.
What it does:
– Automatically saves relevant articles, tweets, and resources based on my current projects
– Summarizes long articles using AI
– Organizes research by client/project tags
– Creates shareable research briefs
The workflow:
1. I tag articles with client names as I browse
2. Extension uses Claude API to generate summaries
3. Auto-organizes everything into project folders
4. Exports research briefs in client-ready formats
Smart tagging logic:
// Auto-suggest tags based on content
async function suggestTags(articleText, existingProjects) {
const prompt = `Based on this article content and my current projects (${existingProjects.join(', ')}), suggest 2-3 relevant tags: ${articleText.substring(0, 500)}`;
// API call to Claude or OpenAI
const suggestions = await getAISuggestions(prompt);
return suggestions.split(',').map(tag => tag.trim());
}
// Save with smart organization
function saveArticle(url, title, content, tags) {
const articleData = {
url,
title,
content,
tags,
timestamp: Date.now(),
summary: null // Generated later
};
chrome.storage.local.get(['articles'], (result) => {
const articles = result.articles || [];
articles.push(articleData);
chrome.storage.local.set({ articles });
});
}
Results: Research time dropped from 3 hours to 45 minutes daily. Client deliverables are more comprehensive because I capture more relevant information.
Extension 3: Invoice & Time Tracker
Invoicing was my biggest time drain. Switching between time tracking apps, calculating rates, chasing payments — pure friction.
What it does:
– Tracks time automatically based on active browser tabs and applications
– Recognizes which client work I’m doing by URL patterns and keywords
– Auto-generates invoices with detailed breakdowns
– Sends payment reminders on schedule
– Integrates with Stripe for easy payment processing
Smart time detection:
// Detect active work based on tabs and applications
chrome.tabs.onActivated.addListener(async (activeInfo) => {
const tab = await chrome.tabs.get(activeInfo.tabId);
const client = detectClientFromURL(tab.url);
if (client) {
startTimeTracking(client, tab.url);
}
});
function detectClientFromURL(url) {
const clientPatterns = {
'client_a': ['github.com/clienta', 'clienta.slack.com', 'clienta-project'],
'client_b': ['trello.com/b/clientb', 'clientb.com/admin'],
'client_c': ['notion.so/clientc', 'clientc-docs']
};
for (const [client, patterns] of Object.entries(clientPatterns)) {
if (patterns.some(pattern => url.includes(pattern))) {
return client;
}
}
return null;
}
// Auto-generate invoice data
function generateInvoiceData(clientId, dateRange) {
const timeEntries = getTimeEntriesForPeriod(clientId, dateRange);
const totalHours = timeEntries.reduce((sum, entry) => sum + entry.duration, 0);
const rate = getClientRate(clientId);
return {
client: clientId,
period: dateRange,
entries: timeEntries,
totalHours: Math.round(totalHours * 100) / 100,
totalAmount: totalHours * rate,
dueDate: new Date(Date.now() + 14 * 24 * 60 * 60 * 1000) // 14 days from now
};
}
Results: Invoicing went from 2 hours monthly to 15 minutes. I bill 12% more hours because the tracking is accurate and automatic. Payment times improved because invoices are more detailed and professional.
Building Your Own Extensions
Start simple. Pick your biggest time waster and automate just that one thing.
Basic Chrome extension structure:
– manifest.json — defines permissions and entry points
– background.js — handles events and API calls
– content.js — interacts with web pages
– popup.html/js — the interface users see
Free AI APIs to get started:
– OpenAI: $18/month free credit
– Claude (Anthropic): Free tier available
– Hugging Face: Many free models
– Google’s PaLM API: Generous free tier
Essential Chrome APIs:
– chrome.storage for saving data
– chrome.tabs for tab management
– chrome.scripting for page interaction
– chrome.alarms for scheduled tasks
The learning curve is gentler than you think. If you can write basic JavaScript, you can build useful automation tools.
The Real Impact
These extensions gave me back 15-20 hours weekly. That’s almost an extra workday I can spend on billable client work or finding new opportunities.
More importantly, they eliminated the friction that made freelancing feel overwhelming. No more forgetting to track time. No more bland outreach messages. No more losing research in browser bookmark chaos.
Monthly breakdown:
– 20 extra billable hours at $60/hour = $1200
– Better proposals leading to higher-value clients
– Reduced administrative overhead stress
– Total monthly increase: $1200+
The best part? These tools get smarter as I use them. The AI learns my writing style, the time tracker gets better at detecting work patterns, and the research tool builds a knowledge base specific to my niche.
What’s the most time-consuming part of your freelance workflow that you haven’t automated yet?