backend-performance

Audit Node.js/TypeScript backends for performance bottlenecks and optimizations.

Updated Jan 22, 2026
One-click install
npx skills add https://github.com/jorgeochipinti97/dublin-skills --skill backend-performance-jorgeochipinti97
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-performance
Source: https://github.com/jorgeochipinti97/dublin-skills/tree/main/skills/backend/backend-performance
Command: npx skills add https://github.com/jorgeochipinti97/dublin-skills --skill backend-performance-jorgeochipinti97

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Backend performance is a chronic risk in Node.js/TypeScript services; this Skill provides a structured audit to identify bottlenecks and guide fixes.

Core Features & Use Cases

  • Audit workflow covering Queries, Async & I/O, Caching, Connection pooling, Payload & Serialization, and Observability.
  • Applies to NestJS / Fastify / Express apps using a PostgreSQL-first stack; produces actionable improvements and instrumentation plans.
  • Use cases include post-implementation reviews where teams need deterministic guidance to reduce latency, increase throughput, and improve reliability.

Quick Start

Run the backend-performance audit after API code is ready to surface concrete bottlenecks and optimization steps for the team.

Frequently Asked Questions about backend-performance

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify performance bottlenecks in a Node.js backend?

Reduce API latency in NestJS or Fastify by auditing async I/O operations, optimizing connection pooling, and improving payload serialization. The post-implementation review workflow targets these areas specifically to increase throughput and improve overall service reliability.

What is the best way to audit PostgreSQL query performance in a Node 20+ application?

Auditing PostgreSQL query performance in a Node 20+ application involves reviewing connection pooling configurations and query execution plans within a PostgreSQL-first stack. The audit workflow provides deterministic guidance to fix slow queries and instrument observability gaps across your TypeScript codebase.

Does backend performance tuning work with Express and a PostgreSQL-first stack?

Backend performance tuning works with Express and a PostgreSQL-first stack by applying a structured audit to code authored with Node 20+. It evaluates caching strategies, connection pooling, and observability to produce actionable improvements for reducing latency and increasing throughput.

When do I need to run a backend performance audit on my TypeScript service?

Run a backend performance audit on your TypeScript service during post-implementation reviews when latency, throughput, or observability gaps become apparent. It enforces a deterministic workflow to guide fixes and instrumentation across Node.js backends using PostgreSQL.

Why does my Node.js backend experience throughput drops under heavy load?

Node.js backends experience throughput drops under heavy load due to unoptimized connection pooling, inefficient async I/O handling, or missing caching layers. A structured performance audit identifies these specific bottlenecks and provides an instrumentation plan to improve reliability.