Starting a backend project is mostly a chore you have already done.

You know what you want. Express or Fastify. Postgres or Mongo. Some auth. A Dockerfile you will not think about again. None of that is interesting, and all of it takes an evening before you write a single line of the thing you actually sat down to build.

So I shipped a tool with five ready-made project templates. Pick one, get a folder. People installed it. For about a year I thought I had built a scaffolding tool.

Then someone asked for a combination I did not have

They wanted one of my templates, but with a different database.

Reasonable ask. I went to add it, and that is when I did the arithmetic.

Three frameworks. Four databases. Three ORMs. Auth on or off. Every one of those combinations is a template someone could reasonably want, and templates are things I have to write by hand and keep working forever.

144 of them.

I had five.

And the feature I actually wanted to build next was a web page where you tick the things you want and get a project out. That idea makes no sense at all when the product is five frozen snapshots of five sets of decisions someone else made for you.

The tool was not broken. It just could not ever become the thing I wanted, and no amount of polish was going to change that.

So I rebuilt it around what you pick, not what I pre-made

Now you describe the project you want, and Atarashi assembles it.

atarashi new my-api --http fastify --db postgres --orm drizzle --auth jwt

No template matching that combination exists anywhere. It gets built for you, on the spot, from the pieces.

If you ask for something impossible it tells you before it writes anything, and it says what would fix it. Ask for an ORM without a database and it names the databases that would work. Ask for two databases and it refuses and tells you why. You never get a half-made project you have to delete before trying again.

If you would rather not think, there are still presets:

atarashi new my-api --preset backend-ts --yes

That gives you a project that installs, builds, boots and answers a health check with no edits from you. Not "a starting point". It actually runs.

The part I did not expect

Because the tool composes from pieces instead of copying a finished folder, it can come back later.

cd my-api
atarashi add obs/pino     # three weeks into the project

That is the bit I use most now, and it is the bit the old version could never have done. A template copier hands you a folder and forgets you exist. It has no idea what you picked, so there is nothing for it to add to.

Things I decided on purpose

It works offline. Everything it needs ships inside the package. On bad internet it still works, which matters to me more than it probably should.

Your project does not depend on Atarashi. Nothing it generates needs the tool at runtime, and atarashi eject cuts the last link entirely. A scaffolding tool that installs itself permanently into your project has misunderstood the job.

It is fast enough that you do not go make tea. Scaffolding is something you do while impatient. Under a second, and I keep it that way.

Every project records what it was made from, so you can reproduce it exactly later, or hand the file to someone else and have them get the same thing.

What it cost

The rewrite changed everything: different commands, different names, a whole set of options where previously there were none. Anyone on the old version had to migrate, which is a sentence I never expected to write about a tool that started life copying folders.

It was worth it, but I want to be honest that assembling a project from parts is genuinely harder than copying one. Pieces that each work fine can still combine into something that does not, which is why every combination gets built and tested rather than assumed.

What I actually took from it

The old templates were not wasted. They were five real, working sets of decisions, and breaking them apart into reusable pieces turned out to be almost mechanical once I was willing to do it.

The catch is that I only got there after admitting that the previous year of the project was a dead end. That is the whole lesson, really: the thing that killed it was not a bug or a performance problem. It was a feature I wanted that the design simply could not reach.