Performance Review Baseline

1.1 Database Queries

1.2 API & Network

1.3 Frontend

1.4 Caching

2. DO / DON'T Examples

N+1 Query Problem

// ❌ DON'T: N+1 — one query per item in loop
const coupons = await Coupon.find({ appInstanceId });
for (const coupon of coupons) {
  coupon.settings = await Settings.findOne({ couponId: coupon._id }); // N queries!
}

// ✅ DO: Single query with $in or $lookup
const coupons = await Coupon.find({ appInstanceId });
const couponIds = coupons.map(c => c._id);
const settings = await Settings.find({ couponId: { $in: couponIds } }); // 1 query
// Map settings to coupons in memory

Unbounded Query

// ❌ DON'T: Fetch ALL records
const allCoupons = await Coupon.find({}); // Could be 100K records!

// ✅ DO: Paginate
const coupons = await Coupon.find({})
  .sort({ createdAt: -1 })
  .skip(page * limit)
  .limit(limit)
  .lean();

Over-fetching

// ❌ DON'T: Return entire document
const settings = await Settings.findOne({ appInstanceId });
res.json(settings); // Includes all internal fields

// ✅ DO: Select only needed fields
const settings = await Settings.findOne({ appInstanceId })
  .select('templateId colors fonts timer coupon')
  .lean();
res.json({ data: settings });

Sync Heavy Operation

// ❌ DON'T: Heavy operation in request path
router.post('/export', async (req, res) => {
  const report = await generatePDFReport(allData); // 30 seconds!
  res.json({ report });
});

// ✅ DO: Offload to async
router.post('/export', async (req, res) => {
  const jobId = await queue.add('generate-report', { userId: req.userId });
  res.status(202).json({ jobId, status: 'processing' }); // Return immediately
});

React Re-renders

// ❌ DON'T: New object/function on every render
function ParentComponent() {
  return <Child style={{ color: 'red' }} onClick={() => doSomething()} />;
  //            ^^ new object every render  ^^ new function every render
}

// ✅ DO: Stable references
const style = useMemo(() => ({ color: 'red' }), []);
const handleClick = useCallback(() => doSomething(), []);
return <Child style={style} onClick={handleClick} />;

3. Latency Targets

API endpoints

Frontend

4. Automated Detection

Grep patterns

# N+1 indicators
grep_search: Query="await.*find"  Includes=["*.js"]  → check if inside loop (for/forEach/map)
grep_search: Query="for.*await"   Includes=["*.js"]  → sequential async in loop

# Unbounded queries
grep_search: Query=".find({" Includes=["*.js"]  → check: has .limit() ?
grep_search: Query=".find()" Includes=["*.js"]  → no filter at all

# Over-fetching
grep_search: Query=".findOne(" Includes=["*.js"]  → check: has .select() ?

# Heavy sync operations
grep_search: Query="readFileSync"  → P1: blocking I/O
grep_search: Query="JSON.parse"    → check: large payloads?

# React performance
grep_search: Query="style={{" Includes=["*.jsx","*.tsx"]  → inline object → re-render
grep_search: Query="() =>" Includes=["*.jsx","*.tsx"]     → inline function in JSX props

Mongoose explain

// Check query plan for slow queries
const explain = await Model.find(query).explain('executionStats');
// Look for: COLLSCAN (no index), nReturned vs totalDocsExamined

5. Output Template

# Performance Review Report

**Scope:** <PR/module>
**Reviewer:** Reviewer Agent
**Date:** YYYY-MM-DD

## Findings

| # | Severity | Category | File:Line | Finding | Impact | Fix |
|---|----------|----------|-----------|---------|--------|-----|
| 1 | 🔴 P0 | N+1 | `services/coupon.js:45` | DB query inside for loop | 100 coupons = 100 queries | Use `$in` batch query |
| 2 | 🔴 P0 | Unbounded | `routes/coupons.js:12` | `Coupon.find({})` without limit | Memory spike on large datasets | Add pagination |
| 3 | 🟠 P1 | Over-fetch | `controllers/settings.js:8` | No `.select()` | 40 fields returned, 5 needed | Add `.select().lean()` |

## Latency Check
| Endpoint | Current p95 | Target p95 | Status |
|----------|:-----------:|:----------:|:------:|
| GET /widget/:id | ~30ms | 50ms | ✅ |
| GET /coupons | ~800ms | 100ms | ❌ PERF-01 |

## Checklist Summary
- P0: X findings (blocking SLA/UX)
- P1: Y findings (should fix)
- P2: Z findings (optimization opportunities)

## Verdict
- ✅ PASS — no bottlenecks
- ⚠️ OPTIMIZATION NEEDED — P0/P1 findings
- ❌ BLOCKED — critical performance issue breaking SLA

See also

• $observability-plan — latency targets, metrics
• $observability-review — logging/metrics compliance
• $data-model — index strategy
• $review-reference-snippets — general DO/DON'T examples