← Back to Blog Posts

The Benefit of Being Poor

The Benefit of Being Poor

I've always had to scrape by, so I picked my tools by what they'd cost me once I stopped paying attention. The ones I kept turned out to be the ones that scale: Git, open languages, Linux, Cloudflare, my own GPUs. Here's the timeline from my own files, the arithmetic behind the prices, the times…

Byline note: Claude Sonnet 5.5 drafted this post from my repositories, backups and docs. Claude Fable 5.2 fact-checked it before it went up. It re-read the prices, re-counted the commits and rewrote the two claims that failed the check. It also did the last pass on the wording.

I've always had to scrape by. For about twenty years that has decided one thing for me more than anything else. Before I pick up a tool, I ask what it will cost me on the day I stop watching it.

That one question sorts tools pretty well. A flat monthly fee fails it. So does a price per seat, and so does a free trial that runs out. What passes is a tool that starts at zero, charges for what I use, keeps my data in a format I can take with me, and has something open source underneath that I can fall back on.

It took me years to notice that the tools that passed were also the ones that scale. I don't think that's luck. If a price follows what you use, it doesn't punish you for growing. Being poor didn't make me smarter. It just made me read the pricing page first, and it turns out the pricing page tells you a lot about how a thing is built.

The short version: going by Cloudflare's published prices, a site on Workers and D1 costs $5 a month at a million page views and about $1,351 at a billion, if each view writes one row to the database. If each view writes eight rows, that same billion costs $8,351. How often you write to the database matters more than how much traffic you get.

The rest of this post is where that comes from: my own repositories, backups and docs. I've also put in the times the cheap choice cost me, because I learned the most from those. I haven't had a million users on any of this, and I'll say where that matters.

What my files say

The dates below come from my own files, so I can prove them. I mostly can't prove the reasons, and I'm not going to pretend I remember old invoices.

  • 2005–2007. I was blogging at 22 on a free WordPress.com blog. I was running Windows Vista RC1 on a Compaq laptop that I'd upgraded to 638 MB of memory. My 2006 wish list for a new computer named Pricewatch and TigerDirect as the places to buy parts, and it asked for a floppy drive "if possible." I wrote about that in The Blog I Forgot.
  • 2009. I opened my GitHub account. It turned 17 this April.
  • 2012–2016. My earliest public repositories are small stuff: a Sublime Text plugin (Python, 2012), a bitcoin calculator and a time tracker (JavaScript, 2013 and 2014), a LED strip test in C (a fork), then Ruby in 2015 and 2016. A lot of them are forks.
  • 2018. A fork of a Go node for a blockchain project.
  • 2019–2023. Vue, then Nuxt 3 with Tailwind, for a long run of small sites. My old Windows profile on an external drive still has an .azure folder from January 2022, an .aws folder from March 2023 and a DigitalOcean command-line download from October 2023. One site repo has an AWS Amplify folder in it. So yes, I tried the big clouds, and I ditched them. I have a lot of small projects that aren't really built to make money. I don't want to worry about them going down, or about my bills bloating while I'm not looking.
  • 2023–2024. Deno Fresh, with Deno KV and Deno Deploy. The README in that same repository already lists Cloudflare AI Gateway and Workers AI.
  • March 2024. The first wrangler config in any repository on this machine. It's Reddisco, a small SvelteKit tool for advertising a Discord server on Reddit, on Cloudflare Pages. Cloudflare has been my default ever since.
  • October 2025. The first config for the bigger apps, on Workers with D1.
  • 12 May 2026. I installed Arch Linux with Omarchy on this machine. The first line of the install log has that date on it. Before that I was on Windows 10, and that profile is backed up on an external drive.
  • 7 September 2026. I scored nine stacks against each other for my own work, on sixteen weighted dimensions. SvelteKit got 8.1, Next.js 7.6 and Rust 7.5. First and second were only 0.52 apart. I wrote that down, because it shows how little it would take to change the answer.

That's a lot of tools. Most of them I tried because they were free.

What Cloudflare costs when you read the price page

I read Cloudflare's pricing and limits pages on 19 November 2026. These are the numbers that matter.

  • Workers Free: 100,000 requests a day, 10 ms of CPU per request.
  • Workers Paid: a $5 monthly minimum per account. It includes 10 million requests and 30 million CPU-milliseconds a month, then $0.30 per extra million requests and $0.02 per extra million CPU-milliseconds.
  • Egress: Cloudflare says there are no charges for data transfer or throughput on Workers. R2 has free egress as well.
  • Static assets: requests for them are free and unlimited.
  • D1: the Free plan allows 100,000 rows written and 5 million rows read per day, with 10 databases of up to 500 MB each and 5 GB in total. Paid raises the cap to 10 GB per database and includes 50 million rows written and 25 billion rows read a month, then $1.00 per million writes. D1 doesn't bill for compute when nothing is running.
  • R2: 10 GB of storage free each month, with 1 million write operations and 10 million read operations, and $0.015 per GB-month after that.

I have 40 wrangler configs in my projects folder. Some are templates with placeholder IDs, so they aren't all live apps. On 5 November I audited the apps behind them. My main account is on Workers Paid. The AgapeVerse site runs on the free plan.

The part I like best is how small my databases are. On the day of the audit the biggest was a 1.2 GB log database for my Discord bot, which is 12% of D1's 10 GB cap. The next biggest was 267 MB. Everything else was a few megabytes at most. Most of what I run is smaller than a photo on your phone.

The same site at four sizes

A price list is hard to picture, so here's a worked example. It's the monthly bill for one site on Workers and D1, at the prices above. I assumed 5 ms of CPU and 3 database reads per page view. I left out KV, R2, Durable Objects and your domain, so treat these numbers as a floor.

Page views a month 1 database write per view 8 database writes per view
1 million $5.00 $5.00
10 million $5.40 $35.40
100 million $91.40 $791.40
1 billion $1,351.40 $8,351.40

If you want to check my arithmetic, or try your own numbers, this is all of it:

def bill(views, writes_per_view, cpu_ms=5, reads_per_view=3):
    requests = max(0, views - 10e6) / 1e6 * 0.30               # Workers requests
    cpu      = max(0, views * cpu_ms - 30e6) / 1e6 * 0.02      # Workers CPU time
    writes   = max(0, views * writes_per_view - 50e6) / 1e6 * 1.00   # D1 rows written
    reads    = max(0, views * reads_per_view - 25e9) / 1e6 * 0.001   # D1 rows read
    return 5 + requests + cpu + writes + reads                 # $5 monthly minimum

for views in (1e6, 10e6, 100e6, 1e9):
    print(f"{views:>13,.0f}  ${bill(views, 1):>9,.2f}  ${bill(views, 8):>9,.2f}")

I ran it, and it prints the numbers in the table. There's no cliff anywhere. The bill starts at $5 and goes up by a small rate per million. But look at the right-hand column. Writes are most of the bill there, and how many writes a page view makes is something I decide in one file.

I know that column well, because I've been in it. The 5 November audit found the page-view counter on several of my sites writing 7 to 9 D1 rows per view. On the free plan that caps a site at about 12,000 views a day. The fix is to hold the counts in memory and write them in one batch, or to move them to Workers Analytics Engine. This is the benefit the title is about. A free tier is a load test you didn't ask for. It breaks while you're small, when the fix is cheap, and it shows you what would have cost real money to find out later.

The times the cheap choice bit me

I wouldn't trust a post that says "free tiers are great" and has no failures in it. So here are mine. All of them happened.

A retry loop ate a day's queue budget. On 23 July a requeue loop in my Discord bot's watchdog used up the whole Cloudflare Queues free allowance, which is 10,000 operations a day. The only warning was an email from Cloudflare that sat unread in my Gmail. Separately, my personal account was sitting at 10 of 10 D1 databases, which is the free-plan limit, and creating one more failed with error code 7406. I couldn't see either limit from my own machine. So I wrote a quota watcher. It reads each account's usage and knows which plan the account is on. If it's only guessing at a limit, it raises a warning and not an alarm.

My quota monitor lied to me. The 5 November audit found that same watcher reporting OK on data it never got. Every count was null, because the API token didn't have the scope to read usage. A check that can't see anything and still says "fine" is worse than no check at all.

A free endpoint died, and nothing told me for three weeks. I'd moved some classification jobs off Claude and onto a free model endpoint from NVIDIA. In mid-September the model I'd picked started returning 410 Gone. Every job logged "nvidia not used (HTTP 410), judged on claude" and carried on working, which is exactly what the fallback was built to do. So nobody noticed until a self-check found it on 8 October. I already knew free endpoints can vanish. What I learned is that a fallback that works looks just like the main path working, unless you count how often the fallback fires.

KV is not a counter. The audit also found several places where I'd used Workers KV for counters, login throttles and limits. KV lets you write to the same key once a second, and a change can take 60 seconds or more to show up in other locations. It's great for config and cache. It's a bad place for a number that has to be exact.

Where it paid off

Git and text files as the source of truth. Everything I own is in a repository: site code, blog drafts, configuration, all of it. That takes a free GitHub account and one rule, which is that nothing important lives only in a web dashboard. It costs me nothing. I also built an encrypted backup to an R2 bucket, next to the iCloud copy. I capped it at 9 GB in code so it stays under R2's 10 GB free allowance.

Open source layers under the paid ones. SvelteKit, Vite, TypeScript and Bun are all open source. D1 behaves like SQLite, and Postgres is my escape hatch. So I can lift my work off any one vendor. I do use Cloudflare-only things too, like D1, KV and Durable Objects, and those don't move. Getting out would mean rewriting the storage layer, not changing a config file. I wrote that down in my architecture doc so I'm not just hoping.

One CMS for many sites. This site is a fork of NebulaKit, a CMS I keep as the canonical version. The next site costs me close to nothing: one new D1 database and one new Worker. The free plan stops at 10 databases, and I've hit that. Paid includes 100,000. That's what you get from a platform that doesn't charge per site.

My own GPUs. I have two consumer RTX 3060 cards with 12 GB each. One runs my displays. The other does the compute: speech-to-text at about 1.9 GB, local language models through Ollama, and the forecasting model behind the member chart in my svjeez post, which peaks around 1 GiB. If a job runs every day, a card I own beats a metered API pretty quickly. If it runs once a month, the API wins, and I use the API.

A subscription instead of per-token billing. I use Claude Code on a subscription, not API credits. I measured the most expensive tier once. Four calls cost $6.26 at API prices. A two-token question comes out around $0.25, because about 27,000 cached tokens ride along on every call. After I saw those numbers I wrote myself a rule on 18 July: work on the cheaper Sonnet model, and only move up on purpose.

My commit log shows how well I've stuck to it. As of 19 November, the repositories on this machine hold 9,383 commits under my name for 2026. All of 2025 has 467. I counted each commit once, because my forks share history. Two thirds of the 2026 ones (6,244) carry a Claude co-author trailer, and the trailer names the model. Since I wrote the rule, 66% of those name Opus, 20% name Sonnet and 13% name Fable, which is the tier I measured. Sonnet's share was 1% in September and it's 47% so far in November. So the rule is working, slowly. The jump in commits isn't me typing faster. It says more about the tool than it does about me.

Does it scale?

I can't tell you this scales to any size. I haven't had a million users on any of it, and I'm not going to claim something I haven't measured.

What I can say is this. Workers charge by the million requests, static assets are free, and there's no cliff anywhere on that curve. I've also written down what would break first. It's in my architecture doc, in the order I expect it to break: too many writes per page view, KV used for exact numbers, logs that never get pruned, and D1's 10 GB limit per database. For that last one, my plan is a SQLite-backed Durable Object per customer. Each customer gets their own 10 GB and strong consistency, and there's no fixed cap on how many customers you can have. I've designed that. I haven't run it at scale.

So my claim is a smaller one. If you pick your stack by cost first, you get a bill that grows smoothly and a pile of limits you can find before they find you. I still have to prove the rest at scale.

What being poor didn't buy

It cost me time. Learning Vue, then Nuxt, then Deno, then Svelte, plus a few clouds, is a lot of reading, and I don't use most of it any more. It cost me comfort too. I've shipped things that would have been simpler with a bigger budget.

And being poor isn't a virtue. Plenty of people scrape by and end up with tools that trap them, so I don't think my path is a recipe. The part I think anyone can copy is the question. You don't have to be poor to ask it. You just need a spreadsheet that prices the hundred-times case before you pick.

If you want the benefit without the hard part

  1. Price the 100x case before you pick a tool. Price the success, not the demo.
  2. Pick a free floor and a usage price over a flat fee, and check that egress is free.
  3. Count your writes per request. Reads are cheap, and writes set the bill.
  4. Watch the free-tier limits with something that fails loudly. Then test that it can actually see.
  5. Keep your data in SQL and your files in an S3-style bucket, so leaving is a migration.
  6. Make every fallback report how often it fires.
  7. Buy a GPU if you'd run it every day. Rent one if you wouldn't.
  8. Keep everything that matters in Git.

I read these prices on Cloudflare's pages on 19 November 2026. They change, so check them before you build on any one number.

The end

Linked from elsewhere

© 2026 davis9001.dev | All rights reserved.