# I Built a Customizable CLI for Node.js Backends 🚀 BACKKIT > Build the backend you actually want. ```bash npx @ghost1411/backkit ``` #node #javascript #typescript #opensource

Amaan Zaidi — Mon, 28 Sep 2026 15:09:49 +0000

I Built a Customizable CLI for Node.js Backends

Amaan Zaidi — Mon, 28 Sep 2026 14:54:07 +0000

I Built a Customizable CLI for Node.js Backends 🚀

Every time I started a new Node.js backend, I found myself doing the same things again.

Setting up the framework.

Creating the folder structure.

Configuring the database.

Adding an ORM.

Setting up authentication.

Creating environment files.

Installing dependencies.

And then finally... starting the actual project.

There are already plenty of backend boilerplates and scaffolders out there, but I wanted something different.

I didn't want a single predefined backend.

I wanted to choose the pieces I needed and generate the backend around those choices.

So I built Backkit.

What is Backkit?

Backkit is an interactive CLI for scaffolding customizable Node.js backends.

Instead of giving you one fixed boilerplate, Backkit lets you choose the stack you want.

Choose your stack

Category	Options
Language	TypeScript, JavaScript
Framework	Express, Fastify
Database	PostgreSQL, MongoDB
ORM / ODM	Drizzle, Prisma, Mongoose
Authentication	Better Auth, JWT, None

You simply run:

npx @ghost1411/backkit

And Backkit guides you through the setup.

What Backkit generates

Depending on your selections, Backkit can generate:

Project structure
Framework configuration
Database setup
ORM / ODM configuration
Authentication setup
Environment configuration
Dependency installation
Ready-to-run development setup

The goal is simple:

Choose your stack → generate your backend → start building.

How it works

The process is essentially:

Your choices
     ↓
Configuration
     ↓
Template selection
     ↓
File generation
     ↓
Dependency installation
     ↓
Ready-to-run backend

Backkit takes the choices you make through the CLI and uses them to determine what should be generated.

This means the resulting project isn't a huge boilerplate where you have to delete half the code before starting.

You get the components you selected.

Installation

You don't need to install Backkit globally.

Run it directly using npx:

npx @ghost1411/backkit

That's it.

The interactive CLI will start and guide you through the configuration.

Quick Start

Run:

npx @ghost1411/backkit

You'll be able to select the technologies you want.

For example:

? Choose your language
❯ TypeScript
  JavaScript

? Choose your framework
❯ Express
  Fastify

? Choose your database
❯ PostgreSQL
  MongoDB

? Choose your ORM / ODM
❯ Drizzle
  Prisma
  Mongoose

? Choose authentication
❯ Better Auth
  JWT
  None

Once the configuration is complete, Backkit generates your project.

Then:

cd your-project
npm install
npm run dev

And you're ready to start building.

Example Generated Structure

A generated TypeScript + Express backend could look something like:

your-backend/
├── src/
│   ├── config/
│   ├── controllers/
│   ├── db/
│   ├── middleware/
│   ├── routes/
│   ├── services/
│   └── index.ts
│
├── .env
├── .env.example
├── package.json
├── tsconfig.json
└── README.md

The exact structure depends on the options selected during setup.

Why did I build this?

I've worked on multiple Node.js backend projects, and I kept noticing the same pattern.

The first part of the project was often:

Setup
Setup
Setup
Setup
Setup
...
Finally start building

The actual backend logic came later.

I wanted to automate that repetitive part.

But I also didn't want to create another tool that says:

"Here is my preferred backend architecture. Use it."

Different projects need different stacks.

A small API might need Express and PostgreSQL.

Another project might use Fastify and MongoDB.

Someone else might prefer Prisma.

Someone else might prefer Drizzle.

And sometimes you don't need authentication at all.

That's where the idea for Backkit came from.

Why customization matters

Imagine two projects.

Project A

TypeScript
+
Express
+
PostgreSQL
+
Drizzle
+
Better Auth

Project B

TypeScript
+
Fastify
+
MongoDB
+
Mongoose
+
No Authentication

With a traditional boilerplate, you might start with one and manually modify it.

With Backkit, the idea is to make those choices before generation.

Don't adapt your project to a boilerplate. Generate a boilerplate that fits your project.

The Architecture

At a high level, Backkit follows a simple pipeline:

                  ┌─────────────────┐
                  │   User Choices  │
                  └────────┬────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │  Configuration  │
                  └────────┬────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │ Template Select │
                  └────────┬────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │ File Generation │
                  └────────┬────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │  Dependencies   │
                  └────────┬────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │ Ready Backend   │
                  └─────────────────┘

The important part is keeping the different components modular.

Adding another framework, database, ORM, or authentication provider should extend the system rather than require rewriting the entire CLI.

Built With

Backkit is currently built around the Node.js ecosystem.

Core

Node.js
TypeScript
npm / npx

Project generation

Node.js filesystem APIs
Template-based generation
Interactive CLI prompts

The project is intentionally designed to be extensible so more backend technologies can be added over time.

Why `npx`?

One of the things I wanted was to make trying Backkit as frictionless as possible.

Instead of asking users to:

npm install -g @ghost1411/backkit

they can simply run:

npx @ghost1411/backkit

No global installation.

No setup before trying it.

Just run the command and start creating a backend.

What's Next?

Backkit is still in its early stage, so there is a lot of room to expand.

Current

[x] Interactive CLI
[x] Custom stack selection
[x] Project generation
[x] Template-based architecture
[x] npm package
[x] npx support

Planned

[ ] More backend frameworks
[ ] More databases
[ ] More ORMs / ODMs
[ ] More authentication providers
[ ] More architecture patterns
[ ] Custom user templates
[ ] Community-contributed templates
[ ] More configuration options

The long-term idea is to make Backkit feel less like a single boilerplate and more like a component library for backend development.

Open Source

Backkit is open source, and I'd love to see other developers experiment with it.

If you build Node.js backends, I'd especially like feedback on:

What frameworks should be supported?
What databases should be added?
What authentication options would be useful?
What should the generated structure look like?
What would make the CLI easier to use?

Found a bug?

Open an issue.

Have an idea?

Open an issue.

Want to contribute?

Pull requests are welcome.

Try Backkit

Give it a try:

npx @ghost1411/backkit

Links

GitHub: https://github.com/amaan1114/backkit

npm: https://www.npmjs.com/package/@ghost1411/backkit

If you find the project useful, consider giving it a ⭐ on GitHub.

It helps more developers discover the project.

I'd Love Your Feedback

Backkit is still very early, and I'm curious about how other developers would use it.

If you could generate your ideal Node.js backend with one command, what would you want to choose?

Framework?

Database?

ORM?

Authentication?

Architecture?

Let me know in the comments.

Backkit

Build the backend you actually want.

DEV Community: Amaan Zaidi

# I Built a Customizable CLI for Node.js Backends 🚀 **BACKKIT** > Build the backend you actually want. ```bash npx @ghost1411/backkit ``` #node #javascript #typescript #opensource