Share

Modern Node.js development no longer happens across isolated tools.

As developers, we no longer just write code. We constantly move between terminals, logs, dashboards, cloud platforms, tracing suites, CI pipelines, browser tools, and production environments to understand what our applications are doing.

For years, that fragmented workflow became normal.

But modern IDEs are changing that.

Today, AI assistants live directly inside VS Code. We have integrated terminals, embedded browsers, Git tools, deployment workflows, debugging panels, and copilots all within the same development environment. Engineering workflows are becoming increasingly centralized around the IDE itself.

And yet, one critical piece still remains disconnected from where developers actually work: production runtime visibility.

Developers can ask AI to explain code, generate functions, refactor applications, and even troubleshoot errors directly inside the editor — but understanding what is happening inside a live Node.js runtime still often requires switching to external dashboards and observability platforms that lack direct coding context.

Things like:

• Event loop behavior
• CPU bottlenecks
• Runtime diagnostics
• Production telemetry
• Memory analysis
• Async performance issues

still typically live outside the IDE.

At NodeSource, we believe that workflow no longer makes sense for modern Node.js engineering.

That’s why we built N|Solid in the IDE: a VS Code extension designed to bring production-aware runtime visibility directly into the development workflow, without forcing developers to constantly leave their editor just to understand what their applications are doing.

But this shift is bigger than simply embedding observability into VS Code.

It’s about rethinking what modern engineering workflows should look like when runtime telemetry, security analysis, profiling, and AI-assisted investigation all exist inside the same environment where code is written.

Imagine a developer investigating a production issue.

Instead of switching between external dashboards, browser tabs, terminals, screenshots, and monitoring platforms, the investigation can begin directly inside the IDE itself.

A security audit can immediately expose:

• Vulnerable dependencies
• Malicious packages
• Transitive dependency risks
• License issues
• Suspicious supply-chain signals

without leaving VS Code.

Here’s an example of a security audit report generated directly inside VS Code using N|Solid in the IDE:

At the same time, developers can inspect runtime assets, open CPU profiles, analyze event loop behavior, review stack activity, and investigate performance bottlenecks directly alongside the application code they are actively editing.

And because modern IDEs are increasingly AI-native, that runtime context can now be combined with AI-assisted investigation workflows.

Instead of asking AI to reason only about static source code, developers can investigate real runtime behavior by:

• Understanding why a service becomes unstable under load
• Identifying async bottlenecks
• Inspecting suspicious execution paths
• Analyzing memory pressure
• Correlating telemetry with actual application structure

all from within the same development workflow.

The result is not simply “observability inside the IDE.”

It’s a tighter feedback loop between production behavior, runtime intelligence, AI-assisted analysis, and engineering decisions.

And that fundamentally changes how Node.js debugging works.

The IDE is no longer just a place to write code.

It becomes a centralized engineering environment where developers can:

• Inspect runtime behavior
• Investigate production issues
• Analyze security risks
• Inspect performance assets
• Interact with AI-assisted tooling
• Make engineering decisions with readily available runtime context

all without fragmenting the development workflow.

If you want to explore this workflow yourself, you can start using N|Solid in the IDE today.

Install N|Solid in the IDE for VS Code:
https://marketplace.visualstudio.com/items?itemName=nodesource-inc.nsolid&ssr=false#overview

N|Solid in the IDE is a VS Code extension for Node.js monitoring, diagnostics, security analysis, and AI-assisted runtime insights powered by NodeSource.

Modern Node.js engineering is becoming increasingly runtime-aware, AI-assisted, and IDE-native.

And this is only the beginning.