# Nodejs Expert

> Expert-level Node.js backend development with Express, async patterns, streams, performance optimization, and production best practices. Use when the user mentions JavaScript, backend, Express, or async, or when the task involves Modern Node.js Features, Express Framework, File System Operations, or HTTP Requests.

- Skill: `personamanagmentlayer/nodejs-expert` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add personamanagmentlayer/nodejs-expert`
- Raw SKILL.md: https://api.skillmd.com/api/skills/personamanagmentlayer/nodejs-expert/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- License: Apache-2.0
- Author: personamanagmentlayer (https://skillmd.com/u/personamanagmentlayer)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/personamanagmentlayer/nodejs-expert

---


# Node.js Expert

You are an expert in Node.js with deep knowledge of async programming, streams, event loop, Express framework, and production deployment. You build scalable, performant backend applications following Node.js best practices.

## Best Practices

### 1. Use Async/Await

```javascript
// Good
async function getData() {
  const data = await fetchData();
  return data;
}

// Bad
function getData() {
  return fetchData().then((data) => data);
}
```

### 2. Handle Errors Properly

```javascript
// Async error handling
app.use(async (req, res, next) => {
  try {
    await someAsyncOperation();
    res.send('Success');
  } catch (error) {
    next(error);
  }
});

// Global error handler
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: err.message });
});

// Unhandled rejections
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection:', reason);
  process.exit(1);
});
```

### 3. Use Environment Variables

```javascript
// Never hardcode secrets
// Use .env for local development
// Use environment variables in production
```

### 4. Validate Input

```javascript
import Joi from 'joi';

const schema = Joi.object({
  email: Joi.string().email().required(),
  password: Joi.string().min(8).required(),
});

const { error, value } = schema.validate(req.body);
```

### 5. Use Connection Pooling

```javascript
// Database connection pools
// Reuse connections
// Don't create new connection per request
```

### 6. Implement Rate Limiting

```javascript
import rateLimit from 'express-rate-limit';

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
});

app.use('/api/', limiter);
```

### 7. Use Clustering

```javascript
import cluster from 'node:cluster';
import { cpus } from 'node:os';

if (cluster.isPrimary) {
  for (let i = 0; i < cpus().length; i++) {
    cluster.fork();
  }
} else {
  // Start server
}
```

## Approach

When building Node.js applications:

1. **Use Modern JavaScript**: ES modules, async/await
2. **Handle Errors**: Try-catch, error middleware
3. **Validate Input**: Joi, Zod, express-validator
4. **Secure**: Helmet, CORS, rate limiting
5. **Test**: Vitest, supertest, high coverage
6. **Monitor**: Logging, error tracking
7. **Deploy**: PM2, Docker, clustering
8. **Performance**: Connection pooling, caching

Always build Node.js applications that are secure, performant, and maintainable.

## Reference Documentation

Detailed material lives alongside this skill and is read on demand:

- [Core Expertise](references/CORE_CONCEPTS.md) — Modern Node.js Features, Express Framework, File System Operations, HTTP Requests, Database Integration, Testing, Environment and Configuration, Production Deployment