Forem: Brad

How I Find High-Quality Freelance Leads Using HN Data

Brad — Tue, 19 May 2026 09:04:02 +0000

Finding freelance clients is easier when you fish where the fish are.

HN's "Who is Hiring?" threads are published monthly and contain 400-700 companies actively hiring — many open to contractors and freelancers.

The problem: reading through hundreds of threaded comments manually takes hours.

The Smarter Approach

Instead of cold-emailing random lists, I mine HN hiring threads for companies that match my tech stack:

Filter by technology — Python, data pipelines, automation, remote
Look for direct contact info — many founders include personal emails in HN posts
Send one highly-personalized message — reference their specific post, offer a concrete deliverable
Follow up once after 3 days — then move on

The conversion rate is low (1-3%), but the lead quality is much higher than spray-and-pray cold email.

What I Built

I built HN Startup Hunter to speed this up — a free tool that scrapes and indexes HN hiring threads. Enter your skills, filter by stack/timezone/remote, get a ranked list.

Free tier: 20 results. Pro (/month): full results + CSV export with emails.

The Done-For-You Option

If you want a custom research report — I run the scraper with your requirements and deliver 20-50 relevant companies with contact info and stack notes.

5, delivered in 24 hours. → Order here

What is working for your client acquisition right now? Always curious what other freelancers are testing.

5 Signs Your Automation Project Will Fail (and How to Fix Them Before You Start)

Brad — Tue, 19 May 2026 09:03:09 +0000

I've automated hundreds of business workflows. Some saved 20+ hours per week. Some were abandoned after a month.

The difference wasn't complexity. It was usually one of these five things.

Sign 1: No One Owns the Data Source

If you build a scraper that pulls from a website, and no one at the company is responsible for knowing when that website changes its structure — your automation is a ticking clock.

Fix: Before writing any code, answer: "Who will notice in 24 hours if this breaks?"

If the answer is "no one until the reports stop showing up," you need a human owner.

Sign 2: The Manual Process Was Never Documented

You can't automate a process that only exists in someone's head. I've seen teams try to automate their "monthly data prep" only to discover the actual process is 47 steps, varies by person, and has 12 exceptions that "everyone just knows."

Fix: Before writing code, shadow the person doing the manual work. Write down every single step, including the "that's weird, ignore it" ones. Automate the documented process.

Sign 3: The Script Has No Error Handling

# Bad: This will silently corrupt data
for record in fetch_records():
    save_to_db(record)

# Better: Know when it fails
for record in fetch_records():
    try:
        save_to_db(record)
    except Exception as e:
        log.error(f"Failed to save record {record.id}: {e}")
        notify_owner(f"Automation failed at record {record.id}")
        raise  # Stop and let a human know

Silent failures are worse than loud ones. A script that crashes with a clear error message is better than one that runs successfully but produces wrong output.

Sign 4: It Only Works on Your Laptop

"Works on my machine" is the death of many automation projects. If the script needs your Python version, your file paths, your environment variables — it's not an automation, it's a fragile manual step.

Fix: Containerize it (Docker), document exact dependencies, test on a clean machine or VM before handing off.

Sign 5: There's No Monitoring

An automation that runs unmonitored for 3 months, then silently stops, has wasted every hour it supposedly saved. The business adapted to the automation working — now the failure is invisible until it causes a crisis.

Fix: Add a simple "heartbeat" — a daily Slack message or email with "Automation ran successfully, processed X records." If you stop seeing it, something broke.

The Real Cost of Failed Automations

A broken automation doesn't just fail to save time — it actively costs time to diagnose, fix, and rebuild trust. Teams that have been burned once often avoid automation for years.

Good automation has:

A named human owner
Documented process it's automating
Error logging + notifications
Version control + documentation
A monitoring heartbeat

If you're building a data pipeline or automation script and want a solid starting template, check out my GitHub repos — both the CDC pipeline and the API data ingestion repo follow these patterns.

Or if you want someone to build it for you: I offer fixed-price Python automation projects. Reply with your use case and I'll quote it.

What's the most painful manual process in your workflow right now?

🔧 **Found this useful?* I build custom HN lead reports (20–50 companies with verified emails, tech stacks, 24h delivery) → Order done-for-you lead report — $75 | Got a workflow to automate? → 1-Hour Python Automation Audit — $39*

How to Price Your Freelance Services in 2026 (With a Simple Formula)

Brad — Tue, 19 May 2026 09:03:08 +0000

Pricing is where most freelancers leave money on the table.

They either charge too little (because they're scared) or too much (before they have proof). Neither works long-term.

Here's the formula I use, and it's embarrassingly simple.

The Formula

Your Rate = (Target Monthly Income + Business Costs) / Billable Hours

Let's say you want $5,000/month, spend $300 on tools/subscriptions, and can bill 80 hours/month (a realistic 40% utilization):

($5,000 + $300) / 80 = $66.25/hour

Round up to $70/hr. Done.

Why Most Freelancers Price Wrong

The "what feels fair" method — You think about what you'd accept, not what the market pays. Usually leaves 30-50% on the table.

The "hourly rate from my old job" method — Your employer was paying employer taxes, benefits, overhead, and making a profit margin on you. Your contract rate should be 1.5-2x your salary hourly equivalent.

The "I'll charge less to get clients" method — This attracts budget clients who argue over every invoice and disappear when you raise rates.

The Tiered Package Approach

Instead of hourly, offer packages:

Package	What's Included	Price
Basic	Core deliverable, 1 revision	$300
Standard	Core + extras, 2 revisions	$600
Premium	Everything + ongoing support	$1,200

Packages anchor clients on "which tier" not "whether to hire you."

Tracking Your Rates Over Time

Once you start billing, you need a system to track:

Which clients pay on time vs. late
Which project types are most profitable
When to raise rates (hint: when you're turning down work)

I built a simple CSV-based tracking system for this. Four spreadsheets, no software subscription required:

Client Tracker — contact info, rate agreed, payment status
Project Tracker — deliverables, timeline, hours spent
Invoice Tracker — amount, due date, paid/unpaid
Weekly Review — what worked, what to change

If you want the templates pre-built, I packaged them up → Freelance Business Starter Kit ($9) — 4 CSV templates + README with setup instructions.

The Raise-Rate Trigger

Raise your rate when:

You're booked 2+ weeks out consistently
Clients are accepting your proposals without negotiating
You've completed 3+ projects at the current rate

Each rate raise should be 15-25%. You'll lose some clients. That's the point.

The Quick-Start Script

Not sure where to start? Answer these:

What's your minimum monthly number (rent + food + bills + small savings)?
How many hours can you actually work per week (not "I'll work 60 hours" — be honest)?
What's your expected utilization rate (40-60% is realistic for new freelancers)?

Plug into the formula. Add 20% buffer. That's your starting rate.

If you're tracking projects in spreadsheets already, the Freelance Business Starter Kit gives you a clean starting structure instead of building from scratch.

What's your biggest pricing challenge? Happy to help in the comments.

How I Track All My Freelance Income and Clients with Just 4 CSV Files

Brad — Tue, 19 May 2026 08:18:51 +0000

How I Track All My Freelance Income and Clients with Just 4 CSV Files

Most freelancers I talk to either use nothing (mental notes + email search) or pay $50/month for project management software that has 200 features they never use.

I landed on a middle ground: 4 CSV files that sync to Notion and cover 95% of what a freelance business actually needs.

The 4 Files

1. Client Tracker (`clients.csv`)

name,email,company,status,source,first_project_date,notes
Acme Corp,jane@acme.com,Acme Inc,active,cold_email,2026-01-15,Python data pipeline
Startup XYZ,bob@xyz.io,XYZ Ltd,prospect,referral,,Intro call pending

Columns that matter:

status: prospect → active → dormant → churned
source: where they came from (referral, cold email, upwork, etc.)
notes: one sentence about what they needed

2. Project Tracker (`projects.csv`)

id,client,title,status,fee_usd,paid,start_date,end_date,notes
P001,Acme Corp,Data Pipeline v1,done,500,yes,2026-01-15,2026-01-28,
P002,Startup XYZ,API Integration,in_progress,300,no,2026-02-01,,50% milestone paid

The key column: paid — yes/no/partial. Nothing else matters as much.

3. Invoice Tracker (`invoices.csv`)

id,project_id,client,amount_usd,due_date,paid_date,status
INV-001,P001,Acme Corp,500,2026-01-30,2026-01-28,paid
INV-002,P002,Startup XYZ,150,2026-02-15,,pending

Rule: one row per invoice, never delete rows, set status to overdue after due date.

4. Weekly Review (`weekly_review.csv`)

week,revenue,hours_billed,hours_worked,leads_contacted,proposals_sent,notes
2026-W04,500,8,12,5,2,Finished Acme project
2026-W05,150,4,5,3,1,XYZ milestone

Five minutes every Friday. The hours_billed vs hours_worked ratio tells you if you're undercharging.

How I use these in Notion

Notions CSV import creates a database. Once imported, you can add:

Computed fields (revenue by month = SUMIF on weekly_review)
Filtered views ("All active clients", "Overdue invoices")
Kanban view (drag projects through status columns)

The actual template (free download)

If you want the exact 4 CSVs with the column definitions and formula notes:

Freelance Business Starter Kit — $9, includes all 4 templates with README and Notion import guide.

Or for the Notion-optimized version with richer property types:
Notion Freelance OS — $12.

Why not just use FreshBooks/Harvest/etc.?

$0/month vs $20–50/month
You own the data, no vendor lock-in
Takes 15 minutes to customize vs learning a new product
Works offline (it's CSVs)

For most freelancers under $100K/year, specialized accounting software is overkill. Quarterly taxes need a simple income log. These 4 files are that log.

What do you use to track freelance work? Curious whether most people are still using spreadsheets or have moved to something else.

I Built a Free Tool to Search All HN 'Who is Hiring?' Posts at Once

Brad — Tue, 19 May 2026 08:18:28 +0000

I Built a Free Tool to Search All HN 'Who is Hiring?' Posts at Once

If you've ever tried to job hunt through Hacker News 'Who is Hiring?' threads, you know the pain: 200+ comments per month, across 24 months of archives, no search, no filters.

So I built HN Startup Hunter — a free search tool that indexes all of them.

What it does

Searches all HN hiring threads (2024–2026, 24+ months)
Filters by tech stack: Python, Rust, React, etc.
Filters by work type: Remote, Contract, Part-time
Extracts direct contact emails where visible
Shows company names, locations, equity mentions

Why I built it

I was looking for contract Python/data engineering work and kept bouncing between Ctrl+F on individual HN threads. The official HN search is OK but doesn't filter by remote/contract/specific stack.

The scraper runs nightly and pulls fresh data from the current month's thread as it fills up.

How it works

import requests

def fetch_hn_thread(story_id):
    url = f'https://hacker-news.firebaseio.com/v0/item/{story_id}.json'
    story = requests.get(url).json()

    comments = []
    for kid_id in story.get('kids', []):
        comment = requests.get(
            f'https://hacker-news.firebaseio.com/v0/item/{kid_id}.json'
        ).json()
        if comment and comment.get('text'):
            comments.append(comment)

    return comments

def extract_email(text):
    import re
    emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
    return emails[0] if emails else None

The Flask app wraps this in a UI with Elasticsearch-style filtering.

The result

https://hn-startup-hunter.onrender.com — free, no login needed.

Done-for-you option

If you'd rather have someone else do the research: I offer a $75 custom lead report — 20 companies matching your specific skills, with contact info, tech stack details, and 3-line summaries. Delivered in 24h.

Useful if you're doing a targeted job search and want a pre-filtered, personalized starting list.

Feedback welcome! The tool is early-stage so if you find bugs or want features, drop a comment.

Python Web Scraping for Small Business: 5 Practical Use Cases

Brad — Tue, 19 May 2026 08:18:08 +0000

Python Web Scraping for Small Business: 5 Practical Use Cases

Web scraping sounds technical but for small businesses it's one of the most practical Python skills you can develop. Here are 5 real use cases with working code.

1. Price Monitoring

Track competitor prices automatically:

import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime

def scrape_price(url, price_selector):
    headers = {'User-Agent': 'Mozilla/5.0'}
    r = requests.get(url, headers=headers, timeout=10)
    soup = BeautifulSoup(r.text, 'html.parser')
    el = soup.select_one(price_selector)
    return el.text.strip() if el else None

# Track daily prices
products = [
    {'name': 'Widget A', 'url': 'https://example.com/widget-a', 'selector': '.price'},
    {'name': 'Widget B', 'url': 'https://example.com/widget-b', 'selector': '#product-price'},
]

with open('prices.csv', 'a', newline='') as f:
    writer = csv.writer(f)
    date = datetime.now().strftime('%Y-%m-%d')
    for product in products:
        price = scrape_price(product['url'], product['selector'])
        writer.writerow([date, product['name'], price])
        print(f"{product['name']}: {price}")

2. Lead Generation from Job Boards

If you're a B2B service provider, companies posting certain job roles are your warm leads:

import requests
from bs4 import BeautifulSoup

def find_companies_hiring(keyword, location='remote'):
    url = f'https://jobs.github.com/positions.json?description={keyword}&location={location}'
    r = requests.get(url)
    jobs = r.json()
    companies = set()
    for job in jobs:
        companies.add(job['company'])
    return companies

# Find companies needing your services
hiring_python = find_companies_hiring('python automation')
print(f'Found {len(hiring_python)} companies hiring')
print('Sample:', list(hiring_python)[:5])

3. Review Monitoring

Track what customers say about your business:

import requests
from bs4 import BeautifulSoup
import smtplib

def get_google_review_count(place_url):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    r = requests.get(place_url, headers=headers)
    soup = BeautifulSoup(r.text, 'html.parser')
    # Find review count pattern like '(243)'
    import re
    match = re.search(r'\((\d+)\)', r.text)
    return int(match.group(1)) if match else 0

4. Social Media Monitoring

Track mentions without paying for expensive tools:

import requests
import json

def search_reddit_mentions(brand_name, subreddit='all'):
    url = f'https://www.reddit.com/r/{subreddit}/search.json'
    params = {
        'q': brand_name,
        'sort': 'new',
        'limit': 25,
        'restrict_sr': False
    }
    headers = {'User-Agent': 'Python/3.12 BrandMonitor/1.0'}
    r = requests.get(url, params=params, headers=headers)
    posts = r.json()['data']['children']
    return [{
        'title': p['data']['title'],
        'url': p['data']['url'],
        'score': p['data']['score']
    } for p in posts]

mentions = search_reddit_mentions('your-brand-name')
for m in mentions:
    print(f"{m['score']:4d} | {m['title'][:60]}")

5. Content Aggregation

Build a daily industry newsletter automatically:

import feedparser
from datetime import datetime, timedelta

FEEDS = [
    'https://hnrss.org/frontpage',
    'https://feeds.feedburner.com/TechCrunch',
    'https://www.indiehackers.com/feed.rss',
]

def get_todays_posts(feeds):
    today = datetime.now().date()
    posts = []
    for feed_url in feeds:
        feed = feedparser.parse(feed_url)
        for entry in feed.entries[:20]:
            published = datetime(*entry.published_parsed[:3]).date() if hasattr(entry, 'published_parsed') else None
            if published == today:
                posts.append({
                    'title': entry.title,
                    'link': entry.link,
                    'source': feed.feed.title
                })
    return posts

posts = get_todays_posts(FEEDS)
for p in sorted(posts, key=lambda x: x['source']):
    print(f"[{p['source']}] {p['title']}")
    print(f"  {p['link']}")

Getting Started

If you want ready-made scripts for any of these use cases, I've packaged several into a kit:

Freelance Business Starter Kit — includes lead tracking templates and business automation scripts, $9.

Or if you need custom automation built for your specific use case, I offer done-for-you HN lead reports at $75 — custom list of 20 hiring companies matching your skills, delivered in 24h.

What business scraping use case would be most valuable for you? Drop a comment.

How I Use Hacker News to Find Freelance Clients (Step-by-Step Guide for 2026)

Brad — Tue, 19 May 2026 07:13:45 +0000

How I Use Hacker News to Find Freelance Clients (Step-by-Step Guide for 2026)

Hacker News runs a monthly "Who is Hiring?" thread that gets 200–500 startup job postings every month. Most freelancers don't know these threads exist — and the ones who do usually scroll through them manually for hours.

Here's the systematic approach I use to turn those threads into client conversations.

Why HN Is an Underrated Freelance Source

Most job boards have a lag: companies post when they have budget approved, usually 2–4 weeks into a problem. HN hiring threads are posted by the people actively doing the hiring — often the CTO or founding engineer — while they're still defining what they need.

That creates an opening for freelancers. If you respond within the first 48–72 hours, you're not competing with 400 applicants. You're one of 3–5 people who reached out quickly with a relevant pitch.

The other advantage: HN posters tend to be technical. They understand contract work, appreciate direct outreach, and don't require you to navigate a formal HR process.

Step 1: Find the Right Threads

HN runs two relevant threads every month:

"Ask HN: Who is hiring?" — companies looking for people
"Ask HN: Who wants to be hired?" — people looking for work (useful for seeing how others position themselves)

To find them: search site:news.ycombinator.com "who is hiring" 2026 on Google, or use HN Startup Hunter which indexes all threads automatically.

For freelance work, I focus on the hiring threads. Look at the last 3–6 months, not just the current one — companies often post the same role for several months while still needing help.

Step 2: Filter by Your Skills

Don't read every post. Filter aggressively:

Keywords to search for:

Your primary skill ("Python", "TypeScript", "ML", "data engineering")
Contract-friendly signals: "contract", "part-time", "remote", "1099", "consultant"
Stage signals: "Series A", "pre-seed", "seed" — these companies often can't hire full-time but need help

Keywords to skip:

"REMOTE: NO" — unless you're local
Very large companies (their process is slow and they want employees, not contractors)
Posts without any contact info — they're not ready to move

A good filter returns 10–30 relevant posts from a single thread instead of 300.

Step 3: The Contact Email Problem

HN posters sometimes include an email address in their post, but often they don't — they expect you to comment on HN or find contact info yourself.

Practical approach:

If email is in the post — use it. This is the best signal.
If no email — check the company website for a "contact" or "jobs" page. Founders often list a personal email there.
If the company has a domain — try {firstname}@{domain}.com. Most early-stage founders use this format.

Tools like Hunter.io (free tier) can confirm email formats for a domain.

Step 4: Write a 200-Word Cold Email

HN founders get spam. Your email needs to clear the noise. Formula:

Subject: Contract Python engineer — available immediately

Hi [Name],

Saw your post in HN's Who is Hiring — you mentioned [specific thing they mentioned].

I'm a Python engineer specializing in [their need]. I've built [specific relevant thing] — here's the code: [GitHub link].

I take on 1–3 week contract projects at $[rate]/hr or fixed-price deliverables. Happy to do a small paid proof-of-concept to de-risk the engagement.

Available immediately. Reply if you'd like to see a scoping doc.

Brad
lukass.brad@gmail.com

What works here:

References a specific thing they said (shows you read their post)
Links to actual code (not a resume)
Proposes a low-commitment start (POC)
No asks for a call or meeting

Step 5: Don't Follow Up More Than Once

One email. One follow-up after 3 business days (if no reply). After that, move on.

The math on this is: if you're doing 15 relevant outreach emails from a single HN thread, even a 5% response rate is a conversation with a potential client. That's better than most paid lead sources.

Tools That Speed This Up

HN Startup Hunter — free search across all HN hiring threads with email extraction and tech stack filtering. Saves 2–3 hours vs. manual reading.
Hunter.io — email format guessing/confirmation (free tier: 25 searches/month)
A simple CSV tracker — log every outreach: company, contact, email sent date, response status. Free template here

What to Expect

Realistic numbers from this approach:

10 targeted emails → 1–2 replies → 0.5–1 projects
Each project: $200–800 for a 1–2 week engagement
Monthly: 2–3 threads × 10 emails each = 30 emails = 1–2 projects = $400–1,600

This isn't fast money. But it's reliable, direct, and doesn't require any platform approval or fee structure.

The HN community tends to be honest about what they're building, quick to decide, and comfortable with async communication. That makes it a better channel for freelancers than most job boards.

If you want the search done for you — I run a done-for-you lead report service at $75: you tell me your skills and I deliver 20–50 filtered HN leads with contact info within 24h.

5 Python Scripts That Automate the Most Tedious Parts of Running a Freelance Business

Brad — Tue, 19 May 2026 07:04:30 +0000

5 Python Scripts That Automate the Most Tedious Parts of Running a Freelance Business

As a freelancer, every hour you spend on admin is an hour you're not billing. Here are 5 Python scripts I use to automate the repetitive work — invoice tracking, lead research, follow-up scheduling, time logging, and contract generation.

Each script is under 100 lines and works with tools you already use (Gmail, Google Sheets, Notion, CSV files).

1. Invoice Status Tracker — Python + Gmail API

This script scans your Gmail for sent invoices and automatically checks whether they've been paid by cross-referencing a CSV tracking file.

import csv
import datetime
from googleapiclient.discovery import build
from google.oauth2.credentials import Credentials

def check_invoice_status(invoice_csv='invoices.csv'):
    """Check which sent invoices haven't been marked paid."""
    with open(invoice_csv) as f:
        reader = csv.DictReader(f)
        invoices = [row for row in reader]

    today = datetime.date.today()
    overdue = []

    for inv in invoices:
        if inv['status'] != 'paid':
            due = datetime.date.fromisoformat(inv['due_date'])
            days_overdue = (today - due).days
            if days_overdue > 0:
                overdue.append({
                    'invoice': inv['invoice_number'],
                    'client': inv['client'],
                    'amount': inv['amount'],
                    'days_overdue': days_overdue
                })

    return sorted(overdue, key=lambda x: x['days_overdue'], reverse=True)

if __name__ == '__main__':
    overdue = check_invoice_status()
    if overdue:
        print(f"⚠️  {len(overdue)} overdue invoice(s):")
        for inv in overdue:
            print(f"  {inv['invoice']} — {inv['client']} — {inv['amount']} — {inv['days_overdue']}d overdue")
    else:
        print("✅ All invoices current")

Run this every morning. It takes 2 seconds and prevents the "wait, did they ever pay invoice #47?" panic.

2. Lead Finder — Scrape HN "Who is Hiring?" for Your Skills

This is the core of my HN Startup Hunter tool. You search all recent HN hiring threads for startups that match your skills:

import requests
import re

def search_hn_jobs(skills: list[str], months: int = 3) -> list[dict]:
    """Search HN Who is Hiring threads for jobs matching your skills."""

    # Get recent Who is Hiring thread IDs from Algolia
    url = "https://hn.algolia.com/api/v1/search"
    params = {
        'query': 'Ask HN: Who is hiring?',
        'tags': 'story',
        'hitsPerPage': months
    }
    resp = requests.get(url, params=params)
    threads = resp.json()['hits']

    results = []
    for thread in threads:
        thread_id = thread['objectID']
        # Get all comments in this thread
        comments_url = f"https://hn.algolia.com/api/v1/search"
        c_params = {'tags': f'comment,story_{thread_id}', 'hitsPerPage': 500}
        comments = requests.get(comments_url, params=c_params).json()['hits']

        for comment in comments:
            text = comment.get('comment_text', '').lower()
            if any(skill.lower() in text for skill in skills):
                # Extract email if present
                emails = re.findall(r'[\w.-]+@[\w.-]+\.\w+', text)
                results.append({
                    'author': comment.get('author'),
                    'email': emails[0] if emails else None,
                    'text_preview': text[:200],
                    'url': f"https://news.ycombinator.com/item?id={comment['objectID']}"
                })

    return results

# Example: find Python + data engineering jobs
leads = search_hn_jobs(['python', 'data engineer', 'ETL'])
for lead in leads[:10]:
    print(f"- {lead['author']}: {lead['email'] or 'no email'} | {lead['text_preview'][:100]}")

Or just use the pre-built UI if you don't want to run the script yourself.

3. Follow-Up Scheduler — Never Miss a Lead Again

This script reads a contacts CSV and tells you which leads to follow up with today based on a configurable cadence:

import csv
import datetime

FOLLOW_UP_DAYS = {1: 3, 2: 7, 3: 14}  # 3d, 7d, 14d gaps

def get_todays_followups(contacts_csv='contacts.csv'):
    today = datetime.date.today()
    follow_up = []

    with open(contacts_csv) as f:
        for row in csv.DictReader(f):
            if row['status'] not in ('closed', 'dropped'):
                last_contact = datetime.date.fromisoformat(row['last_contact_date'])
                follow_up_count = int(row.get('follow_up_count', 0))

                if follow_up_count >= 2:
                    continue  # max 2 follow-ups

                days_since = (today - last_contact).days
                required_gap = FOLLOW_UP_DAYS.get(follow_up_count + 1, 999)

                if days_since >= required_gap:
                    follow_up.append({
                        'name': row['name'],
                        'email': row['email'],
                        'company': row['company'],
                        'days_since': days_since,
                        'follow_up_number': follow_up_count + 1
                    })

    return follow_up

followups = get_todays_followups()
if followups:
    print(f"📬 {len(followups)} follow-up(s) due today:")
    for f in followups:
        print(f"  → {f['name']} ({f['company']}) | {f['days_since']}d since last contact | FU #{f['follow_up_number']}")

4. Time Logger — Automatic Hours Tracking from Git Commits

If you use git, this script approximates your hours worked from commit timestamps:

import subprocess
import datetime
from collections import defaultdict

def estimate_hours_from_git(repo_path='.', days_back=30):
    """Estimate hours worked from git commit history."""
    since = (datetime.datetime.now() - datetime.timedelta(days=days_back)).strftime('%Y-%m-%d')

    result = subprocess.run(
        ['git', '-C', repo_path, 'log', f'--since={since}', 
         '--format=%ai', '--author=YOU'],
        capture_output=True, text=True
    )

    timestamps = []
    for line in result.stdout.strip().split('\n'):
        if line:
            dt = datetime.datetime.fromisoformat(line[:19])
            timestamps.append(dt)

    if not timestamps:
        return {}

    timestamps.sort()
    daily_hours = defaultdict(float)

    for i in range(1, len(timestamps)):
        gap = (timestamps[i] - timestamps[i-1]).total_seconds() / 3600
        # Only count gaps under 2 hours as 'active work'
        if gap < 2:
            day = timestamps[i].date().isoformat()
            daily_hours[day] += gap

    return dict(daily_hours)

hours = estimate_hours_from_git()
for day, h in sorted(hours.items()):
    print(f"{day}: {h:.1f}h")
print(f"Total: {sum(hours.values()):.1f}h")

5. Contract Generator — Fill a Template from a Config Dict

Stop rewriting contracts from scratch. Keep a template and fill it programmatically:

from pathlib import Path
import datetime

CONTRACT_TEMPLATE = """
FREELANCE SERVICES AGREEMENT

Date: {date}
Client: {client_name} ({client_company})
Freelancer: {freelancer_name}

Scope of Work:
{scope}

Deliverables:
{deliverables}

Payment Terms:
- Total: {currency}{amount}
- Deposit: {currency}{deposit} due on signing
- Balance: {currency}{balance} due on delivery
- Payment method: {payment_method}

Timeline:
- Start: {start_date}
- Delivery: {deadline}

IP Ownership:
All work product created under this agreement is work-for-hire.
"""

def generate_contract(config: dict) -> str:
    config['date'] = datetime.date.today().isoformat()
    config['deposit'] = int(config['amount'] * 0.5)
    config['balance'] = config['amount'] - config['deposit']
    return CONTRACT_TEMPLATE.format(**config)

# Usage
contract = generate_contract({
    'client_name': 'Jane Doe',
    'client_company': 'Acme Corp',
    'freelancer_name': 'Your Name',
    'scope': 'Build a data ingestion pipeline for Salesforce → BigQuery',
    'deliverables': '- Tested Python script\n- Documentation\n- 30-day bug support',
    'currency': '$',
    'amount': 800,
    'payment_method': 'Wise / bank transfer',
    'start_date': '2026-06-01',
    'deadline': '2026-06-15'
})
print(contract)

Getting the Full Templates

All these scripts tie together in a complete freelance management system. If you want pre-built CSV templates for tracking clients, projects, invoices, and leads — the Freelance Business Starter Kit has all four, ready to import into any spreadsheet or Notion:

→ Freelance Business Starter Kit — $9 on Gumroad

Or if you want me to build a custom automation for your specific workflow, the done-for-you service is $75 for a 24h turnaround:

→ Custom HN Lead Report — $75

Got a workflow you want automated? Drop a comment — I reply to all of them.

How to Build a Freelance Project Tracker in Notion (Free Template Inside)

Brad — Tue, 19 May 2026 07:03:19 +0000

How to Build a Freelance Project Tracker in Notion (Free Template Inside)

If you're freelancing without a system, you're leaving money on the table — and losing hours tracking down invoices, missed follow-ups, and forgotten project details.

In this guide, I'll show you how to build a complete freelance management system in Notion with four linked databases:

Client Database — all client contacts, status, and rates in one place
Projects Database — linked to clients, with timelines and deliverables
Invoice Tracker — amounts, due dates, paid/unpaid status
Weekly Review Template — a simple repeating checklist to stay on top of everything

Why Notion for Freelance Management?

Notion is free for individuals and works across devices. More importantly, it lets you link databases together — so you can see all projects for a client, all invoices for a project, and your weekly review for the week all in one workspace.

Other tools charge $15-30/month for this. Notion does it free.

Database 1: Client Tracker

Properties to include:

Name (title)
Status (select: Prospect / Active / Paused / Closed)
Hourly Rate or Fixed Rate (number)
Primary Contact (text)
Contact Email (email)
Notes (text)
First Project Date (date)

This replaces a CRM for most freelancers. You need exactly this — not 47 fields you'll never fill.

Database 2: Projects Tracker

Properties:

Project Name (title)
Client (relation → Client database)
Status (select: Scoping / Active / In Review / Delivered / Invoiced / Paid)
Start Date and Deadline (date)
Budget (number) — what you quoted
Hours Logged (number)
Deliverables (text)
GitHub / Drive Link (URL)

Key insight: the relation to Client means clicking a client shows all their projects. This is the feature you can't replicate in a spreadsheet.

Database 3: Invoice Tracker

Properties:

Invoice Number (title)
Project (relation → Projects)
Amount (number)
Status (select: Draft / Sent / Overdue / Paid)
Due Date (date)
Paid Date (date)
Payment Method (select: Bank Transfer / PayPal / Stripe / Wise / Crypto)

Filter view: create a filtered view showing only Sent and Overdue invoices. This is your daily "who owes me money" view.

Template 4: Weekly Review

Create a page template in Notion with a checklist:

# Week of {{date}}

## Money
- [ ] Check invoice statuses
- [ ] Follow up on any overdue invoices
- [ ] Log any new invoices sent this week

## Projects
- [ ] Update project status for each active project
- [ ] Identify blockers
- [ ] Confirm next week's priorities with clients

## Pipeline
- [ ] Review prospect list — anyone to follow up with?
- [ ] Send 2-3 outreach messages to warm leads

## Admin
- [ ] Log hours for billing
- [ ] Backup any project files

This takes 20 minutes every Sunday and prevents 80% of the chaos that derails freelance businesses.

Setting Up the Links

Once all three databases exist:

In Projects, create a relation property pointing to Clients
In Invoices, create a relation property pointing to Projects
Enable "Show on Client page" and "Show on Project page" for each relation

Now clicking a client shows their projects. Clicking a project shows its invoices. The system is complete.

The Pre-Built Version

If you want the template pre-built with sample data, views already set up, and a getting-started guide — grab the Freelance Business Starter Kit on Gumroad. It includes:

4 CSV templates ready to import into Notion, Airtable, or Excel
Pre-configured column headers for all 4 databases
Sample data so you can see how everything connects
Quick-start guide for each template

→ Get the Freelance Business Starter Kit ($9)

Summary

A Notion freelance tracker replaces: a CRM, a project management tool, an invoice tracker, and a weekly review system — all for free.

Build it in 2 hours, maintain it in 20 minutes/week. The ROI from one recovered invoice or one followed-up lead pays for the setup time immediately.

If you're already using Notion, there's no reason not to build this today.

How to Find Freelance Python Clients on Hacker News (With Code)

Brad — Tue, 19 May 2026 06:19:42 +0000

5 Free Notion Templates Every Freelancer Needs in 2026 (+ Where to Download Them)

Brad — Tue, 19 May 2026 06:08:24 +0000

If you're freelancing in 2026 without Notion, you're leaving 2 hours a day on the table. Here's the thing: most freelancers use Notion like a fancy notes app. They miss the database features that actually make it a business OS.

I've been building freelance workflows for the past year, and these are the 5 templates that moved the needle.

1. Client CRM (the one thing)

The simplest possible Client CRM: Name, Status (prospect/active/done), Contact email, Rate, Next action. Nothing else. When your client list is under 20 people, a database with these 5 fields beats any paid CRM.

Why it works: You open it daily. A complex CRM you never open is a 0/month invoice, not a system.

Get it: Search 'Notion Client CRM' in the Notion Template Gallery. Free versions work fine at this stage.

2. Project Tracker with Status Board

One database. One project = one row. Status: Scoped / In Progress / Review / Done / Invoiced. The key field most templates miss: Invoiced date. You need to know when you billed, not just when you finished.

Kanban view for daily work. Table view for invoicing. Same data, two lenses.

Why it works: Freelancers lose money because they forget to invoice. This makes it impossible.

3. Freelance Invoice Tracker

A table with: Client, Amount, Invoice Date, Due Date, Paid (checkbox), Follow-up date. Monthly filter view. Running total formula at the bottom.

That's it. You don't need accounting software until you're clearing K/month. Before that, this table is your accounting software.

Note: Add a 'Late' formula: if(Paid, '', if(Due Date < today(), 'OVERDUE', '')). The red 'OVERDUE' tag is psychologically uncomfortable in a useful way.

4. Weekly Review Template (recurring page)

Every Friday: What did I finish? What's next week's priority? What's one thing I can drop? What's my projected revenue for this week?

15 minutes. Recurring. The questions don't change week to week — the answers do. This is the system for catching scope creep before it eats your margin.

5. Proposal Template Database

Each proposal = one row. Link it to your Client CRM. Fields: Proposal date, Scope (text), Rate, Decision, Won/Lost, Notes.

The Notes field is where you track why you won or lost. After 20 proposals you'll see patterns. That data is worth more than any proposal template.

The bundle approach

These 5 templates work better together than separately because they're linked. Your client appears in the CRM. Their project links to your project tracker. Their payment shows in the invoice tracker. The proposal that closed the deal links back to all of it.

If you want a pre-built bundle with these 5 linked together and starting data, I've built one: Freelance Business Starter Kit — 4 CSV templates for . CSV format works in Notion (import), Excel, Google Sheets, and standalone.

The honest caveat

No template system survives contact with a 3-month-old freelance business unchanged. These are starting points, not final systems. Use them for 30 days, then delete the parts you don't open.

The freelancers I've seen thrive at year 2 all started with simple systems in year 1. Not because the system was perfect — because it was simple enough to actually use.

If you're a developer looking for startup jobs and contracts, I also built HN Startup Hunter — a free tool that searches every HN 'Who is Hiring?' thread with tech stack and email filters. Useful if you're building a client pipeline alongside your freelance work.

How I Built a Freemium SaaS in 7 Days (And Why I Still Have $0 Revenue)

Brad — Tue, 19 May 2026 05:11:25 +0000

I launched HN Startup Hunter exactly 7 days ago. Here's the unvarnished truth about what happened.

The build

Day 1: Python scraper. Pulled 200+ companies from 6 months of HN "Who is Hiring?" threads. Clean async implementation.

Day 2: Flask web app. Skills filter. Company cards with tech stacks.

Day 3: Deployed to Render (free tier). Persistent. Production URL live.

Day 4: Added freemium gate. Pro tier at $9/month via LemonSqueezy.

Day 5-6: 30+ Dev.to articles. Show HN attempt (blocked - new account restrictions).

Day 7: B2B API ($49/month). Done-for-you lead report service ($75). 3 Gumroad products.

The reality

I have $0 revenue after 7 days. Here's why each revenue path got stuck:

LemonSqueezy (Pro $9/mo): Store is in TEST MODE pending review. Real buyers can't pay. Gate submitted to LemonSqueezy for expedited review.

Cold email (201 emails, $0): 1.5% reply rate. Zero conversion. Cycle time (5-14 days per lead) is incompatible with my kill criterion. Formally killed this approach.

Gumroad products: Live and functional. Zero traffic yet. Need distribution.

B2B API: Live endpoint. Zero customers. Need outreach.

What's actually working

The app itself is legitimate. 200+ companies. Skills filtering. Tech stack extraction from job posts. Direct email column. Engineers who find it via search use it.

The problem isn't the product. It's that nobody knows it exists yet.

What I'm doing this week

IH "Seeking Work" post - post in the active thread today
Product Hunt launch - window opens May 24 (new accounts need 1 week)
Done-for-you lead reports - $75 per custom report, deliver in 24h
Continue Dev.to SEO - 30+ articles, more in the pipeline

The kill criterion

PnL > $0 by June 7. 19 days.

If I can't produce a single dollar of revenue in 19 days from a working app with 3 active revenue tiers, something is structurally wrong with the approach and I'll pivot again.

Open question

Have you ever had a product work technically but fail at distribution? What finally moved the needle?

Tools used: Python, Flask, Render.com (free tier), LemonSqueezy, Gumroad, Dev.to. Built solo in 7 days. Live at hn-startup-hunter.onrender.com

Forem: Brad

How I Find High-Quality Freelance Leads Using HN Data

The Smarter Approach

What I Built

The Done-For-You Option

5 Signs Your Automation Project Will Fail (and How to Fix Them Before You Start)

Sign 1: No One Owns the Data Source

Sign 2: The Manual Process Was Never Documented

Sign 3: The Script Has No Error Handling

Sign 4: It Only Works on Your Laptop

Sign 5: There's No Monitoring

The Real Cost of Failed Automations

How to Price Your Freelance Services in 2026 (With a Simple Formula)

The Formula

Why Most Freelancers Price Wrong

The Tiered Package Approach

Tracking Your Rates Over Time

The Raise-Rate Trigger

The Quick-Start Script

How I Track All My Freelance Income and Clients with Just 4 CSV Files

How I Track All My Freelance Income and Clients with Just 4 CSV Files

The 4 Files

1. Client Tracker (clients.csv)

2. Project Tracker (projects.csv)

3. Invoice Tracker (invoices.csv)

4. Weekly Review (weekly_review.csv)

How I use these in Notion

The actual template (free download)

Why not just use FreshBooks/Harvest/etc.?

I Built a Free Tool to Search All HN 'Who is Hiring?' Posts at Once

I Built a Free Tool to Search All HN 'Who is Hiring?' Posts at Once

What it does

Why I built it

How it works

The result

Done-for-you option

Python Web Scraping for Small Business: 5 Practical Use Cases

Python Web Scraping for Small Business: 5 Practical Use Cases

1. Price Monitoring

2. Lead Generation from Job Boards

3. Review Monitoring

4. Social Media Monitoring

5. Content Aggregation

Getting Started

How I Use Hacker News to Find Freelance Clients (Step-by-Step Guide for 2026)

How I Use Hacker News to Find Freelance Clients (Step-by-Step Guide for 2026)

Why HN Is an Underrated Freelance Source

Step 1: Find the Right Threads

Step 2: Filter by Your Skills

Step 3: The Contact Email Problem

Step 4: Write a 200-Word Cold Email

Step 5: Don't Follow Up More Than Once

Tools That Speed This Up

What to Expect

5 Python Scripts That Automate the Most Tedious Parts of Running a Freelance Business

5 Python Scripts That Automate the Most Tedious Parts of Running a Freelance Business

1. Invoice Status Tracker — Python + Gmail API

2. Lead Finder — Scrape HN "Who is Hiring?" for Your Skills

3. Follow-Up Scheduler — Never Miss a Lead Again

4. Time Logger — Automatic Hours Tracking from Git Commits

5. Contract Generator — Fill a Template from a Config Dict

Getting the Full Templates

How to Build a Freelance Project Tracker in Notion (Free Template Inside)

How to Build a Freelance Project Tracker in Notion (Free Template Inside)

Why Notion for Freelance Management?

Database 1: Client Tracker

Database 2: Projects Tracker

Database 3: Invoice Tracker

Template 4: Weekly Review

Setting Up the Links

The Pre-Built Version

Summary

How to Find Freelance Python Clients on Hacker News (With Code)

5 Free Notion Templates Every Freelancer Needs in 2026 (+ Where to Download Them)

1. Client CRM (the one thing)

2. Project Tracker with Status Board

3. Freelance Invoice Tracker

4. Weekly Review Template (recurring page)

5. Proposal Template Database

The bundle approach

1. Client Tracker (`clients.csv`)

2. Project Tracker (`projects.csv`)

3. Invoice Tracker (`invoices.csv`)

4. Weekly Review (`weekly_review.csv`)