Performance Engineer

Performance Engineer

Specialist in analyzing and optimizing application performance, identifying bottlenecks, and implementing efficiency improvements.

When This Skill Activates

Activates when you:

• Report performance issues
• Need performance optimization
• Mention "slow" or "latency"
• Want to improve efficiency

Performance Analysis Process

Phase 1: Identify the Problem

1. Define metrics

   • What's the baseline?
   • What's the target?
   • What's acceptable?

2. Measure current performance

   bashCopy code
   # Response time
   curl -w "@curl-format.txt" -o /dev/null -s https://example.com/users
   
   # Database query time
   # Add timing logs to queries
   
   # Memory usage
   # Use profiler
   

3. Profile the application

   bashCopy code
   # Node.js
   node --prof app.js
   
   # Python
   python -m cProfile app.py
   
   # Go
   go test -cpuprofile=cpu.prof
   

Phase 2: Find the Bottleneck

Common bottleneck locations:

Phase 3: Optimize

Database Optimization

N+1 Queries:

typescriptCopy code
// Bad: N+1 queries
const users = await User.findAll();
for (const user of users) {
  user.posts = await Post.findAll({ where: { userId: user.id } });
}

// Good: Eager loading
const users = await User.findAll({
  include: [{ model: Post, as: 'posts' }]
});

Missing Indexes:

sqlCopy code
-- Add index on frequently queried columns
CREATE INDEX idx_user_email ON users(email);
CREATE INDEX idx_post_user_id ON posts(user_id);

API Optimization

Pagination:

typescriptCopy code
// Always paginate large result sets
const users = await User.findAll({
  limit: 100,
  offset: page * 100
});

Field Selection:

typescriptCopy code
// Select only needed fields
const users = await User.findAll({
  attributes: ['id', 'name', 'email']
});

Compression:

typescriptCopy code
// Enable gzip compression
app.use(compression());

Frontend Optimization

Code Splitting:

typescriptCopy code
// Lazy load routes
const Dashboard = lazy(() => import('./Dashboard'));

Memoization:

typescriptCopy code
// Use useMemo for expensive calculations
const filtered = useMemo(() =>
  items.filter(item => item.active),
  [items]
);

Image Optimization:

• Use WebP format
• Lazy load images
• Use responsive images
• Compress images

Phase 4: Verify

1. Measure again
2. Compare to baseline
3. Ensure no regressions
4. Document the improvement

Performance Targets

Derive targets from the service SLO, current baseline, workload shape, cost budget, and critical user journey. The table below is an example starting point only; never present it as the system's acceptance criteria without evidence or owner agreement.

Common Optimizations

Caching Strategy

typescriptCopy code
// Cache expensive computations
const cache = new Map();

async function getUserStats(userId: string) {
  if (cache.has(userId)) {
    return cache.get(userId);
  }

  const stats = await calculateUserStats(userId);
  cache.set(userId, stats);

  // Invalidate after 5 minutes
  setTimeout(() => cache.delete(userId), 5 * 60 * 1000);

  return stats;
}

Batch Processing

typescriptCopy code
// Bad: Individual requests
for (const id of userIds) {
  await fetchUser(id);
}

// Good: Batch request
await fetchUsers(userIds);

Debouncing/Throttling

typescriptCopy code
// Debounce search input
const debouncedSearch = debounce(search, 300);

// Throttle scroll events
const throttledScroll = throttle(handleScroll, 100);

Performance Monitoring

Key Metrics

• Response Time: Time to process request
• Throughput: Requests per second
• Error Rate: Failed requests percentage
• Memory Usage: Heap/RAM used
• CPU Usage: Processor utilization

Monitoring Tools

Scripts

Profile application:

bashCopy code
python3 scripts/profile.py --name <service-name> --output perf-profile.txt

Generate performance report:

bashCopy code
python3 scripts/perf_report.py --name <service-name> --output perf-report.md

References

• references/optimization.md - Optimization techniques
• references/monitoring.md - Monitoring setup
• references/checklist.md - Performance checklist