performance-optimization

# 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');

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

// BAD: N+1 — one query per task for the owner
const tasks = await db.tasks.findMany()
for (const task of tasks) {
  task.owner = await db.users.findUnique({where: {id: task.ownerId}})
}
 
// GOOD: Single query with join/include
const tasks = await db.tasks.findMany({
  include: {owner: true},
})

// BAD: Fetching all records
const allTasks = await db.tasks.findMany()
 
// GOOD: Paginated with limits
const tasks = await db.tasks.findMany({
  take: 20,
  skip: (page - 1) * 20,
  orderBy: {createdAt: 'desc'},
})

<!-- BAD: No dimensions, no format optimization -->
<img src="/hero.jpg" />
 
<!-- GOOD: Hero / LCP image — art direction + resolution switching, high priority -->
<!--
  Two techniques combined:
  - Art direction (media): different crop/composition per breakpoint
  - Resolution switching (srcset + sizes): right file size per screen density
-->
<picture>
  <!-- Mobile: portrait crop (8:10) -->
  <source
    media="(max-width: 767px)"
    srcset="/hero-mobile-400.avif 400w, /hero-mobile-800.avif 800w"
    sizes="100vw"
    width="800"
    height="1000"
    type="image/avif"
  />
  <source
    media="(max-width: 767px)"
    srcset="/hero-mobile-400.webp 400w, /hero-mobile-800.webp 800w"
    sizes="100vw"
    width="800"
    height="1000"
    type="image/webp"
  />
  <!-- Desktop: landscape crop (2:1) -->
  <source
    srcset="/hero-800.avif 800w, /hero-1200.avif 1200w, /hero-1600.avif 1600w"
    sizes="(max-width: 1200px) 100vw, 1200px"
    width="1200"
    height="600"
    type="image/avif"
  />
  <source
    srcset="/hero-800.webp 800w, /hero-1200.webp 1200w, /hero-1600.webp 1600w"
    sizes="(max-width: 1200px) 100vw, 1200px"
    width="1200"
    height="600"
    type="image/webp"
  />
  <img
    src="/hero-desktop.jpg"
    width="1200"
    height="600"
    fetchpriority="high"
    alt="Hero image description"
  />
</picture>
 
<!-- GOOD: Below-the-fold image — lazy loaded + async decoding -->
<img
  src="/content.webp"
  width="800"
  height="400"
  loading="lazy"
  decoding="async"
  alt="Content image description"
/>

// BAD: Creates new object on every render, causing children to re-render
function TaskList() {
  return <TaskFilters options={{sortBy: 'date', order: 'desc'}} />
}
 
// GOOD: Stable reference
const DEFAULT_OPTIONS = {sortBy: 'date', order: 'desc'} as const
function TaskList() {
  return <TaskFilters options={DEFAULT_OPTIONS} />
}
 
// Use React.memo for expensive components
const TaskItem = React.memo(function TaskItem({task}: Props) {
  return <div>{/* expensive render */}</div>
})
 
// Use useMemo for expensive computations
function TaskStats({tasks}: Props) {
  const stats = useMemo(() => calculateStats(tasks), [tasks])
  return (
    <div>
      {stats.completed} / {stats.total}
    </div>
  )
}

// Modern bundlers (Vite, webpack 5+) handle named imports with tree-shaking automatically,
// provided the dependency ships ESM and is marked `sideEffects: false` in package.json.
// Profile before changing import styles — the real gains come from splitting and lazy loading.
 
// GOOD: Dynamic import for heavy, rarely-used features
const ChartLibrary = lazy(() => import('./ChartLibrary'));
 
// GOOD: Route-level code splitting wrapped in Suspense
const SettingsPage = lazy(() => import('./pages/Settings'));
 
function App() {
  return (
    <Suspense fallback={<Spinner />}>
      <SettingsPage />
    </Suspense>
  );
}

// Cache frequently-read, rarely-changed data
const CACHE_TTL = 5 * 60 * 1000 // 5 minutes
let cachedConfig: AppConfig | null = null
let cacheExpiry = 0
 
async function getAppConfig(): Promise<AppConfig> {
  if (cachedConfig && Date.now() < cacheExpiry) {
    return cachedConfig
  }
  cachedConfig = await db.config.findFirst()
  cacheExpiry = Date.now() + CACHE_TTL
  return cachedConfig
}
 
// HTTP caching headers for static assets
app.use(
  '/static',
  express.static('public', {
    maxAge: '1y', // Cache for 1 year
    immutable: true, // Never revalidate (use content hashing in filenames)
  }),
)
 
// Cache-Control for API responses
res.set('Cache-Control', 'public, max-age=300') // 5 minutes

JavaScript bundle: < 200KB gzipped (initial load)
CSS: < 50KB gzipped
Images: < 200KB per image (above the fold)
Fonts: < 100KB total
API response time: < 200ms (p95)
Time to Interactive: < 3.5s on 4G
Lighthouse Performance score: ≥ 90

# Bundle size check
npx bundlesize --config bundlesize.config.json
 
# Lighthouse CI
npx lhci autorun