// package.json configuration
{
  "scripts": {
    "preinstall": "npx only-allow pnpm", // Enforce package manager
    "audit": "pnpm audit --audit-level=high"
  },
  "overrides": {
    // Force resolution of known vulnerable sub-dependencies
    "lodash": "4.17.21"
  }
}

import express from 'express';
import helmet from 'helmet';
import rateLimit from 'express-rate-limit';
import { z } from 'zod';

const app = express();

// 1. Security Headers via Helmet
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "'unsafe-inline'"], // Minimize unsafe-inline
      styleSrc: ["'self'"],
      imgSrc: ["'self'", "data:"],
      connectSrc: ["'self'"],
      frameSrc: ["'none'"], // Prevent clickjacking
      objectSrc: ["'none'"],
      upgradeInsecureRequests: []
    }
  },
  crossOriginEmbedderPolicy: true,
  crossOriginOpenerPolicy: true,
  crossOriginResourcePolicy: { policy: "same-origin" }
}));

// 2. Rate Limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per window
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: "Too many requests, please try again later." }
});

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

// 3. Strict Input Validation with Zod
const CreateUserSchema = z.object({
  email: z.string().email(),
  role: z.enum(['user', 'admin']).default('user'),
  age: z.number().int().min(18).max(120).optional()
});

app.post('/api/users', (req, res) => {
  try {
    const validatedData = CreateUserSchema.parse(req.body);
    // Process validated data
    res.status(201).json({ success: true });
  } catch (error) {
    if (error instanceof z.ZodError) {
      res.status(400).json({ 
        error: 'Validation failed', 
        details: error.errors 
      });
    } else {
      res.status(500).json({ error: 'Internal server error' });
    }
  }
});

import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager";

const client = new SecretsManagerClient({ region: "us-east-1" });

export async function getDbSecret() { const command = new GetSecretValueCommand({ SecretId: "prod/backend/db-credentials" });

const response = await client.send(command); if (response.SecretString) { return JSON.parse(response.SecretString); } throw new Error("Secret not found"); }

// Usage in DB connection // const dbConfig = await getDbSecret(); // const pool = new Pool(dbConfig);

### Step 4: API Defense and Authentication

Implement zero-trust API patterns. Validate every request, regardless of origin.

**Architecture Decision:** Use JWTs with short expiration times and refresh tokens. Validate tokens on every request. Implement CORS strictly.

**Implementation:**
```typescript
import jwt from 'jsonwebtoken';

const verifyToken = (req: any, res: any, next: any) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) {
    return res.status(401).json({ error: "Access token required" });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(403).json({ error: "Invalid or expired token" });
  }
};

// Apply to protected routes
app.get('/api/admin', verifyToken, (req, res) => {
  // Check specific permissions
  if (req.user.role !== 'admin') {
    return res.status(403).json({ error: "Insufficient permissions" });
  }
  res.json({ data: "Admin data" });
});

Step 5: Observability and Logging

Security events must be logged with sufficient context for forensic analysis without leaking sensitive data.

Architecture Decision: Centralized logging with PII redaction. Alerting on anomalous patterns (e.g., multiple failed logins, privilege escalation attempts).

Implementation:

import pino from 'pino';

const logger = pino({
  level: 'info',
  redact: ['req.headers.authorization', 'req.body.password', 'req.body.token'],
  transport: {
    target: 'pino-pretty',
    options: { colorize: true }
  }
});

// Middleware to log requests
app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = Date.now() - start;
    logger.info({
      method: req.method,
      url: req.url,
      statusCode: res.statusCode,
      duration,
      userId: req.user?.id
    });
  });
  next();
});

Pitfall Guide

1. Implicit Trust in Internal Services

Mistake: Assuming services within the VPC or mesh are safe from each other. Impact: Lateral movement during a breach. An attacker compromising one service can access the database directly. Remediation: Implement mutual TLS (mTLS) for service-to-service communication. Enforce authentication and authorization on internal APIs.

2. Verbose Error Messages in Production

Mistake: Returning stack traces, database schemas, or internal paths in error responses. Impact: Information disclosure aids attackers in crafting exploits. Remediation: Use a global error handler that returns generic messages to clients. Log detailed errors internally with correlation IDs.

3. Over-Privileged IAM Roles

Mistake: Assigning AdministratorAccess or broad permissions to backend services. Impact: If credentials are leaked, the attacker gains full control of the account. Remediation: Apply the Principle of Least Privilege. Grant only the specific permissions required for the service function. Use IAM roles for service accounts, not long-lived keys.

4. Static Secrets in Environment Variables

Mistake: Storing secrets in .env files or Kubernetes secrets without encryption at rest. Impact: Secrets can be exfiltrated via container escapes or misconfigured storage. Remediation: Use dynamic secret injection. Encrypt secrets at rest and in transit. Rotate secrets automatically.

5. Insecure Deserialization

Mistake: Parsing untrusted data using JSON.parse or language-specific serializers without validation. Impact: Remote Code Execution (RCE) via prototype pollution or malicious object graphs. Remediation: Validate input schemas strictly. Avoid deserializing untrusted data. Use safe parsing libraries.

6. Missing Idempotency and Replay Protection

Mistake: Allowing the same request to be processed multiple times without detection. Impact: Financial fraud, duplicate resource creation, or denial of service. Remediation: Implement idempotency keys for write operations. Use nonces or timestamps to prevent replay attacks.

7. Wildcard CORS Configuration

Mistake: Setting Access-Control-Allow-Origin: * or reflecting the Origin header dynamically. Impact: Cross-Site Request Forgery (CSRF) and data theft from malicious domains. Remediation: Configure a whitelist of allowed origins. Validate the Origin header against the whitelist server-side.

Production Bundle

Action Checklist

• Enforce Strict Input Validation: Implement schema validation on all API endpoints using tools like Zod or Joi.
• Rotate Secrets and Credentials: Audit all secrets, rotate immediately, and migrate to a dynamic secret manager.
• Implement Rate Limiting: Configure rate limits on all public and internal APIs to prevent abuse and DDoS.
• Configure Security Headers: Deploy Helmet or equivalent middleware to set CSP, HSTS, and X-Frame-Options.
• Audit Third-Party Dependencies: Run npm audit or equivalent; patch or replace vulnerable packages.
• Enable Detailed Audit Logging: Ensure logs capture security events with PII redaction and centralized storage.
• Test Backup and Recovery: Verify backups are encrypted, immutable, and restore procedures are tested quarterly.
• Review IAM Permissions: Apply least-privilege policies to all service accounts and roles.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Startup / MVP	Managed Services + Basic Headers + Auth0	Speed to market; low operational overhead; managed security reduces initial risk.	Low
Enterprise / Compliance	Zero Trust Mesh + Vault + WAF + SIEM	Meets audit requirements; granular control; defense-in-depth for high-value assets.	High
Legacy Migration	Container Isolation + API Gateway + Sidecar Proxy	Reduces risk without refactoring code; gateway handles security concerns centrally.	Medium
High-Throughput API	Edge Rate Limiting + Caching + Strict Validation	Performance optimization; reduces load on backend; prevents resource exhaustion.	Medium

Configuration Template

Dockerfile Best Practices:

# Multi-stage build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine AS production
WORKDIR /app
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./

USER nodejs

# Security: Drop capabilities
# RUN apk add --no-cache libcap && \
#     setcap cap_net_bind_service=+ep /usr/local/bin/node

EXPOSE 3000
CMD ["node", "dist/main.js"]

Nginx Security Headers (Reverse Proxy):

server {
    listen 443 ssl http2;
    server_name api.example.com;

    ssl_certificate /etc/ssl/certs/api.pem;
    ssl_certificate_key /etc/ssl/private/api.key;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "DENY" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header Content-Security-Policy "default-src 'self';" always;

    location / {
        proxy_pass http://backend:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Quick Start Guide

1. Install Security Dependencies:

   npm install helmet express-rate-limit zod jsonwebtoken pino
   

2. Add Validation Middleware: Create a validation.ts file defining schemas for all endpoints. Apply schema.parse(req.body) in route handlers.

3. Configure Runtime Security: Add helmet and rateLimit to the Express app setup. Configure CSP directives to match your application's needs.

4. Secure Secrets: Remove all secrets from .env. Configure your CI/CD pipeline to inject secrets from your secret manager at runtime.

5. Containerize Securely: Update your Dockerfile to use a non-root user, multi-stage builds, and minimal base images. Scan the image with Trivy or Snyk.

6. Verify: Run npm audit. Test headers using securityheaders.com. Validate rate limiting by sending burst requests.

---

Backend security hardening is not a one-time task but a continuous discipline. Integrate these practices into your CI/CD pipeline, enforce them via policy-as-code, and regularly review your attack surface to maintain a resilient backend architecture.