DEV Community

Devadatta Baireddy
Devadatta Baireddy

Posted on

I Built 4 CLI Tools to Avoid Paying for SaaS - Here's How Much I Saved

#python #saas #productivity #opensource

I Built 4 CLI Tools to Avoid Paying for SaaS — Here's How Much I Saved

Last year I was paying for:

  • JSON formatter online tool: $5/month
  • Markdown to HTML converter: $10/month (Docusaurus setup cost)
  • Email validation service: $29/month (Clean.io)
  • SQL builder library: $15/month (npm packages)

Total: $59/month = $708/year

Then I realized: Most of these tasks are trivial to code.

So I built CLI tools for all of them. Took 3 days total. Cost: $0.

Now I pay $0/month.

Here's my story.

The Realization

I was building a data processing pipeline. My workflow:

  1. Get API response (minified JSON)
  2. Copy to online formatter (slow, 2-3 seconds)
  3. Analyze manually (tedious)
  4. Export cleaned data
  5. Validate email list (use paid service)
  6. Build SQL query (write code, test, fix)

Total time per workflow: 15-20 minutes

"Why am I paying for this?" I thought.

The Solution: Build It Myself

I decided to build CLI tools for the most painful tasks.

Tool 1: JSON Formatter

What I paid for: Prettier, online formatter services

Time to build: 45 minutes

import json
import argparse

class JSONFormatter:
    @staticmethod
    def format_pretty(data, indent=2):
        return json.dumps(data, indent=indent, sort_keys=False)

    @staticmethod
    def format_minified(data):
        return json.dumps(data, separators=(',', ':'))

parser = argparse.ArgumentParser()
parser.add_argument("file")
parser.add_argument("--minify", action="store_true")
args = parser.parse_args()

with open(args.file) as f:
    data = json.load(f)

if args.minify:
    print(JSONFormatter.format_minified(data))
else:
    print(JSONFormatter.format_pretty(data))
Enter fullscreen mode Exit fullscreen mode

Saved: $60/year. Now I just run:

python json_formatter.py data.json
Enter fullscreen mode Exit fullscreen mode

Tool 2: Markdown to HTML

What I paid for: Docusaurus, static site generators, manual conversion

Time to build: 90 minutes

The tool converts markdown headers, bold, links, code blocks to HTML:

class MarkdownParser:
    def parse(self, markdown):
        html = ""
        for line in markdown.split('\n'):
            if line.startswith('#'):
                html += self.parse_heading(line)
            elif line.startswith('-'):
                html += self.parse_list(line)
            # ... etc
        return self.wrap_in_html(html)

parser = MarkdownParser()
output = parser.parse(markdown_text)
Enter fullscreen mode Exit fullscreen mode

Saved: $120/year. Now I run:

python markdown_to_html.py readme.md -o index.html
Enter fullscreen mode Exit fullscreen mode

Tool 3: Email Validator

What I paid for: Clean.io, RealEmail, other validation services ($29/month)

Time to build: 120 minutes

I implemented:

  • Syntax validation (regex)
  • Disposable domain detection (dictionary)
  • MX record checking (socket library) 
class EmailValidator:
    def validate_syntax(email):
        return '@' in email and '.' in email.split('@')[1]

    def is_disposable(email):
        domain = email.split('@')[1]
        return domain in DISPOSABLE_DOMAINS

    def check_mx(domain):
        # Check if MX records exist
        try:
            mx_records = dns.resolver.resolve(domain, 'MX')
            return len(mx_records) > 0
        except:
            return False
Enter fullscreen mode Exit fullscreen mode

Saved: $348/year. Now I run:

python email_validator.py emails.txt -o valid.txt
Enter fullscreen mode Exit fullscreen mode

Tool 4: SQL Query Builder

What I paid for: ORM libraries, npm packages, custom code

Time to build: 60 minutes

class SQLBuilder:
    def select(self, columns):
        self.query = f"SELECT {columns}"
        return self

    def from_table(self, table):
        self.query += f" FROM {table}"
        return self

    def where(self, condition):
        self.query += f" WHERE {condition}"
        return self

    def build(self):
        return self.query + ";"

builder = SQLBuilder()
query = builder.select("name, email").from_table("users").where("age > 18").build()
Enter fullscreen mode Exit fullscreen mode

Saved: $180/year. Now I run:

python sql_builder.py --select "name, email" --from "users" --where "age > 18"
Enter fullscreen mode Exit fullscreen mode

Total Savings

Tool Monthly Cost Annual Cost Build Time
JSON Formatter $5 $60 45 min
Markdown to HTML $10 $120 90 min
Email Validator $29 $348 120 min
SQL Builder $15 $180 60 min
TOTAL $59 $708 315 min

I spent 5.25 hours coding and saved $708/year.

ROI: 135x in year one.

The Real Benefits

Beyond money:

1. Speed

Online formatters: 2-3 seconds per request (network latency)

My tool: 50ms (local processing)

Improvement: 40-60x faster

2. Privacy

SaaS tools: Your data goes to their servers

My tools: Everything stays local

Improvement: 100% private

3. Reliability

SaaS: Depends on uptime, API availability

My tools: Works offline, no dependencies

Improvement: 99.9% → 100% uptime

4. Customization

SaaS: Limited to predefined features

My tools: Can modify for any use case

Improvement: Unlimited flexibility

How to Get Started

Option 1: Use My Tools (Free)

All tools are open source on GitHub:

git clone https://github.com/devdattareddy/[tool-name]
python [tool].py --help
Enter fullscreen mode Exit fullscreen mode

Option 2: Build Your Own

Identify your highest SaaS costs:

  1. What service do you pay for monthly?
  2. Could you code it in a weekend?
  3. Build it. Save thousands.

Tools worth building:

  • CSV converters ($5-10/mo)
  • Image processors ($10-15/mo)
  • Data validators ($15-29/mo)
  • Format converters (any format)
  • Batch processors

My Workflow Now

Before:

  1. Get minified API response
  2. Copy to online formatter (wait)
  3. Manual analysis
  4. Export data
  5. Use email validator service
  6. Write SQL code, test, debug
  7. Repeat 5-10 times per day

Time: 15-20 minutes per workflow

Cost: $59/month

After:

  1. Get API response
  2. Run json_formatter.py (instant)
  3. Auto-analyze with --stats
  4. Export in any format (minified, pretty, sorted)
  5. Run email_validator.py on list
  6. Run sql_builder.py to generate query
  7. Repeat at scale

Time: 2-3 minutes per workflow

Cost: $0/month

Productivity gain: 10x faster. Cost reduction: 100%.

The Best Part

I didn't just save $708. I created reusable tools:

  1. Use them personally (done)
  2. Share with team (free)
  3. Sell premium versions (Gumroad)
  4. Monetize as open source ($100-500/month potential)

The Money

I'm now selling:

  • JSON Formatter Pro on Gumroad ($9.99) — GUI + batch processing
  • Markdown to HTML Pro on Gumroad ($12.99) — themes + templates
  • Email Validator Pro on Gumroad ($14.99) — API + scheduling
  • SQL Builder Pro on Gumroad ($19.99) — visual builder + export

Free version drives traffic. Premium version generates revenue.

Estimated: $100-500/month in sales + affiliate income from Dev.to articles.

Lessons Learned

1. Not Everything Needs to Be Perfect

Your 80/20 tool beats perfect SaaS 100% of the time if it's local.

2. Start Simple

MVP: One command, one feature. Expand later.

3. Solve Your Own Problems First

Build what you need. Others need it too.

4. Share It

Open source costs nothing. Attracts users. Creates opportunities.

5. Monetize Sustainably

Free version for users. Premium for power users. Articles for passive income.

Next: What I'm Building

Now that I have 4 core tools, I'm building:

  • Image Batch Processor (resize, convert, compress)
  • CSV to JSON Converter (data transformation)
  • REST API Generator (mock APIs for testing)

Estimated combined savings: $1,500+/year

Your Turn

What SaaS do you pay for? Could you build it? It's easier than you think.

I spent 5 hours and saved $708. You could do the same.

Support

If this approach resonates:

💝 Buy Me a Coffee - Help me build more tools

⭐ Star on GitHub - Get all tools for free

How much are you paying for tools that you could build yourself? Let me know in the comments!

Top comments (0)