The Python Automation Stack That Quietly Started Earning Me Money Every Month

I Stopped Building Random Scripts and Started Building Systems Businesses Would Actually Pay For

Photo by Veronica on Unsplash

For a long time, my Python projects followed the same pattern.

I’d discover a cool library.

Build something impressive.

Show it to a few developer friends.

Then move on to the next shiny thing.

The problem?

Nobody was paying for any of it.

The turning point came when I stopped asking:

“What can this library do?”

And started asking:

“What expensive problem can this library solve?”

That single shift changed everything.

Instead of building demos, I started building automation systems that generated leads, created reports, monitored competitors, processed invoices, and handled repetitive business tasks.

Some became freelance services.

Some became internal tools.

A few even turned into small SaaS products.

These are the Python libraries that had the biggest impact on my automation business.

1. Playwright Turned Manual Research Into a Fully Automated Service

One of my first paying automation projects involved collecting pricing information from dozens of competitor websites.

Doing it manually took hours.

So I built a Playwright-powered scraper.

from playwright.sync_api import sync_playwright

def collect_competitor_data():

    with sync_playwright() as p:

        browser = p.chromium.launch(
            headless=True
        )

        page = browser.new_page()

        page.goto(
            "https://example.com/pricing"
        )

        prices = page.locator(
            ".pricing-card"
        ).all_inner_texts()

        browser.close()

        return prices

data = collect_competitor_data()

print(data)

Unlike traditional scraping libraries, Playwright handles modern JavaScript-heavy websites extremely well.

That opens opportunities for:

• Competitor monitoring
• Lead generation
• Market research
• Product tracking

Monetization Idea

Offer competitor intelligence dashboards.

Typical pricing:

• $300–$2,000/month

depending on industry complexity.

2. Pandas Helped Me Turn Raw Data Into Client Reports

Businesses love data.

What they don’t love is organizing it.

That’s where Pandas became one of my most valuable tools.

import pandas as pd

sales = pd.read_csv("sales.csv")

summary = (
    sales
    .groupby("product")
    ["revenue"]
    .sum()
    .reset_index()
)

summary.to_excel(
    "monthly_report.xlsx",
    index=False
)

print(summary)

A surprising number of businesses still rely on spreadsheets.

Automating reporting can save entire teams hours every week.

Revenue Opportunity

Automated reporting systems are easy to sell because ROI is obvious.

3. Polars Replaced Pandas for Large Datasets

Pandas is fantastic.

Until someone sends a 5GB CSV file.

That’s when things get painful.

Polars changed that.

import polars as pl

df = pl.read_csv(
    "massive_dataset.csv"
)

result = (
    df.group_by("category")
      .agg(
          pl.col("sales").sum()
      )
)

print(result)

For large-scale data processing, Polars often feels ridiculously fast.

Clients notice when reports that used to take 20 minutes suddenly finish in seconds.

4. FastAPI Turned Scripts Into Products

Most Python developers stop after building the script.

The money usually starts when you turn that script into a service.

from fastapi import FastAPI

app = FastAPI()

@app.post("/generate-report")
def generate_report(data: dict):

    return {
        "status": "success",
        "rows": len(data)
    }

FastAPI allows you to expose automation functionality through APIs.

Suddenly your script becomes:

• A SaaS backend
• An internal company tool
• A commercial product

That’s a very different business.

5. Celery Allowed My Automations to Run Without Me

One lesson I learned quickly:

Clients don’t care if you’re sleeping.

The automation still needs to run.

That’s where Celery became invaluable.

from celery import Celery

app = Celery(
    "tasks",
    broker="redis://localhost:6379"
)

@app.task
def process_invoice(invoice):

    return {
        "processed": invoice
    }

With scheduled jobs and background workers, automations become reliable systems rather than personal scripts.

6. Rich Made My Tools Look Surprisingly Professional

Presentation matters.

Even command-line tools benefit from a better user experience.

from rich.console import Console
from rich.table import Table

console = Console()

table = Table(
    title="Sales Report"
)

table.add_column("Product")
table.add_column("Revenue")

table.add_row(
    "Course",
    "$5,000"
)

console.print(table)

Rich makes internal tools feel polished.

Clients notice professionalism.

7. DuckDB Became My Secret Analytics Weapon

At one point I was considering setting up a full database stack for analytics.

Then I discovered DuckDB.

import duckdb

result = duckdb.sql("""

SELECT
    category,
    SUM(revenue) AS total

FROM sales

GROUP BY category

""").df()

print(result)

For many analytics projects, DuckDB delivers absurd performance with almost no setup.

Perfect for:

• BI dashboards
• Reporting tools
• Financial analysis

8. Pydantic Eliminated Countless Bugs

Bad input data can destroy automation workflows.

Pydantic catches problems before they become expensive.

from pydantic import BaseModel

class Customer(BaseModel):

    name: str
    email: str
    age: int

customer = Customer(
    name="John",
    email="john@example.com",
    age=30
)

print(customer)

When dealing with client systems, validation isn’t optional.

It’s survival.

9. OpenPyXL Became an Unexpected Money Maker

Developers often underestimate how much business runs on Excel.

I certainly did.

Then clients started asking for:

• Invoice generation
• Budget sheets
• Financial reports
• Inventory tracking

from openpyxl import Workbook

wb = Workbook()

sheet = wb.active

sheet["A1"] = "Revenue"
sheet["B1"] = 5000

wb.save("report.xlsx")

Simple?

Yes.

Profitable?

Also yes.

10. Typer Helped Me Package Tools Clients Could Use

Not every automation needs a web interface.

Sometimes clients just want a simple command.

import typer

app = typer.Typer()

@app.command()
def generate_report(month: str):

    print(
        f"Generating report for {month}"
    )

if __name__ == "__main__":
    app()

Typer makes CLI applications feel modern and professional.

A huge upgrade over raw argparse scripts.

11. The Combination That Changed Everything

The biggest lesson wasn’t discovering a single amazing library.

It was learning how they work together.

A typical automation stack I build today looks like this:

Playwright
     ↓
Pandas / Polars
     ↓
DuckDB
     ↓
Pydantic
     ↓
Celery
     ↓
FastAPI
     ↓
Typer

This pipeline can:

• Collect data automatically
• Process information
• Generate reports
• Validate results
• Schedule tasks
• Deliver outputs

Without human intervention.

And that’s where the real business opportunity exists.

Most companies aren’t looking for revolutionary AI.

They’re looking for fewer repetitive tasks.

Less manual work.

Faster reporting.

Better visibility.