The Week My Builds Started Compounding

How to stop starting from zero: the question to ask before you build anything, and why your first attempt always costs a day.

I set out to move some images off a server I was renting and finished the week with five working things I hadn’t planned. The move itself was dull: four small pieces of code over a weekend, then a day of shifting files. What changed is that everything afterwards started from what was already there, so a job that would have taken a week in January took an evening in March. Here’s what made the difference, and the question that reproduces it.

💡 The principle: most work feels slow because you rebuild the same foundation every time. Ask what already exists before you start, and the tenth thing you make costs a fraction of the first.

I upgraded to Cloudflare’s Workers Paid plan — five dollars a month. That covers Workers, which run small pieces of code, and KV, which remembers small values like “has this person paid”.

Two of the four things I used aren’t in that five dollars, and the number is the whole hook so it’s worth being precise. R2, which stores files, and D1, a database, are billed on what you use — but both have a free allowance underneath. R2 gives you 10GB of storage a month before charging anything, and everything I moved came to 220MB. My bill really was five dollars, then, but not because the plan covered everything: because one person’s projects sit well inside allowances built for companies.

But the five dollars is not what made the week work, and I’d be misleading you if I left it there.

The commands I didn’t have to learn

Cloudflare ships a command-line tool called wrangler. A command-line tool is a program you drive by typing instructions instead of clicking around a website — which matters here because it means an assistant can drive it too. Anything I’d otherwise do by hand in a browser, mine does by issuing the same typed commands.

One prerequisite decides whether any of this applies to you. It needs an assistant that runs programs on your own computer — Claude Code, Codex and Cursor all do. An assistant in a browser tab can tell you what to type but can’t type it, so if that’s your setup, read on for what to go and get rather than what to do this afternoon.

With that in place, the platform stops being a set of dashboards and becomes a set of instructions:

wrangler r2 bucket create my-images   # a place to keep files
wrangler d1 create my-database        # a database
wrangler kv namespace create SESSIONS # a place for small values
wrangler deploy                       # put it live on the internet
wrangler tail                         # watch what it's doing, live

I typed almost none of those. I said what I wanted; the assistant worked out which pieces it needed and ran them. You don’t have to be able to write those lines — you have to know that they exist, so you know the job is a five-second instruction rather than an afternoon of clicking.

One distinction underneath all of this carried the whole week. I need to know what these things are — R2 holds files, D1 is a database, KV remembers small values — because that’s the vocabulary I think in when deciding what to build. I do not need to know how they get wired together. Each one has to be told which specific store the code is allowed to touch, a connection called a binding that lives in a settings file beside the code. Bindings are fiddly, easy to mistype, and completely uninteresting. They are exactly what an assistant does perfectly and I do badly at eleven at night.

Worth knowing where wrangler stops. Workers, R2, D1, KV and putting sites live are all wrangler commands. Domain names are not. Pointing a web address at what you’ve built, or checking whether a name is free to buy, happens through Cloudflare’s website instead. I keep my domains there too, so the chain from “is this name available” to “the site is live on it” stays in one account — but it’s two mechanisms wearing one logo, and there is no wrangler dns command to go looking for.

The upgrade bought me the account. The command line is what let me spend the week building instead of clicking.

Saturday and Sunday. Four small pieces, about an hour each: somewhere to serve images from, a contact form handler, a health monitor, a link shortener. None of them impressive on its own, but each taught me the deployment routine for the next, and by the fourth I was pointing at the last one and saying same shape, different purpose.

Monday. Moved the images for six of my sites across. The first site took most of the day — rewriting paths, cache settings, a deployment tool that behaved differently from its documentation. Sites two to six were mechanical, because by then the route was known. The total came down from 519MB to 220MB, mostly by converting and compressing on the way through.

The evening it cost nothing

Monday night I turned a document I’d already written into a working paid course in a single session — sign-in, checking who’d bought it, interactive pages, branded email.

It added nothing to the monthly bill. Every piece it needed was already running from the weekend: the file storage held the content, the database held who had access, the small code pieces ran the logic. I’d been paying for all of it since Saturday.

Up to that point I’d been moving images. After it, I was building on something I’d accidentally assembled.

Tuesday. Seventy-five minutes to expand that course into a hub with several products and proper accounts, short because the sign-in, the email templates and the deployment were all inherited from Monday.

Wednesday. I realised the thing I’d built was something I could build for other people, so I scoped it, priced it, wrote a sales page and put it live in under an hour. The site, the design and the image hosting already existed, so the whole hour went on the words.

What “infrastructure” actually means here

A project is a thing you finish. You build it, you ship it, it sits there. The next project starts at zero.

Infrastructure is what the next project lands on, and it needn’t be technical. A folder structure you always use. A document template. A supplier already set up. The test is whether finishing leaves anything behind that makes the next job shorter. If nothing is, you built a project.

Nothing got cleverer between Saturday and Wednesday. Each session just started further along.

Why your tenth attempt should be easier than your first

Everything above happened to involve cloud hosting, but the shape belongs to any work you do more than once. The report rebuilt from scratch every quarter. The client onboarding reassembled from memory. The presentation where you rehunt the same five statistics. Each felt fine on the day, and none left anything behind, so the tenth costs what the first one cost.

It keeps happening because the foundation is invisible while you’re standing on it. Laying it feels like a detour, and only looks obvious once you’ve paid for the same groundwork four times.

How to run this yourself

1. Before your next piece of work, write down what you already have — no tools needed. Templates, accounts, documents, subscriptions you’re paying for. Ten minutes on paper is enough, and most people are surprised by how long the list runs.

2. Ask what the new thing can sit on. Give your assistant the job and the list, and ask which existing pieces it can build on rather than replacing. Make it name them specifically.

3. When you do the same thing a second time, write the route down where the work lives. Not in a notes app you’ll forget — in the folder, next to the thing. The steps, and the parts that cost you time.

4. Ask what it costs to add. If the answer is nothing, lower your bar for what’s worth trying. Of everything on this list, this is the question that actually changes how you behave.

5. Make it standing, so you stop having to remember any of this.

Sample prompts

Before starting anything new:

Before you write anything, tell me what I already have
that this could be built on, and name each one
specifically. If there's genuinely nothing, say so.

Make it standing, once — paste this into your assistant’s instruction file:

When building something new:
- First, list what already exists that this can land on.
  Name the specific service, file or account. If nothing
  does, say so.
- If this is the second instance of something, reuse the
  first one's pattern instead of designing it again.
- Once the first instance works, write the pattern down
  where the work lives: the steps, the awkward bits.
- Tell me what this adds to the monthly cost. If it's
  nothing, say so.
- If we stop mid-build, leave a note saying exactly
  where to pick up.

The rung that will cost you time is the first instance, every time. Monday took a whole day for one site, and you’ll hit the same wall: the first one surfaces every awkwardness in the process at once, which feels like evidence that the whole approach is wrong. The cause is boring rather than hard — you’re paying a one-off charge for finding out where everything is. Budget a full day, expect to feel stupid around hour four, and judge the idea on instance two. Sites two to six took a fraction of the time.

The third rule in that block is the one that turns a good week into something permanent. A route that exists only in the session that discovered it dies with that session. The last one is the fix for the fragility below: you can’t always work on consecutive days, but you can make picking it back up cheap.

Where to stop

Don’t build the foundation speculatively. Everything above came out of a job I actually needed doing. Infrastructure built for a future you’re guessing at is just a project with extra steps, and it’s the most expensive mistake in this whole approach.

The momentum is fragile, and that part you can’t schedule. I was housebound that week and working in short bursts, which meant the sessions were consecutive. Take three days off in the middle and you spend the next one reloading context instead of building forward.

A lower bar is not no bar. Once things cost nothing to add, the question stops being “is this worth building?” and becomes “is this worth the afternoon?” That’s freeing, and it will also let you build five things nobody asked for. Deciding what deserves the afternoon stays your job.

By Wednesday evening there was image hosting, four small pieces of code, a paid course, a multi-product hub and a service with a live page. All of it out of a week that started with “I should move those images.”