How I Replaced 6 SaaS Tools with Python Scripts (Saving ,200/year)

#python #automation #productivity #webdev

I was paying over $1,200/year for tools that could be replaced with Python scripts.

Here's exactly what I built and how much I saved:

The Tools I Replaced

1. Zapier ($240/year) → Python + cron jobs

Zapier is amazing for no-code automation, but if you can write Python, you don't need it.

import schedule
import time
import smtplib
from email.mime.text import MIMEText

def daily_report():
    # Your custom business logic
    report = generate_report()
    send_email("boss@company.com", "Daily Report", report)

schedule.every().day.at("09:00").do(daily_report)

while True:
    schedule.run_pending()
    time.sleep(60)

2. Mailchimp ($156/year) → Python + SMTP

For small lists under 1,000 subscribers, simple SMTP works perfectly.

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import csv

def send_campaign(csv_file, subject, html_body):
    with open(csv_file) as f:
        subscribers = list(csv.DictReader(f))

    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(EMAIL, PASSWORD)
        for sub in subscribers:
            msg = MIMEMultipart('alternative')
            msg['Subject'] = subject
            msg['To'] = sub['email']
            personalized = html_body.replace('{{name}}', sub['name'])
            msg.attach(MIMEText(personalized, 'html'))
            server.sendmail(EMAIL, sub['email'], msg.as_string())
            time.sleep(0.5)  # Rate limiting

    print(f"Campaign sent to {len(subscribers)} subscribers")

3. FreshBooks ($228/year) → Python + ReportLab

from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Table, Paragraph
from reportlab.lib.styles import getSampleStyleSheet
import datetime

def generate_invoice(client_name, items, invoice_num):
    doc = SimpleDocTemplate(f"invoice_{invoice_num}.pdf", pagesize=letter)
    styles = getSampleStyleSheet()

    story = []
    story.append(Paragraph(f"Invoice #{invoice_num}", styles['Title']))
    story.append(Paragraph(f"Bill to: {client_name}", styles['Normal']))
    story.append(Paragraph(f"Date: {datetime.date.today()}", styles['Normal']))

    data = [['Description', 'Hours', 'Rate', 'Total']]
    total = 0
    for item in items:
        subtotal = item['hours'] * item['rate']
        total += subtotal
        data.append([item['desc'], item['hours'], f"${item['rate']}", f"${subtotal}"])
    data.append(['', '', 'TOTAL:', f"${total}"])

    table = Table(data)
    story.append(table)
    doc.build(story)
    return f"invoice_{invoice_num}.pdf"

4. Airtable ($228/year) → Python + SQLite

import sqlite3
import pandas as pd

class SimpleDB:
    def __init__(self, db_file="business.db"):
        self.conn = sqlite3.connect(db_file)
        self.create_tables()

    def create_tables(self):
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS clients (
                id INTEGER PRIMARY KEY,
                name TEXT,
                email TEXT,
                status TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        """)
        self.conn.commit()

    def add_client(self, name, email, status="lead"):
        self.conn.execute(
            "INSERT INTO clients (name, email, status) VALUES (?, ?, ?)",
            (name, email, status)
        )
        self.conn.commit()

    def get_report(self):
        return pd.read_sql("SELECT * FROM clients", self.conn)

# Usage
db = SimpleDB()
db.add_client("Acme Corp", "contact@acme.com", "active")
print(db.get_report())

5. Calendly ($144/year) → Python + Google Calendar API

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

def book_meeting(attendee_email, start_time, duration_minutes=30):
    creds = Credentials.from_authorized_user_file('token.json')
    service = build('calendar', 'v3', credentials=creds)

    end_time = start_time + datetime.timedelta(minutes=duration_minutes)

    event = {
        'summary': 'Meeting',
        'start': {'dateTime': start_time.isoformat(), 'timeZone': 'UTC'},
        'end': {'dateTime': end_time.isoformat(), 'timeZone': 'UTC'},
        'attendees': [{'email': attendee_email}],
        'conferenceData': {
            'createRequest': {'requestId': 'meeting-123'}
        },
    }

    return service.events().insert(
        calendarId='primary',
        body=event,
        conferenceDataVersion=1
    ).execute()

6. Backblaze ($96/year) → Python + rclone

import subprocess
import datetime
import os

def backup_to_cloud(source_dir, destination):
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_name = f"backup_{timestamp}"

    # Using rclone (free, open source)
    cmd = [
        "rclone", "copy",
        source_dir,
        f"{destination}/{backup_name}",
        "--progress",
        "--transfers", "4"
    ]

    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode == 0:
        print(f"Backup completed: {backup_name}")

        # Keep only last 7 backups
        cleanup_old_backups(destination, keep=7)
    else:
        print(f"Backup failed: {result.stderr}")

def cleanup_old_backups(destination, keep=7):
    # List and sort backups, delete oldest
    pass  # Implementation depends on your cloud provider

The Total Savings

Tool	Was	Now	Saved
Zapier	$240/yr	$0	$240
Mailchimp	$156/yr	$0	$156
FreshBooks	$228/yr	$0	$228
Airtable	$228/yr	$0	$228
Calendly	$144/yr	$0	$144
Backblaze	$96/yr	$0	$96
Total	$1,092/yr	$0	$1,092