Node.js backend inspector

Chrome DevTools for your Node.js backend.

See everything that happened during a backend request. Inspect request/response data, execution flow, outgoing HTTP calls, database operations, errors, and timings from one local dashboard.

$ npm install server-devtools
Works with: • Node.js • Express • NestJS • MongoDB • PostgreSQL • MySQL • Redis (ioredis)
Actual dashboard

Inspect the request lifecycle in one view.

Explore the current ServerDevTools dashboard with sanitized demo data. Every slide is a static screenshot from the running dashboard—there are no simulated rows, tabs, or controls.

Captured from the current local dashboard with sanitized demo data. The Requests view has no matching dark asset, so it remains unchanged in Dark mode while its surrounding frame follows the selected theme.

Embedded Dashboard

From install to request inspection.

Mount the middleware in your existing Node.js application and open its dashboard at /_devtools.

01

Install

Add the developer instrumentation package to your project. Supported OpenTelemetry database instrumentation is included.

$ npm install server-devtools
02

Initialize & Preload

Create and start your own initialization file, then preload it before your application starts. Choose any filename and location.

Initialize once · preload before app imports
03

Import & Inspect

Import that same instance in your application, mount its middleware, and open /_devtools to inspect requests.

http://localhost:3000/_devtools
Request Inspection

Everything that happened during a request.

http

HTTP Requests

Inspect method, route and path parameters, query parameters, request headers and body, and response headers, body, and status.

account_tree

Execution

Follow middleware, handlers, database operations, and outbound calls within a request.

database

Database Operations

Inspect MongoDB, PostgreSQL, MySQL (`mysql2`), and Redis (ioredis) operations and their timing inside the request trace. Redis (ioredis) spans include command inspection, request-linked spans and timings, and command errors, with support verified in Express and NestJS, including pipelines and transactions.

cloud_sync

External APIs

Inspect outbound native Node.js HTTP/HTTPS and fetch/Undici calls, including request and response headers and bodies.

bug_report

Errors & Exceptions

Inspect request-associated errors with available message, type, and stack information.

timer

Timing

See duration across the request execution tree and compare operation timings.

In-Process Runtime

Runs inside your application.

ServerDevTools runs inside your Node.js application, instruments backend activity, persists inspection history to SQLite, and serves its dashboard from your existing HTTP server without requiring a separate ServerDevTools web server.

check_circle Embedded in your existing Node.js application
check_circle Dashboard served from /_devtools
check_circle SQLite-backed inspection history
// server-devtools.ts
import ServerDevTools from "server-devtools";

export const devtools = new ServerDevTools({
  auth: {
    username: process.env.SERVER_DEVTOOLS_USERNAME!,
    password: process.env.SERVER_DEVTOOLS_PASSWORD!,
  },
});

await devtools.start();

// src/main.ts
import { createServer } from "node:http";
import { devtools } from "../server-devtools";

const server = createServer((req, res) => {
  devtools.middleware(req, res, () => {
    res.end("ok");
  });
});

server.listen(3000);

// npx tsx watch --import ./server-devtools.ts src/main.ts
Preload initializes instrumentation before application imports.
Same HTTP server · /_devtools Optional: encrypt selected sensitive captured fields at rest. See the README for configuration details.
Examples

Working Examples

Start from a working integration or use it as a reference for your own application.

Workflow Shift

Stop digging through terminal logs.

When an endpoint fails or slows down, see the HTTP request, full execution path, database queries, Redis (ioredis) commands, external network calls, and errors correlated together.

Without ServerDevTools close
  • ✕ Add console.log("here 1")
  • ✕ Grep through messy terminal stdout
  • ✕ Restart node server process
  • ✕ Manually re-trigger request from curl / Postman
  • ✕ Guess which external dependency stalled
Request details and execution context spread across logs
With ServerDevTools check
  • ✓ Open http://localhost:3000/_devtools
  • ✓ Click the failing or slow request in table
  • ✓ Inspect database, Redis (ioredis), and outbound HTTP activity in context
  • ✓ Review request timing and associated errors
Request activity in one dashboard
Data & storage

Your traces stay with your application.

ServerDevTools can capture request and response metadata, selected headers and bodies, user context when configured, database operations, and outbound HTTP activity when the relevant instrumentation and request context are present. It stores traces in ./server-devtools.db by default and does not send telemetry to a ServerDevTools service.

Default header redaction covers authorization, proxy-authorization, cookie, set-cookie, and x-api-key; additionalHeaders extends that list. Optional AES-256-GCM encryption protects configured fields at rest; it is not whole-database encryption. Read the data-handling guidance →

Performance

Measure overhead in your workload.

Instrumentation adds span creation and persistence work. Native outbound request and response body capture skips bodies above 256 KiB without changing the network payload; inbound response and fetch capture have no SDK byte limit today. No reproducible benchmark is published, so measure in your own environment.

FAQ

Short answers for setup and security.

What is ServerDevTools?

An in-process Node.js request inspection dashboard for seeing request lifecycles, timings, database operations, outbound calls, and errors during development.

How is it different from Postman or Swagger?

Postman sends and tests API requests, while Swagger documents an API contract. ServerDevTools observes what your running backend actually did during a request.

How is it different from hosted APM tools?

It is a local, in-process inspection tool rather than a hosted monitoring platform. It focuses on request detail and a local SQLite history instead of fleet-wide monitoring.

Which Node versions and frameworks are supported?

The SDK requires Node.js 20 or newer and documents native Node HTTP, Express, and NestJS integrations, plus MongoDB, PostgreSQL, MySQL, Redis, and outbound HTTP instrumentation.

Does captured data leave my application environment?

The SDK has no ServerDevTools telemetry service or collector; it writes to local SQLite. Outbound instrumentation observes your application’s own calls and does not export them to ServerDevTools.

Can sensitive information be captured?

Yes. Bodies, URLs, query parameters, headers, database attributes, errors, and user data can contain sensitive values. Header-name redaction is enabled for the documented defaults and can be extended with redaction.additionalHeaders; it does not cover bodies, URLs, queries, or arbitrary span attributes. Optional encryption protects configured fields at rest. See the security guide.

Where is data stored, and how do I delete it?

By default, traces are stored in ./server-devtools.db. Use Clear History in the dashboard or delete individual traces; there is no automatic trace retention policy.

What happens when a captured body is too large?

Native outbound request and response body capture has a fixed 256 KiB limit. Oversized bodies are skipped rather than truncated, while the complete application network payload continues to its destination. Other body paths do not currently have an SDK byte limit.

Why must instrumentation start before application imports?

OpenTelemetry patches supported libraries during startup. Preloading ServerDevTools before those imports lets the instrumentations register before requests or database clients are created.

How does this differ from Server-Timing?

Server-Timing is a response header for exposing selected server durations to a client. ServerDevTools stores a richer server-side trace with request, database, outbound, and error details.

Compare workflows

Choose the right inspection layer.

See how an in-process request inspector compares with an API client and a hosted observability platform.

Coming next

More visibility, more control.

Planned capabilities, not available yet:

Configurable trace storage

Store ServerDevTools data through user-configured storage instead of only the default local SQLite file.

See what your backend is actually doing.

Free and open source. Embed the inspector in your Node.js application and inspect activity in development, staging, or deployed environments.

$ npm install server-devtools