You've been here before. You just didn't have a map.
You've done this enough times to know the pattern exists.
The surge of excitement. The quiet middle where everything gets hard. The weird guilt of abandoning something you cared about. The random Tuesday six months later when you open it again for no reason.
Every side project follows the same emotional arc. Not the same technical arc — the emotional one. The feelings arrive in the same order, at roughly the same intervals, with the same intensity, regardless of what you're building or how experienced you are.
The developers who finish things aren't the ones who escape this cycle. They're the ones who've mapped it. Who know which phase they're in. Who recognise the feeling that's trying to make them quit and call it by its name instead of listening to it.
This is that map.
Phase 1: The Spark ⚡
What it feels like: Electricity. Clarity. The specific euphoria of an idea that feels genuinely new.
You're in the shower. On a walk. Half asleep. And then — there it is. A problem you've had that nobody's solved properly. A tool you wish existed. A thing you could build that would be genuinely useful, genuinely interesting, genuinely yours.
The idea arrives fully formed in a way that never survives contact with reality but feels completely real in the moment. You can see the landing page. You can see the UI. You can see people using it. You open Notes and type three paragraphs in a row without stopping.
For a few hours — sometimes days — the idea is perfect. Untouched by execution. Unspoiled by the actual work of building it.
This phase is intoxicating and completely unreliable as a signal of anything. Every project that got abandoned started here. Every project that changed someone's life also started here.
The spark doesn't tell you which one this is.
The lie this phase tells you: This one is different. This one is the one.
The truth: Maybe. Doesn't matter yet. Write it down and start.
Phase 2: The Setup High 🛠️
What it feels like: Momentum without resistance. Pure possibility.
You create the repo. You scaffold the project. You pick the stack — and honestly this decision takes longer than it should because you're also half-dreaming about what this could become.
Everything in this phase is easy because nothing is real yet. You're not solving the hard problem. You're arranging the tools you'll use to solve it. And arranging tools feels like progress because technically it is.
The README gets written. The folder structure gets decided. The color palette gets chosen. You might even make a Figma file. You're building the scaffolding around a building that doesn't exist yet, and it feels fantastic.
This phase can last hours or days depending on how good you are at starting and how afraid you are of the actual work. Some people have perfected the Setup High into an art form — they have thirty perfectly scaffolded repositories and zero finished products.
The Setup High is the side project equivalent of buying running shoes.
The lie this phase tells you: Starting is the hardest part.
The truth: Starting is the easiest part. By a significant margin.
Phase 3: Early Momentum 🚀
What it feels like: Confirmation. You're doing it. It's actually happening.
The first real features exist. The thing works, roughly. You can open it in a browser and see something that resembles the idea in your head. The gap between vision and reality is still enormous but it's no longer infinite.
You're coding fast. Things are clicking. Each session ends with something visibly different from where it started. You tell someone about it — a friend, a partner, a Discord — and saying it out loud makes it feel more real.
This is the phase where the GitHub contribution graph starts looking good. Where the commits are daily. Where working on the project feels less like effort and more like play.
Sleep suffers. That's how you know it's real.
This phase is deceptive because it creates a false baseline. The pace feels sustainable. It isn't. The easy parts of any project get built first, by definition. The rate of visible progress will slow. When it does, your brain will interpret the slowdown as a sign that something is wrong.
Nothing is wrong. The easy parts just ran out.
The lie this phase tells you: I could ship this in two weeks.
The truth: Multiply that estimate by four. Minimum.
Phase 4: The First Wall 🧱
What it feels like: Friction. Sudden, unexpected, demoralising friction.
You hit the thing you'd been quietly avoiding thinking about. The hard technical problem at the centre of the project. The feature that doesn't have a clean solution. The architecture decision you deferred because you didn't want to deal with it yet.
Progress slows dramatically. Sessions that used to produce visible results now produce invisible ones — refactoring, thinking, reading docs, abandoning approaches, trying again. The gap between where you are and where you want to be stops shrinking.
You spend an entire evening on something that should take an hour. You close the laptop feeling like you went backwards. You open it the next day and spend twenty minutes staring before writing a single line.
This is where most projects die. Not because the problem is unsolvable. Because the slowdown feels like failure. Because the feeling of momentum was so good and this feeling is so bad and your brain presents abandonment as relief.
The First Wall is not a sign that the project is flawed.
It's a sign that the project is real.
The lie this phase tells you: Maybe this idea wasn't as good as I thought.
The truth: The idea is exactly as good as you thought. You just reached the part that requires actual work.
Phase 5: The Trough 🕳️
What it feels like: Contempt. For the project, the code, the original idea, yourself.
You open the codebase and feel nothing but irritation. The early decisions you made look naive. The code that felt clean two weeks ago looks like a mess. The original concept — the thing that felt so obvious and right — suddenly seems embarrassing.
You look at other people's projects. Everything they ship looks better than what you're building. You go on Twitter and see someone announce a product that's adjacent to your idea and it's already further along than you are and better designed and you feel a specific cocktail of envy and deflation that is deeply unpleasant.
The Trough is where you seriously consider:
- Scrapping everything and starting over with a better architecture
- Pivoting the idea entirely
- Abandoning it and pretending it never happened
- Finishing it really quickly just to be done with it even though "done" would mean shipping something you're not proud of
None of these are the right move. All of them feel like the right move.
The Trough is a phase. Not a verdict.
Every single project you've ever admired — every product you've used and loved, every open source tool you've depended on, every portfolio piece that impressed you — passed through a Trough. The difference between the ones that made it out and the ones that didn't is almost never quality. It's almost always just someone deciding to keep going when keeping going felt pointless.
The lie this phase tells you: This is when I should quit.
The truth: This is exactly when you shouldn't. The Trough means you're close to something real.
Phase 6: The Quiet Rebuild 🔧
What it feels like: Resignation, then something quieter. Steadier.
You stop expecting sessions to feel exciting. You start treating the project like a job — not in a bad way, in a professional way. You show up. You do the work. You close the laptop without needing it to have felt good.
Something shifts in this phase. The emotional charge fades and in its place comes something more durable: commitment. You're not building because it's fun anymore. You're building because you said you would. Because the idea still matters even when the feeling is gone. Because finishing is a skill and you're practicing it.
The code gets cleaner in this phase, not because you have more energy but because you have more clarity. The decisions you agonised over in the Trough resolve themselves quietly. You know the codebase well enough now to move through it with confidence even without enthusiasm.
This is the phase that separates the developers who ship from the ones who don't. Because nothing about this phase feels like a highlight. There's no story to tell. No dramatic breakthrough. Just sessions of steady, unremarkable work that collectively build the thing.
Most of the best software in the world was built mostly in this phase.
The lie this phase tells you: If I'm not excited, something is wrong.
The truth: Excitement is a spark. Commitment is a furnace. You need both but only one of them keeps burning.
Phase 7: The Emergence 🌅
What it feels like: Surprise. The thing is actually becoming what you imagined.
You can't pinpoint when it happened. One session you were grinding through the Quiet Rebuild and then suddenly — the pieces are connecting. The features that existed in isolation are working together. You load it in the browser and for the first time it looks like software. Real software. The kind someone else might actually use.
The gap between what you imagined in Phase 1 and what exists now is still real. But for the first time it feels closeable. The end is visible from where you're standing.
Excitement comes back, quieter than before, more earned. You find yourself thinking about it during the day. Making notes. Seeing things you want to fix, things you want to add. The project has gravity again.
This phase is also when you start getting scared in a new way. Before you were scared it would never be good enough. Now you're scared of what happens when you actually share it.
The lie this phase tells you: I should keep polishing. It's not ready.
The truth: It will never feel ready. That's not what ready means.
Phase 8: The Pre-Ship Spiral 🌀
What it feels like: Productive procrastination disguised as perfectionism.
You're so close. Which means every remaining imperfection is now visible and intolerable. The mobile layout is slightly off. The loading state isn't quite right. The copy on the landing page doesn't feel tight enough. The README needs one more pass.
You tell yourself you're being professional. Thorough. That you have high standards. All of that is true and also completely irrelevant because what's actually happening is fear.
Fear that it won't land. That nobody will care. That the people who do see it will see the cracks you can see. That shipping means accountability and not shipping means you can still believe it could be great.
The Pre-Ship Spiral can last days. For some projects it lasts long enough that the project never ships. The developer keeps polishing a thing in private indefinitely, always one small fix away from ready, until eventually the moment passes and the project joins the graveyard.
The only move is to pick a date and treat it like a non-negotiable.
Not when it's perfect. When it's good enough to be useful. Those are different things and conflating them is the thing that kills more good projects than any technical problem ever could.
The lie this phase tells you: Just one more thing and then it'll be ready.
The truth: Ship it. Now. Today. The version that exists beats the perfect version that doesn't.
Phase 9: The Deploy 🚢
What it feels like: A strange calm. Then nothing. Then something.
You push to production. You share the link somewhere — Twitter, dev.to, a Discord, a subreddit, an email to three people. You close the tab immediately because you can't watch.
The next twenty minutes are a specific kind of suspended animation. You refresh things you've already refreshed. You make tea you don't drink. You check your phone for no reason.
And then someone sees it. Someone clicks it. Someone says something — anything — and the thing that was only in your head and then only on your laptop and then only on a domain nobody knew existed is suddenly, unmistakably, real.
The feeling isn't always joy. Sometimes it's relief. Sometimes it's anticlimactic. Sometimes you feel less than you expected and that's confusing.
But underneath all of it, quiet and steady, is something that doesn't go away:
I built this. It exists. Nobody can unship it.
The lie this phase tells you: The response will tell me if it was worth it.
The truth: It was already worth it. The response is just data.
Phase 10: The Aftermath 🌊
What it feels like: Everything, in waves.
Pride. Vulnerability. The sudden, sharp vision of every flaw now that other people can see it. Unexpected gratitude when a stranger says it helped them. The strange loneliness of a project that's out in the world and no longer entirely yours.
And eventually, quietly, an itch.
A thing you'd do differently. A feature that would make it better. A new problem the project revealed that you want to go solve.
The cycle doesn't end. It just starts again, smaller, more confident, with the knowledge that you've been through this before and you know where it goes.
That knowledge doesn't make it easier.
But it makes it survivable. And survivable, for a builder, is enough.
The Map Is Not the Territory
Reading this won't stop you from feeling every phase as if it's happening for the first time. Emotions don't care that you've mapped them. The Trough will still feel like a verdict. The Pre-Ship Spiral will still feel like thoroughness.
But somewhere in the middle of Phase 5, when your brain is presenting quitting as the only reasonable option — maybe you'll remember you've seen this before. That you know what phase this is. That the map says you're closer than you feel.
That's all a map is for.
Not to remove the terrain. Just to remind you that others have crossed it.
And that the other side exists.
Which phase are you in right now? Drop it in the comments — no context needed, just the phase number. Let's see where everyone is on the map. 👇
Follow for more honest writing about the craft and psychology of building things.