I make A LOT of things.
Some turn into bigger projects than I expected. Some are experiments. Some are tiny utilities I made because I wanted one very specific thing and didn't feel like using whatever already existed.
And lately I've been thinking about when a project is actually done.
Not abandoned. Not sitting in a folder waiting for the mythical day when I suddenly decide to work on it again.
Just... done.
Not everything needs a roadmap
There's this weird tendency in software development where the second you build something, your brain starts trying to turn it into more.
Okay, it works. Cool.
But what if it had accounts?
What if it synced across devices?
What if there was an API?
What if I turned it into a SaaS?
What if I added seventeen things I never actually wanted in the first place?
Sometimes that makes sense. Plenty of good projects start small and grow because you realize there's a lot more you want to do with them.
But sometimes I wanted a tool that does one thing, and now I have a tool that does that thing.
Mission accomplished.
I don't think every project needs twelve integrations, a pricing page, and a five-year roadmap just because technically it could have them.
Sometimes the point was just making it
A lot of my projects start with some version of:
"I wonder if I could make this."
That's honestly enough motivation for me most of the time.
Maybe I'm trying a new library. Maybe I want to figure out how something works. Maybe I need some tiny utility. Maybe I just had a dumb idea at 1 AM and now apparently we're doing this.
If I build it, learn whatever I wanted to learn, and end up with something that does what I wanted, I don't really see that as an unfinished project.
It means I got what I wanted out of it.
And I think that's especially important if you're somebody who likes starting new things.
Because otherwise every experiment slowly turns into another responsibility.
Now you've got an endless list of things you're supposed to maintain, improve, and maybe eventually monetize.
That's a great way to make a hobby feel like a job.
No thanks.
Some projects do grow
Sometimes I start with a small idea, and then I keep thinking of new features I want to add.
Sometimes people use something you made and suggest something great to add to it.
Sometimes you just really like the project and it's fun to keep messing with it.
Those are great too.
I love building bigger things when I actually want to.
I just don't think growth has to be the default measure of whether a project was worth making.
A tiny utility that saves me five clicks was worth making.
An experiment that taught me something was worth making.
A completely ridiculous app that exists mostly because it made me laugh was worth making.
It doesn't have to become a product or a business or my new personal brand to justify the time I spent making it.
Maybe "done" just means it did its job
I think I'm getting more comfortable with letting some projects just... exist.
If I find a bug, I'll probably fix it.
If six months from now I suddenly think of something I want to add, I can add it.
But sometimes I made the thing, and the thing works, and I like it.
That's enough for me.
And honestly, sometimes the best thing I can do with a project is leave it alone and go make something else.
Which is good, because I probably already have another idea.
How do you decide when one of your projects is actually done?
Do you have a graveyard full of unfinished projects?
Top comments (10)
The test I've started using is whether the next change would be for the tool or for an imagined user. Fixing a bug I actually hit is for the tool. Adding accounts in case someone else wants it is for a person who doesn't exist yet, and that's usually the moment a finished thing quietly turns into a maintenance job. Your not-abandoned-just-done distinction probably deserves a line in the README too, so nobody reads the silence as neglect.
I really like that distinction between changes for the tool and changes for an imagined user. That’s such an easy trap to fall into, especially once you start thinking “well, someone might want…” and suddenly you’re building for people who don’t even exist yet.
And the README idea is actually really smart. Calling something intentionally finished instead of just leaving it quiet would make that a lot clearer.
I build one main app and a lot of small single-page tools around it, and the small ones taught me what done looks like for me. A tool that answers one question without a login is finished the day it works.
The moment I start thinking about adding accounts to one, it stops being a tool and turns into a second product I would have to support. So my rough test is that if the next feature needs a database, it probably belongs to a different project.
I really like that way of looking at it. The database test is actually a pretty great line to draw. Once accounts, persistence, user data, etc. start creeping in, it really does stop being “a little tool” and starts becoming something you have to maintain as a product.
I think I’m slowly getting better at recognizing that point instead of automatically thinking every useful little thing needs to grow.
I really liked the idea that a project doesn't have to keep growing to be considered successful. If it solves the problem you built it for or teaches you something valuable, that can be enough. Sometimes knowing when to stop adding features and move on to the next idea is just as important as building the project itself. Great perspective!
Yeah, I think knowing when to stop is a skill in itself. Sometimes the best thing you can do is recognize that the project already accomplished what you made it for and move on to the next thing.
Really enjoyed this, Jessica. I think we’ve gotten a little too used to measuring projects by how much they grow instead of whether they actually did what we wanted.
Exactly. I think “did it do what I wanted it to do?” is a much better measure than “how much can I keep adding to it?” Not every project needs to keep growing forever.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.