What are key security best practices for a Node.js app?

Question

IT Interview Practice · Accepted Answer

Securing a Node app means defending against common web vulnerabilities (the OWASP Top 10) at multiple layers — input handling, authentication, dependencies, and configuration. Security is layered (defense in depth), not a single fix.

## 1. Validate and sanitize all input

```js
import { z } from "zod";
// never trust client input — validate shape/type before using it
const schema = z.object({ email: z.string().email(), age: z.number().min(0) });
const data = schema.parse(req.body); // rejects malformed/malicious input
```

## 2. Prevent injection (SQL, NoSQL, command)

```js
// ❌ string concatenation → SQL injection
db.query(`SELECT * FROM users WHERE id = ${req.params.id}`);
// ✅ parameterized queries — input is data, never executable SQL
db.query("SELECT * FROM users WHERE id = $1", [req.params.id]);
```

Always use parameterized queries / an ORM, and never build commands from user input (see command injection with `child_process`).

## 3. Authentication & secrets

```text
✓ Hash passwords with bcrypt/argon2/scrypt (slow + salted) — never plain/SHA
✓ Store secrets in env vars, never in code/git
✓ Use httpOnly, secure, sameSite cookies for sessions (XSS-resistant)
✓ Sign/verify JWTs properly; keep tokens short-lived
```

## 4. Set security headers & rate-limit

```js
import helmet from "helmet";
import rateLimit from "express-rate-limit";

app.use(helmet()); // sets secure HTTP headers (CSP, HSTS, X-Frame-Options, etc.)
app.use(rateLimit({ windowMs: 60_000, max: 100 })); // throttle abuse/brute-force
```

`helmet` adds protective headers; rate limiting defends against brute-force and DoS.

## 5. Keep dependencies secure (supply chain)

```bash
npm audit          # check installed packages for known vulnerabilities
npm audit fix
# + keep deps updated; review postinstall scripts; pin versions via the lockfile
```

Most Node code is third-party packages — vulnerable dependencies are a major attack vector. Audit and update regularly.

## 6. Other essentials

```text
✓ Use HTTPS (TLS) everywhere; redirect HTTP → HTTPS
✓ Don't leak error details/stack traces to clients in production
✓ Escape output to prevent XSS (frameworks usually do this)
✓ Implement proper authorization (not just authentication) — check permissions per action
✓ CORS configured to an allowlist, not "*" for credentialed APIs
✓ Limit request body size to prevent payload-based DoS
```

## Why it matters

Web apps are constant targets, and Node apps are exposed to the full range of web vulnerabilities — injection, broken auth, XSS, vulnerable dependencies, misconfiguration.

No single measure suffices; security is **layered**: validate input, parameterize queries, hash passwords correctly, manage secrets safely, set protective headers, rate-limit, audit dependencies, and use HTTPS.

Understanding these practices (and the OWASP risks behind them) is essential responsibility for anyone building production Node services — a single overlooked layer (an injection, a leaked secret, an unpatched dependency) can compromise the whole system.

1. Validate and sanitize all input

2. Prevent injection (SQL, NoSQL, command)

3. Authentication & secrets

4. Set security headers & rate-limit

5. Keep dependencies secure (supply chain)

6. Other essentials

Why it matters

Related questions