DEV Community: Milan K Jain

Building AppForge: A Unified Project Scaffolding CLI for Modern Development

Milan K Jain — Tue, 02 Jun 2026 11:36:09 +0000

As developers, we've become accustomed to powerful tooling that helps us get started quickly.

If you've worked with React, you've probably used Create React App in the past or Vite today. Angular provides its own CLI that can generate an entire application with a single command. These tools remove the repetitive work of creating folders, configuring build tools, installing dependencies, and setting up project structures.

However, while working on backend projects, I noticed something interesting.

Although there are excellent framework-specific tools such as Express Generator, Nest CLI, and Fastify CLI, I often found myself switching between different tools depending on the project I was building. Each framework had its own setup process, structure, and commands.

That observation led me to a simple question:

What if there was a single CLI that could scaffold projects across different technologies while providing a consistent developer experience?

That idea became AppForge.

The Problem

Starting a new project often involves repeating the same setup tasks:

Creating a project structure
Installing dependencies
Configuring TypeScript
Creating scripts in package.json
Setting up Express
Configuring development environments
Creating boilerplate files

These tasks aren't difficult, but they are repetitive.

Even with existing framework generators, developers often need to remember different commands for different technologies.

For example:

npm create vite@latest

nest new my-app

npx express-generator

Each tool solves a specific problem, but there isn't always a unified workflow.

Introducing AppForge

AppForge is a project scaffolding CLI designed to simplify project creation through a single interface.

The current version focuses on Node.js applications using Express.

Features include:

Interactive command-line experience
Node.js project generation
JavaScript support
TypeScript support
Automatic dependency installation
Ready-to-run Express application
Standardized project structure

Using AppForge is straightforward:

npx @milankj/appforge

The CLI then guides you through a few simple prompts:

Application Name: my-api
Application Type: Node
Language: TypeScript

Once complete, the project is generated, dependencies are installed, and the application is ready to run.

Under the Hood

AppForge is built using:

Node.js
TypeScript
Inquirer
fs-extra

The CLI works by selecting a predefined template, copying it into a new project directory, updating project-specific values, and installing dependencies automatically.

The current structure follows a template-based approach:

templates/
└── node/
    ├── javascript/
    └── typescript/

This architecture makes it easy to add new templates and technologies in future releases.

What I Learned

Building AppForge turned out to be a valuable learning experience.

Some of the topics I explored included:

Node.js CLI Development

Learning how npm packages expose executable commands through the bin field and how global CLI tools work.

ESM and Modern TypeScript

Working with modern Node.js module systems, including:

ES Modules
NodeNext
Import resolution
Runtime compatibility

npm Package Publishing

Publishing a package involves more than simply running npm publish.

I gained hands-on experience with:

Package versioning
Dependency management
Scoped packages
npm distribution
CLI packaging

Project Scaffolding Patterns

I also learned how many popular tools approach project generation using templates and file generation strategies.

Future Plans

The current version is only the beginning.

Planned improvements include:

Additional Backend Frameworks

Fastify
NestJS
Additional API templates

Frontend Support

React
Angular
Additional frontend frameworks

Advanced Configuration

Database selection
Authentication templates
Docker support
Environment configuration

Template Versioning

Maintaining templates through proper versioning and update strategies to ensure generated projects stay current.

Why Open Source Developer Tools Matter

One of the things I enjoy most about software development is building tools that improve developer productivity.

Many of the frameworks and libraries we use every day exist because someone identified a repetitive problem and decided to automate it.

AppForge is a small step in that direction.

While the current version is focused on Node.js and Express, the long-term goal is to create a flexible and extensible project generation platform that provides a consistent experience regardless of the technology stack being used.

Try AppForge

You can install and run AppForge directly from npm:

npx appforge-toolkit

npm package:

NPM Package Link
Feedback, ideas, and feature suggestions are always welcome.

Building tools for developers is one of the best ways to learn, and AppForge has already taught me a great deal about Node.js, TypeScript, package publishing, and developer tooling. I'm excited to continue improving it and expanding its capabilities in future releases.

Simulating IoT Devices Without Physical Hardware 🚀

Milan K Jain — Sun, 03 May 2026 07:47:47 +0000

One of the recurring challenges while building IoT systems is testing device communication, telemetry handling, MQTT flows, and event-driven architectures without constantly relying on physical hardware. To solve this problem, I recently started building a lightweight IoT Simulator CLI focused on helping developers simulate virtual devices directly from the terminal.

The project is designed for developers working on IoT platforms, MQTT brokers, RabbitMQ pipelines, telemetry ingestion systems, automation workflows, and real-time event processing. Instead of manually mocking payloads or depending on real devices during development, the simulator allows virtual devices to behave like actual connected hardware with configurable telemetry, topics, and runtime interactions.

The current version focuses on providing a simple but flexible developer experience with config-driven device simulation and MQTT communication support. The goal is to make local IoT testing faster, easier, and more scalable while keeping the simulator lightweight and developer-friendly.

This is still the first version, but there’s a lot planned ahead — including more advanced payload generators, richer simulation controls, better orchestration capabilities, and expanded protocol support.

📦 npm Package: PACKAGE LINK

Would love feedback from developers working with IoT systems, MQTT infrastructure, or event-driven architectures.

🚀 Fixing MongoDB Updates in n8n (No More Workarounds!)

Milan K Jain — Thu, 16 Apr 2026 17:23:18 +0000

If you've ever used MongoDB with n8n, you've probably hit this limitation.

The MongoDB node in n8n doesn’t actually support real MongoDB update operations.

Yeah… that surprised me too.

😤 The Problem

The existing update functionality is extremely limited:

Only allows updating a single field
Uses updateKey + value
Internally tied to updateOne

That means no support for native MongoDB update operators like:

$set (multiple fields)
$pull
$push
$rename
$inc

🤯 Real-world limitation

Let’s say you want to remove a value from an array:

{
  "$pull": {
    "tags": "deprecated"
  }
}

👉 Not possible in the current node.

Or update multiple fields:

{
  "$set": {
    "status": "active",
    "updatedAt": "2026-01-01"
  }
}

🧠 The Workarounds (that shouldn’t exist)

Because of this, developers are forced to:

Use aggregation pipelines 😬
Add Code nodes 🤯
Chain multiple operations 😵 This defeats the purpose of using a low-code tool like n8n.

💡 The Fix

I created a PR that enables JSON-based update operations in the MongoDB node.

✅ What’s new?

You can now define:

A JSON filter
A JSON update object 👉 Just like native MongoDB.

🔥 Before vs After

❌ Before

One field update only
No operators
Limited flexibility

✅ After (JSON Mode)

{
  "filter": {
    "userId": "123"
  },
  "update": {
    "$set": {
      "status": "active"
    },
    "$inc": {
      "loginCount": 1
    }
  }
}

👉 Clean
👉 Flexible
👉 Powerful

🛠️ What this unlocks

This change enables:

Updating multiple fields in one operation.
Using advanced operators like $pull, $push, $rename.
Writing cleaner workflows.
Removing unnecessary Code nodes.
Aligning with native MongoDB behavior.

⚙️ How it works

A new mode is introduced:

Simple Mode (existing)
Uses updateKey
No changes
JSON Mode (new) Accepts raw JSON:
Filter
Update object 👉 Fully opt-in 👉 No breaking changes

🧪 Stability
✅ Backward compatible
✅ Input validation (invalid / empty JSON)
✅ Unit tests added
✅ All existing tests passing
🎯 Why this matters

n8n is powerful because it bridges the gap between code and no-code.

But limitations like this push developers back into writing code — unnecessarily.

This change:

✔ Reduces friction
✔ Improves flexibility
✔ Matches real MongoDB capabilities
✔ Saves time for developers

🚀 PR Link

👉 https://github.com/n8n-io/n8n/pull/27583

Would love feedback from the community and maintainers!

💬 Final thought

Sometimes the most impactful improvements aren’t flashy…

They’re the ones that remove everyday friction.

This is one of them.