performance-optimization – skill Thiết kế & UI cho agent AI

Performance Optimization

Overview

Measure before optimizing. Performance work without measurement is guessing — and guessing leads to premature optimization that adds complexity without improving what matters. Profile first, identify the actual bottleneck, fix it, measure again. Optimize only what measurements prove matters.

When to Use

• Performance requirements exist in the spec (load time budgets, response time SLAs)
• Users or monitoring report slow behavior
• Core Web Vitals scores are below thresholds
• You suspect a change introduced a regression
• Building features that handle large datasets or high traffic

When NOT to use: Don't optimize before you have evidence of a problem. Premature optimization adds complexity that costs more than the performance it gains.

Core Web Vitals Targets

| Metric | Good | Needs Improvement | Poor |

|--------|------|-------------------|------|

| LCP (Largest Contentful Paint) | ≤ 2.5s | ≤ 4.0s | > 4.0s |

| INP (Interaction to Next Paint) | ≤ 200ms | ≤ 500ms | > 500ms |

| CLS (Cumulative Layout Shift) | ≤ 0.1 | ≤ 0.25 | > 0.25 |

The Optimization Workflow

1. MEASURE  → Establish baseline with real data
2. IDENTIFY → Find the actual bottleneck (not assumed)
3. FIX      → Address the specific bottleneck
4. VERIFY   → Measure again; keep or revert
5. GUARD    → Add monitoring or tests to prevent regression

Step 1: Measure

Two complementary approaches — use both:

• Synthetic (Lighthouse, DevTools Performance tab): Controlled conditions, reproducible. Best for CI regression detection and isolating specific issues.
• RUM (web-vitals library, CrUX): Real user data in real conditions. Required to validate that a fix actually improved user experience.

Frontend:

// Synthetic: Lighthouse in Chrome DevTools (or CI)
// Chrome DevTools → Performance tab → Record
// Chrome DevTools MCP → Performance trace

// RUM: Web Vitals library in code
import { onLCP, onINP, onCLS } from 'web-vitals';

onLCP(console.log);
onINP(console.log);
onCLS(console.log);

Backend:

// Response time logging
// Application Performance Monitoring (APM)
// Database query logging with timing

// Simple timing
console.time('db-query');
const result = await db.query(...);
console.timeEnd('db-query');

Where to Start Measuring

Use the symptom to decide what to measure first:

What is slow?
├── First page load
│   ├── Large bundle? --> Measure bundle size, check code splitting
│   ├── Slow server response? --> Measure TTFB in DevTools Network waterfall
│   │   ├── DNS long? --> Add dns-prefetch / preconnect for known origins
│   │   ├── TCP/TLS long? --> Enable HTTP/2, check edge deployment, keep-alive
│   │   └── Waiting (server) long? --> Profile backend, check queries and caching
│   └── Render-blocking resources? --> Check network waterfall for CSS/JS blocking
├── Interaction feels sluggish
│   ├── UI freezes on click? --> Profile main thread, look for long tasks (>50ms)
│   ├── Form input lag? --> Check re-renders, controlled component overhead
│   └── Animation jank? --> Check layout thrashing, forced reflows
├── Page after navigation
│   ├── Data loading? --> Measure API response times, check for waterfalls
│   └── Client rendering? --> Profile component render time, check for N+1 fetches
└── Backend / API
    ├── Single endpoint slow? --> Profile database queries, check indexes
    ├── All endpoints slow? --> Check connection pool, memory, CPU
    └── Intermittent slowness? --> Check for lock contention, GC pauses, external deps

Step 2: Identify the Bottleneck

Common bottlenecks by category:

Frontend:

| Symptom | Likely Cause | Investigation |

|---------|-------------|---------------|

| Slow LCP | Large images, render-blocking resources, slow server | Check network waterfall, image sizes |

| High CLS | Images without dimensions, late-loading content, font shifts | Check layout shift attribution |

| Poor INP | Heavy JavaScript on main thread, large DOM updates | Check long tasks in Performance trace |

| Slow initial load | Large bundle, many network requests | Check bundle size, code splitting |

Backend:

| Symptom | Likely Cause | Investigation |

|---------|-------------|---------------|

| Slow API responses | N+1 queries, missing indexes, unoptimized queries | Check database query log |

| Memory growth | Leaked references, unbounded caches, large payloads | Heap snapshot analysis |

| CPU spikes | Synchronous heavy computation, regex backtracking | CPU profiling |

| High latency | Missing caching, redundant computation, network hops | Trace requests through the stack |

Step 3: Fix the Bottleneck

Fix the one thing Step 2 identified, nothing else. The anti-patterns below are the usual suspects; each entry gives the rule and the signature to recognize it, and links to a worked fix in [references/optimization-patterns.md](references/optimization-patterns.md). Open the one you need when you reach that code, not before.

Backend

• N+1 queries. One query per row is the most common backend bottleneck. Fetch the relation in the same query (join/include) instead of in the loop. [Pattern](references/optimization-patterns.md#n1-queries-backend).
• Unbounded data fetching. Every list endpoint paginates with a limit and a stable order. [Pattern](references/optimization-patterns.md#unbounded-data-fetching).
• Queries that ignore their index. "Add an index" is the guess; EXPLAIN ANALYZE is the measurement. A Seq Scan where you expected an index, a rows= estimate off by an order of magnitude, and a Sort node above the scan each call for a different fix; a bad rows= estimate means stale statistics, so run ANALYZE rather than adding an index. Index for the shape of the query (equality columns first, then the range or sort column). A plain index will not help a query on a low-selectivity dominant value (a partial index serves the rare value), a leading wildcard (needs trigram or full-text), or a function applied to the column (index the expression, as in WHERE lower(email) = ?), and every index taxes every write. Re-run the plan afterwards; an index that did not change it is a revert. [Pattern](references/optimization-patterns.md#queries-that-ignore-their-index).
• Connection pool exhaustion. Signature: *every* endpoint slows at once, time is spent waiting for a connection rather than executing, and the database shows mostly idle sessions. One pool per process, sized so instances × max stays under the database's connection ceiling. Bigger is not faster; it relocates the queue to the database where it is harder to see. With unbounded instance counts (serverless, autoscaling), multiplex through a proxy (pgbouncer, RDS Proxy) instead of raising max. [Pattern](references/optimization-patterns.md#connection-pool-exhaustion).
• Missing caching. Cache what is expensive to produce and read far more often than it changes; caching an already-fast query adds a network hop and a staleness bug in exchange for nothing. Pick the layer deliberately (in-process, shared, CDN). Every input that changes the response belongs in the key (tenant, locale, permissions, feature flags): a key that omits the viewer is how one user's data gets served to another. Choose one invalidation strategy (TTL, event or tag based, versioned keys) and state the acceptable staleness window explicitly. Guard hot keys against the stampede: serve stale while one request recomputes, or coalesce concurrent misses behind a single in-flight promise. Never cache what must be fresh (balances, permissions, inventory at checkout). [Pattern](references/optimization-patterns.md#missing-caching-backend); request coalescing, write strategies, and negative caching in ../../references/performance-checklist.md.

Frontend

• Missing image optimization. Every image declares width and height (CLS). The LCP image gets fetchpriority="high", modern formats (AVIF, WebP) through <picture>, and srcset/sizes for resolution switching; below-the-fold images get loading="lazy" and decoding="async". [Pattern](references/optimization-patterns.md#missing-image-optimization-frontend).
• Unnecessary re-renders. An object or function created in render is a new reference every time and re-renders every child that receives it. Hoist constants; reserve React.memo and useMemo for work the profile shows is expensive, since overuse is its own cost. [Pattern](references/optimization-patterns.md#unnecessary-re-renders-react).
• Large bundle size. Modern bundlers tree-shake ESM named imports on their own; the real gains are route-level code splitting and lazy-loading heavy, rarely-used features behind Suspense. Profile before changing import styles. [Pattern](references/optimization-patterns.md#large-bundle-size).

Step 4: Verify (Keep or Revert)

A fix is a hypothesis until you re-measure. This step decides whe

… (nội dung đầy đủ có trong gói tải về)