I build a lot of admin systems — client work and my own projects. They all share the same traits: tight deadlines, changing requirements, and usually just me on the keyboard.

After years of trial and error, the setup that works best for me is full-stack Node.js + a framework with fixed conventions. Here's why, and what I built around it.

The practical benefits of full-stack Node.js

Not theory — things I actually feel day to day:

One person can carry the whole project. Vue on the frontend, Node on the backend, one language. I write an endpoint and immediately wire up the page for it. No context switching between two languages.

Shared types. With TypeScript on both ends, the API's field types are the same types the frontend uses. Backend changes a field, the frontend build fails and tells you where. No comparing against API docs by hand.

No integration meetings. When you write both ends, you decide what the API looks like. Integration cost is basically zero — anyone who has done frontend/backend coordination knows how much time that saves.

Hiring is easier. If the project grows, half the people who know Vue can pick up Node quickly.

Full-stack alone isn't enough — you need fixed conventions

Node full-stack solves the language problem. But there's another one: every project rebuilds the same plumbing — directory layout, permissions, list pages, menu config. It's roughly the same every time, yet you redesign it every time. It wastes time, and the designs drift, so your own old projects feel foreign six months later.

So I turned my own way of working into Me-Admin — the conventions and common features are already decided:

• Fixed directory structure and layering; every module looks identical
• Built-in RBAC (menu / button / API levels), users, roles, menus — ready out of the box
• The stuff admin panels always need — lists, search, pagination, forms, uploads — already has components and established patterns
• Mainstream stack: Midway 3 + Sequelize + PostgreSQL on the backend, Vue 3 + Vite + Element Plus + vxeTable on the frontend

The biggest time-saver: define an entity, run two commands, get a whole module.

# Sync the database schema
pnpm exec meadmin sync product

# Generate controller, API, frontend pages, menu permissions
pnpm exec meadmin crud product --menu

Refresh the admin panel and the module is in the menu — full CRUD working. The output is plain source code in your repo, no black boxes. Edit it directly.

{% github https://github.com/meadmin-cn/meadmin %}

Works for agile sprints, works for AI coding too

Two situations where this setup really pays off:

Deadline-driven agile work. Requirement comes in → define the entity → run the commands → the basics are done. All remaining time goes to actual business logic. Requirement changes? Update the entity and regenerate, or just edit the generated code.

AI-assisted coding. This is my biggest takeaway from the past year. Because the framework's conventions are fixed and every module has the same shape, AI writes noticeably more accurate code by copying existing modules. Even more direct: I have the AI write the entity definition (describe the table's fields), which it does fast and well, then the commands generate the module. The only AI output I need to review is that one entity file — a few dozen lines, checked at a glance. Everything else is identical generator output.

Simple truth: the more fixed the conventions, the smoother the work — whether a human or an AI is writing it.

Try it

pnpm create meadminjs@latest
pnpm dev

Admin panel at http://127.0.0.1:7001/admin (admin / meAdmin#202507!P). MIT licensed, use it for anything.

• GitHub: https://github.com/meadmin-cn/meadmin
• Website: https://www.meadmin.cn
• Docs: https://www.meadmin.cn

Questions → open an issue, I answer all of them: https://github.com/meadmin-cn/meadmin/issues

If it saves you time, a star means a lot: https://github.com/meadmin-cn/meadmin