The first chapter of I Built an App. Now What?

Chapter 0.1 — The Magic, and the Bill

What just happened to you, why it felt so easy, and the part of the story the tools politely forgot to mention.

The first time I built something real with AI, I laughed out loud. Alone, at my desk, like a slightly unhinged person.

I’d typed a few sentences describing a thing I wanted — and the thing appeared. Working. On my screen. Buttons I could click, a layout that did what I’d pictured in my head ten minutes earlier. I’d spent years working in tech and had still never built real software of my own — and here it was: my software, running. So I described another piece. It appeared too. I felt like I’d been handed a cheat code for reality.

You know this feeling. It’s almost certainly why you’re holding this book. You had your own version of that moment — in Lovable, or Bolt, or Google AI Studio, or Cursor, or wherever you started — where you described an app and it just… was. For a little while, you were a wizard.

I’m not going to take that feeling away from you. It’s real, and it’s earned, and it genuinely is one of the most extraordinary things to happen to ordinary people in a generation. Building software used to take years of training, or a team and a budget. Now it can start with a sentence.

But I am going to tell you the part nobody printed on the box.

Anyone can build an app now. Almost nobody tells you what happens next.

What you’ve been doing has a name

People call it vibe coding: you describe what you want in plain language, the AI writes the code, you nudge it — “make that blue, move it left, add a button here” — and you ride the vibe. It’s a wonderful way to start. It got you a working prototype faster than you’d have believed possible a couple of years ago.

Here’s the trap hiding inside the magic, and I’m going to say it plainly, because it’s the entire reason this book exists:

The tools make the first 80% of building an app feel free. You describe, it appears, you’re flying. And then — right around the moment you start to believe you’ve gotten away with it — the last 20% quietly hands you the bill.

The bill arrives as questions. A flood of them, all at once, none of which you know how to answer. Firebase or Supabase? SQL or NoSQL — and what do those words even mean? Where does this thing actually live when I want other people to use it? What’s a domain, and why is “DNS” suddenly my problem? Wait — is my app safe? Is anyone’s data safe? What’s an IDE, and why do I need one just to edit my own code? The app that loaded instantly last week now barely loads at all. Every new feature breaks an old one. And the AI that felt like a genie three days ago is now confidently walking you in circles.

That is not you failing. That is the bill. Everyone who builds with AI gets handed the exact same one. The difference between the people who ship a real product and the people who quietly abandon a folder full of half-broken magic is not talent, and it’s not how cleverly they can prompt. It’s whether someone showed them what was in that last 20% — before it ambushed them.

This book is that someone.

What this is (and what it isn’t)

A quick, honest word on what you’re reading. This is not a coding course. I’m not going to teach you to become a software engineer — you don’t need to become one, and, full disclosure, I’m not one either. Here’s where I’m actually coming from: I’ve spent years working in and around tech, so a fair amount of what’s in this book — what a database is, why security isn’t optional — I’d met before, as concepts. What I hadn’t met was the gap between understanding a concept in the abstract and actually shipping it, by yourself, in something real that strangers will trust with their data. That gap is the whole subject of this book. It’s a field guide to the 20%: the decisions, the setup, the safety, the going-live — everything standing between “it works on my screen” and “it works, safely, for strangers on the internet.”

It rests on three promises:

It’s decision-first. When you hit a fork — and you’ll hit many — I won’t bury you in fifty tutorials. I’ll show you your options, how to choose between them, and the shortest safe path through.
It’s AI-native. You already have an AI that can do the actual work. So for each step, I’ll hand you the exact words to make it do that step correctly — and warn you about what AI tends to quietly get wrong.
It’s honest. I’ll show you my own faceplants, name the costs out loud, and treat “it works and I have no idea why” as the enemy it is, instead of pretending everything’s fine.

How to read this

You can read this front to back. It’s built as a journey, in roughly the order the questions actually hit you — from the moment your browser tool stops being enough, all the way to launch day. The first time through, that’s the way I’d do it.

But you might not be reading this calmly. You might be reading it because something is on fire right now. If so, jump:

Your app got heavy and breaks every time you add a feature, and someone said “you need to go local”? → Parts 1 and 2.
Staring at the word deploy with no idea what it means? → Part 8.
Lying awake wondering whether your app — or your users’ data — is wide open? → Part 6. (There’s a real chance it is. We’ll fix it.)
Drowning in “what’s an IDE, a terminal, a repo, and why do I need them”? → Part 3.

Come back for the rest once the fire’s out. The book will wait.

One last thing before we start

I didn’t build my apps because I wanted to be a programmer. I built them because I needed them to exist — small tools to take some overwhelming corner of life and make it manageable. To make a helper. I suspect that if you dig under your own app idea, you’ll find the same thing: you weren’t trying to become a developer, you were trying to solve something that was weighing on you.

That’s what this book is, too: a helper — for the people building the helpers. You already did the brave part. You built the thing.

Now let’s make it real. First, let’s make sure this book is actually for you.