Nobody talks about the emotional side of shipping. Let's fix that.
There's a specific kind of silence that happens right after you deploy something real.
Not the silence of a bug you haven't found yet. Not the silence of waiting for the CI pipeline to clear. A different kind. The kind where you close your laptop, lean back, and just... sit with it.
If you've felt it, you know exactly what I mean.
If you haven't felt it yet, this article is for you.
It Doesn't Start With Excitement. It Starts With Dread.
Here's what nobody puts in their "I shipped a side project!" LinkedIn post:
The beginning is awful.
You open a blank index.html or a fresh one, and suddenly the weight of the idea feels crushing. You had a vision in your head. Fully formed. Beautiful. And then you look at a white screen with a blinking cursor, and the gap between what you imagined and what currently exists feels insurmountable.
This is the part people skip when they talk about building things. They show you the polished Figma mockup, the finished landing page, and the GitHub repo with 400 stars. They don't show you the three hours they spent just trying to decide on a folder structure.
The dread is real. The friction is real. And it's not a sign that you're doing it wrong — it's the price of entry for building something that actually matters to you.
The gap between your taste and your current ability is not a flaw in you. It's evidence that your taste is working.
This is a real thing. The people who never feel that gap are the people who don't have high standards for their own work.
The Middle: Where Most Things Go to Die
At some point in every project — usually around 40% of the way through — you will hate it.
Not mildly dislike it. Hate it. You'll look at what you've built and feel nothing but contempt. The colours feel wrong. The code feels messy. The whole concept suddenly seems embarrassing. You'll open Twitter, see someone ship something that looks better than yours, and quietly close your laptop.
This is the trough. Every creative person has a name for it:
- Writers call it the 'saggy middle'.
- Musicians call it 'demo-itis'.
- Filmmakers call it the 'rough cut that makes the director cry'.
For developers, it's the moment you seriously consider scrapping everything and starting over. Or worse — just abandoning the project entirely and telling yourself you'll "come back to it later".
You won't come back to it. We both know that.
The only way out of the trough is through it.
Not around it. Not by pivoting to a new idea. Not by starting fresh. Through. Keep pushing. Ship something. Iterate. The feeling on the other side is worth it in a way that's almost impossible to describe until you've experienced it.
The Moment the Thing Comes Alive
And then—if you survive the trough—something shifts.
It's usually small. An animation finally feels right. Two components click together in a way you didn't plan. You load it in the browser, and for the first time it looks like the thing you imagined at the beginning. Not exactly. Better.
This is the moment developers don't talk about enough. When the project stops being a problem you're solving and starts being a thing that exists in the world. When you catch yourself using your own app and forgetting that you built it.
I've spoken to dozens of developers about this moment, and the words they reach for are almost always the same:
"It felt real."
Not finished. Real. There's a difference. Finished is when all the tasks are done. Real is when it stops feeling like a side project and starts feeling like software.
What Shipping Actually Feels Like
Here's the emotional sequence — as honestly as I can write it:
T-minus 1 hour: Quiet panic. You're finding small things to fix that don't need fixing. You're re-reading your README for the fifth time. You're refreshing your deployment preview.
T-minus 10 minutes: Resignation. You've accepted that it's not perfect. That there are still edge cases you haven't handled. That the mobile nav is slightly off on the iPhone SE. You hit deploy anyway.
T-zero: A strange calm. The kind that comes after a decision is made and can't be unmade.
T-plus 5 minutes: You share it somewhere. A tweet. A Discord. Submitting to dev.to. And then you close the tab immediately because you can't watch.
T-plus 20 minutes: You open the tab. Someone liked it. Someone actually looked at the thing you made. And something in your chest does a thing that's hard to describe — it's not quite pride, not quite relief. It's closer to vindication. Proof that the idea wasn't just in your head.
T-plus a few days: You look at it again, and you can see every flaw clearly. But you don't feel ashamed of them. You feel like a person who made a real thing and learned real things in the process of making it.
That's it. That's what shipping feels like.
The Thing About Being Proud of Your Work
Pride is a complicated word in developer culture. We're trained to be humble. To say "it's just a side project" is to minimise it. To pre-emptively apologise for the code quality before anyone even looks at it.
But there's a version of pride that has nothing to do with arrogance. It's the quiet satisfaction of knowing that something exists because you made it exist. That a year ago it was nothing, and now it is something. That if you didn't build it, it simply wouldn't be there.
That's not arrogance. That's a craft.
The developers I respect most aren't the ones with the cleanest code or the most GitHub stars. They're the ones who finish things. Who ships things? Who look at what they've built and – even knowing all the shortcuts they took and all the technical debt they accumulated – feel something?
Because code without feeling is just syntax. It's the feeling that makes it worth building.
What I've Learned From Building Things I'm Proud Of
A few things that are actually true, earned from time in the trough:
Constraints make you more creative, not less. The projects I'm most proud of weren't the ones with unlimited scope. They were the ones where I had a weekend, a weird idea, and no time to second-guess myself.
The version you ship will always feel unfinished. Ship it anyway. "Done and public" beats "perfect and private" every single time.
Other people's opinions of your work are data, not verdicts. When someone loves what you built, it tells you something useful. When someone doesn't, it also tells you something useful. Neither defines whether you should keep building.
The pride compounds. The first thing you ship feels terrifying. The second feels hard. By the tenth, shipping is just something you do. The fear never fully goes away — but it gets smaller relative to the satisfaction.
Building something you're proud of changes how you see yourself. Not in a dramatic way. In a quiet way. You start to think of yourself as someone who makes things. And that identity — builder, creator, maker — is one of the most useful identities a developer can carry.
A Question for You
What's the thing you've built that you're most proud of? Not the most technically impressive. Not the one with the most stars or the most users.
The one that made you feel something when you shipped it.
Drop it in the comments. I want to see what you've made.
If this resonated with you, follow along — I write about the craft and psychology of building things as a developer, not just the technical how-tos. Real talk, no fluff.