Open Source

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.

Get Started arrow_forward View on GitHub

$ npm install server-devtools

Works with: • Node.js • Express • NestJS • MongoDB • PostgreSQL • MySQL

lock http://localhost:3000/_devtools

Connected :3000

Requests 5 total

filter_list block

Method

Path

Status

Time

GET

/users/123

200 OK

462ms

POST

/orders

201 Created

731ms

GET

/products

200 OK

84ms

POST

/checkout

500 Error

1.24s

GET

/health

200 OK

12ms

Filter: all Recorded 10.4 MB

GET /users/123 200 OK

462ms • 2.4 KB • 10:42:19.304

arrow_drop_down HTTP ROUTE GET /users/123

462ms (100%)

├── Middleware express.json()

0.4ms

├── Middleware middleware:auth_jwt

2.1ms

└── arrow_drop_down Handler route handler /users/:id

458ms

├── DATABASE users.findOne({ id: "123" })

12ms (2.6%)

└── EXTERNAL API GET https://api.billing.internal/status

421ms (91.1%)

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, and MySQL (`mysql2`) operations and their timing inside the request trace.

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!,
  },
  encryption: {
    key: process.env.SERVER_DEVTOOLS_ENCRYPTION_KEY!,
  },
  getCurrentUser: (req) => req.user,
});

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.statusCode = 404;
    res.end("Not found");
  });
});

server.listen(3000);

tsx watch --import ./server-devtools.ts src/main.ts

// 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!,
  },
  encryption: {
    key: process.env.SERVER_DEVTOOLS_ENCRYPTION_KEY!,
  },
  getCurrentUser: (req) => req.user,
});

await devtools.start();

// src/main.ts
import express from "express";
import { devtools } from "../server-devtools";

const app = express();
app.use((req, res, next) => devtools.middleware(req, res, next));

app.get("/users/:id", async (req, res) => {
  res.json({ id: req.params.id, name: "John Doe" });
});

app.listen(3000);

tsx watch --import ./server-devtools.ts src/main.ts

// server-devtools.js
const ServerDevTools = require("server-devtools");
const devtools = new ServerDevTools({
  auth: {
    username: process.env.SERVER_DEVTOOLS_USERNAME,
    password: process.env.SERVER_DEVTOOLS_PASSWORD,
  },
  encryption: {
    key: process.env.SERVER_DEVTOOLS_ENCRYPTION_KEY,
  },
  getCurrentUser: (req) => req.user,
});
globalThis.__serverDevtools = devtools;

void (async () => {
  await devtools.start();
})();

// tsconfig.json
{
  "compilerOptions": {
    "allowJs": true
  }
}

NODE_OPTIONS='--import ./server-devtools.js' nest start --watch

// src/main.ts
import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";
import { ServerDevToolsNestInterceptor } from "server-devtools/nestjs";
import ServerDevTools from "server-devtools";

declare global {
  var __serverDevtools: ServerDevTools | undefined;
}

async function bootstrap() {
  const devtools = globalThis.__serverDevtools;
  if (!devtools) {
    throw new Error(
      "ServerDevTools was not preloaded. Start Nest with NODE_OPTIONS='--import ./server-devtools.js'.",
    );
  }

  const app = await NestFactory.create(AppModule);
  app.use((req, res, next) => devtools.middleware(req, res, next));
  app.useGlobalInterceptors(
    new ServerDevToolsNestInterceptor(),
  );
  await app.listen(3000);
}

bootstrap();

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.

Express + TypeScript

Minimal Express + TypeScript integration with ServerDevTools.

View Example open_in_new

NestJS

Minimal NestJS integration with the recommended ServerDevTools preload setup.

View Example open_in_new

Workflow Shift

Stop digging through terminal logs.

When an endpoint fails or slows down, see the HTTP request, full execution path, database queries, 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 and outbound HTTP activity in context
✓ Review request timing and associated errors

Request activity in one dashboard

Coming next

More visibility, more control.

Planned capabilities, not available yet:

Redis visibility

Trace Redis operations alongside the rest of a request.

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

Read Documentation Star on GitHub