1// Node.js Performance Profiling Setup
2 
3// 1. Enable V8 CPU profiler (development/staging)
4// node --prof server.js
5// node --prof-process isolate-*.log > profile.txt
6 
7// 2. In-process profiling for specific operations
8import { Session } from 'inspector';
9import fs from 'fs';
10 
11async function profileFunction<T>(name: string, fn: () => Promise<T>): Promise<T> {
12  const session = new Session();
13  session.connect();
14 
15  await new Promise<void>(resolve =>
16    session.post('Profiler.enable', () => resolve())
17  );
18  await new Promise<void>(resolve =>
19    session.post('Profiler.start', () => resolve())
20  );
21 
22  const result = await fn();
23 
24  const profile = await new Promise<object>((resolve) =>
25    session.post('Profiler.stop', (err, { profile }) => resolve(profile))
26  );
27 
28  fs.writeFileSync(`profile-${name}-${Date.now()}.cpuprofile`, JSON.stringify(profile));
29  session.disconnect();
30  console.log(`Profile saved. Open in Chrome DevTools > Performance`);
31  return result;
32}
33 
34// 3. PostgreSQL query analysis
35// Find the 10 most expensive queries (by total time)
36const expensiveQueries = await db.execute(sql`
37  SELECT
38    query,
39    calls,
Focus on total_exec_time (= calls × avg_ms) — a fast query called 1M times is a bottleneck
40    mean_exec_time::numeric(10,2) AS avg_ms,
41    total_exec_time::numeric(10,2) AS total_ms,
42    (total_exec_time / sum(total_exec_time) OVER ()) * 100 AS pct_total
43  FROM pg_stat_statements
44  ORDER BY total_exec_time DESC
Log heap before/after load test — growing heap indicates a memory leak
45  LIMIT 10
46`);
47// Focus optimization on queries with highest total_ms (calls × avg_ms)
48 
49// 4. Memory leak detection script
50import v8 from 'v8';
51function logHeapUsage(label: string) {
52  const stats = v8.getHeapStatistics();
53  console.log(`[${label}] heap used: ${(stats.used_heap_size / 1024 / 1024).toFixed(1)} MB`);
54}

1-- ✅ EXPLAIN ANALYZE: understand your query plan
2EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
3SELECT o.id, o.total, u.email
4FROM orders o
5JOIN users u ON u.id = o.user_id
6WHERE o.status = 'pending'
7  AND o.created_at > NOW() - INTERVAL '7 days'
8ORDER BY o.created_at DESC
9LIMIT 100;
10 
11-- Look for in the output:
12-- ❌ Seq Scan → add an index
13-- ❌ Nested Loop with large row estimates → consider Hash Join hint
14-- ✅ Index Scan → index is being used
15-- ✅ Buffers: hit=1000, read=0 → data in memory (good)
16 
17-- ✅ Composite index for this query pattern
18CREATE INDEX CONCURRENTLY idx_orders_status_created
CONCURRENTLY: add index without locking the table for writes
19  ON orders(status, created_at DESC)
20  WHERE status = 'pending';  -- Partial index: only pending orders
21 
22-- ✅ Materialized view for expensive dashboard aggregation
23CREATE MATERIALIZED VIEW daily_revenue_by_region AS
Materialized view turns a 10-second query into a 1ms lookup
24SELECT
25  DATE_TRUNC('day', created_at) AS day,
26  region,
27  SUM(total) AS revenue,
28  COUNT(*) AS order_count
29FROM orders
30WHERE status = 'completed'
31GROUP BY 1, 2
32WITH DATA;
33 
CONCURRENTLY: refresh without locking reads (but requires unique index)
34CREATE INDEX ON daily_revenue_by_region(day, region);
35 
36-- Refresh in background (non-blocking for reads, blocking for writes during refresh)
37REFRESH MATERIALIZED VIEW CONCURRENTLY daily_revenue_by_region;
38 
39-- ✅ pg_stat_statements: find slow queries
40SELECT query, calls, mean_exec_time, total_exec_time
41FROM pg_stat_statements
42WHERE mean_exec_time > 100  -- Queries averaging > 100ms
43ORDER BY total_exec_time DESC
44LIMIT 20;

1// ✅ Bundle optimization: tree-shakeable imports
2// ❌ Bad: imports entire lodash (72KB gzipped)
Importing all of lodash adds 72KB gzipped to your bundle
3import _ from 'lodash';
4const debounced = _.debounce(fn, 300);
5 
6// ✅ Good: import only what you need (1KB)
7import debounce from 'lodash/debounce';
8const debounced = debounce(fn, 300);
9 
10// ✅ Even better: use native or lighter alternatives
11const debounced = (fn: Function, delay: number) => {
12  let timer: NodeJS.Timeout;
13  return (...args: unknown[]) => {
14    clearTimeout(timer);
15    timer = setTimeout(() => fn(...args), delay);
16  };
17};
18 
19// ✅ Image optimization in Next.js
20import Image from 'next/image';
21 
22function HeroBanner() {
23  return (
24    <Image
priority=true adds <link rel="preload"> — critical for LCP images
25      src="/hero.jpg"
26      alt="Hero banner"
27      width={1200}
28      height={600}
29      priority            // Preload: above-the-fold critical image
30      placeholder="blur"  // Show blurred placeholder while loading
31      quality={85}        // WebP, 85% quality — good balance
32    />
33  );
34}
35 
36// ✅ Measure Core Web Vitals in production
37import { onLCP, onINP, onCLS } from 'web-vitals';
Measure real user performance — lab metrics (Lighthouse) often disagree with field data
38 
39function reportWebVitals(metric: Metric) {
40  // Send to your analytics
41  fetch('/api/metrics', {
42    method: 'POST',
43    body: JSON.stringify({
44      name: metric.name,
45      value: metric.value,
46      rating: metric.rating, // 'good' | 'needs-improvement' | 'poor'
47      url: window.location.href,
48    }),
49  });
50}
51 
52onLCP(reportWebVitals);
53onINP(reportWebVitals);
54onCLS(reportWebVitals);