Which framework should I pick?

Choose based on needs: Express for quick setup and flexibility, NestJS for enterprise structure, Fastify for performance, and Hono for edge/lightweight deployments.

What are the essential packages I should start with?

typescript, zod, bcrypt, jsonwebtoken, helmet, cors, and a logger (winston or pino); plus ORM options like prisma or drizzle if using a database.

How do I enforce code quality?

Follow TS strict mode, validate inputs, handle all errors, use async/await, manage environment variables with dotenv, and implement structured logging with correlation IDs.

node-backend

npx machina-cli add skill shahtuyakov/claude-setup/node-backend --openclaw

Files (1)

SKILL.md

2.9 KB

Node.js Backend

Patterns and best practices for Node.js backend development with TypeScript.

Framework Selection

Framework	Best For	Use When
Express	Simple APIs, flexibility	Quick setup, full control needed
NestJS	Enterprise, structured	Large teams, Angular-like structure
Fastify	Performance critical	High throughput, schema validation
Hono	Edge, lightweight	Cloudflare Workers, minimal overhead

Reference Files

Topic	Load	Use When
Project structure	`references/project-structure.md`	Setting up new project or organizing code
Express patterns	`references/express-patterns.md`	Building with Express
NestJS patterns	`references/nestjs-patterns.md`	Building with NestJS
Auth implementation	`references/auth-patterns.md`	Implementing authentication
Error handling	`references/error-handling.md`	Setting up error handling
Validation	`references/validation.md`	Input validation patterns

Quick Start Patterns

Express Basic Setup

import express from 'express';
import cors from 'cors';
import helmet from 'helmet';
import { errorHandler } from './middleware/errorHandler';
import { routes } from './routes';

const app = express();

app.use(helmet());
app.use(cors());
app.use(express.json());

app.use('/api', routes);
app.use(errorHandler);

export { app };

NestJS Module Pattern

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

TypeScript Configuration

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true
  }
}

Essential Packages

Package	Purpose
`typescript`	Type safety
`zod`	Runtime validation
`bcrypt`	Password hashing
`jsonwebtoken`	JWT handling
`helmet`	Security headers
`cors`	CORS handling
`winston` / `pino`	Logging
`prisma` / `drizzle`	Database ORM

Code Quality Rules

Always use TypeScript - strict mode enabled
Validate all inputs - use Zod or class-validator
Handle all errors - never swallow exceptions
Use async/await - no callback hell
Environment variables - use dotenv, never hardcode secrets
Logging - structured logs with correlation IDs

Source

git clone https://github.com/shahtuyakov/claude-setup/blob/main/skills/node-backend/SKILL.mdView on GitHub

Overview

This skill covers Node.js backend development patterns using TypeScript across Express, NestJS, Fastify, and Hono. It provides project structure, code patterns, and best practices for building robust APIs, authentication flows, middleware, services, and server-side logic.

How This Skill Works

The guide presents framework-specific starter templates (Express, NestJS) and framework-agnostic references (project structure, auth, error handling, validation). It also enumerates essential TypeScript configuration, package choices, and coding standards used to enforce quality.

When to Use It

Building quick APIs with Express for flexibility and speed
Developing enterprise-grade backends with NestJS and strong structure
Optimizing performance for high-throughput services with Fastify
Deploying edge or lightweight apps with Hono on Cloudflare Workers
Creating a well-structured project using reference files, auth patterns, and code quality rules

Quick Start

Step 1: Choose a framework (Express, NestJS, Fastify, or Hono) based on API needs.
Step 2: Install essential packages (typescript, zod, bcrypt, jsonwebtoken, helmet, cors) and configure tsconfig.
Step 3: Create a basic app using the corresponding quick start pattern (Express Basic Setup or NestJS Module Pattern) and wire in middleware, routes, and error handling.

Best Practices

Use TypeScript with strict mode
Validate all inputs with Zod or class-validator
Handle all errors; never swallow exceptions
Prefer async/await; avoid callback hell
Manage secrets via dotenv; never hardcode

Example Use Cases

Express Basic Setup: helmet, cors, json parsing, errorHandler, and routes
NestJS Module Pattern: UsersModule wired with TypeOrmModule and service/controllers
TypeScript Configuration: ES2022 target, NodeNext module resolution, strict mode
Reference Files usage: project-structure.md, express-patterns.md, auth-patterns.md
Auth implementation patterns using bcrypt and jsonwebtoken for JWT-based auth

Frequently Asked Questions

Add this skill to your agents