The $20/Month Solo Creator Stack: Building and Selling Technical Ebooks with Python and AI

I have one paid tool in my entire publishing stack. Everything else is free. Here is the honest accounting.

The Full Stack

Tool	Purpose	Cost
Claude Code Pro	Writing, editing, code generation, pipeline automation	$20/month
Gumroad	Direct sales, payments, delivery	Free (10% fee per sale)
KDP (Kindle Direct Publishing)	Amazon distribution	Free (royalty split)
Canva	Cover design	Free tier
NotebookLM	Research, source synthesis	Free
ConvertKit	Email list (up to 1,000 subscribers)	Free tier

The $20/month goes to Claude Code Pro. That is the only subscription. Everything else is either free at the usage levels a solo creator needs, or it is fee-on-revenue — meaning you only pay when you earn.

This matters because fee-on-revenue tools do not create a fixed cost problem. If a book sells nothing in a month, the only cash out is $20.

The Financial Model

Two pricing tiers, two different distribution strategies:

Gumroad — $19.99 list price

• Gumroad takes 10%: $2.00
• Net per sale: $17.99
• Audience: engineers who find you through search, social, or email

KDP — $9.99 list price

• Amazon takes ~30% for digital delivery: ~$3.00
• Net per sale: ~$6.99
• Audience: Amazon shoppers browsing by topic

Break-even

With $20/month in fixed costs, the math is simple:

• Gumroad only: 2 sales × $17.99 = $35.98 → covered
• KDP only: 3 sales × $6.99 = $20.97 → covered
• Mixed: 1 Gumroad + 1 KDP = $17.99 + $6.99 = $24.98 → covered

Two sales per month is the floor. Everything above that is margin.

Python Break-Even Calculator

Rather than doing this in a spreadsheet, here is a script that calculates break-even dynamically for any pricing configuration:

from dataclasses import dataclass
from math import ceil

@dataclass
class Channel:
    name: str
    list_price: float
    platform_fee_pct: float  # as a decimal, e.g. 0.10 for 10%

    @property
    def net_per_sale(self) -> float:
        return self.list_price * (1 - self.platform_fee_pct)


def break_even(
    fixed_monthly_cost: float,
    channels: list[Channel],
    weights: list[float],  # expected fraction of sales per channel, must sum to 1.0
) -> dict:
    """
    Calculate how many total sales per month are needed to cover fixed costs,
    given a mix of channels with different net revenue per sale.

    Example:
        channels = [gumroad, kdp]
        weights  = [0.6, 0.4]   # 60% of sales via Gumroad, 40% via KDP
    """
    assert abs(sum(weights) - 1.0) < 1e-6, "Weights must sum to 1.0"
    assert len(channels) == len(weights)

    # weighted average net revenue per sale across channels
    avg_net = sum(c.net_per_sale * w for c, w in zip(channels, weights))

    raw = fixed_monthly_cost / avg_net
    sales_needed = ceil(raw)

    return {
        "avg_net_per_sale": round(avg_net, 2),
        "raw_break_even": round(raw, 2),
        "sales_needed": sales_needed,
        "breakdown": [
            {
                "channel": c.name,
                "net_per_sale": round(c.net_per_sale, 2),
                "weight": w,
                "sales_share": ceil(sales_needed * w),
            }
            for c, w in zip(channels, weights)
        ],
    }


if __name__ == "__main__":
    gumroad = Channel("Gumroad", list_price=19.99, platform_fee_pct=0.10)
    kdp = Channel("KDP", list_price=9.99, platform_fee_pct=0.30)

    result = break_even(
        fixed_monthly_cost=20.00,
        channels=[gumroad, kdp],
        weights=[0.6, 0.4],
    )

    print(f"Weighted avg net/sale: ${result['avg_net_per_sale']}")
    print(f"Break-even: {result['sales_needed']} sales/month")
    print()
    for row in result["breakdown"]:
        print(
            f"  {row['channel']}: ${row['net_per_sale']}/sale "
            f"({int(row['weight']*100)}% of sales → "
            f"~{row['sales_share']} sales needed)"
        )

Running this with the default values:

Weighted avg net/sale: $13.59
Break-even: 2 sales/month
  Gumroad: $17.99/sale (60% of sales → ~2 sales needed)
  KDP: $6.99/sale (40% of sales → ~1 sale needed)

You can adjust weights to model different scenarios — a book that gets heavy Amazon traffic versus one that sells primarily through direct email.

Time Investment Per Book

I track active hours per project. A technical ebook (8,000–15,000 words, with code examples) takes:

• Research and outline: 1–1.5 hours (NotebookLM for source synthesis, Claude for structure)
• Writing and code: 2–3 hours (Claude Code handles boilerplate; I review and direct)
• Cover design: 30 minutes (Canva template, swap text and colors)
• Formatting and upload: 30–45 minutes (Pandoc pipeline, KDP upload, Gumroad listing)

Total active time: 4–6 hours per book.

This is not passive time — it is focused work. But it is a weekend afternoon, not a month-long project.

Revenue Projections

These numbers assume modest, realistic sales — not a viral launch:

Single book

Period	Sales/month	Gumroad net	Annual
Conservative	4	$71.96	$863
Moderate	6	$107.94	$1,295

A single book earning at the conservative end, after costs, puts roughly $827/year in your pocket. Not life-changing, but it is compounding: the book keeps selling while you write the next one.

20-book catalog

Assuming each book averages 4 sales/month across both channels with a 60/40 Gumroad/KDP split:

Per book monthly net: ~$52 (blended across channels)
20 books × $52 = $1,040/month gross
Less $20 fixed cost = $1,020/month net
Annual: ~$12,240

The practical monthly figure, accounting for variance and slower months, lands around $1,079/month. That is a meaningful secondary income on a catalog you built in 80–120 hours of actual work spread across a year.

What Makes This Model Work

The key is treating each book as a durable asset rather than a one-time effort. Technical content in stable domains — Python, APIs, database design, deployment patterns — stays relevant for 2–3 years without significant updates.

The pipeline automation (Pandoc build, QA checks, metadata validation) means the marginal cost of publishing book two through twenty drops to nearly zero in setup time. You are reusing the same tooling, the same distribution accounts, the same email list.

The $20/month is not a cost. It is rent on the infrastructure that makes this possible at solo-creator speed.

---

The full pipeline — including the translation layer, EPUB build system, QA checks, and Gumroad/KDP upload automation — is documented in a practical guide at https://germy5.gumroad.com/l/xhxkzz for $19.99, with a 30-day refund if it does not deliver value.