Performance Profiler
Systematic performance profiling for Node.js, Python, and Go applications. Identifies CPU bottlenecks with flamegraphs, detects memory leaks with heap snapshots, analyzes bundle sizes, optimizes database queries, detects N+1 patterns, and runs load tests with k6 and Artillery. Enforces a measure-first methodology: establish baseline, identify bottleneck, fix, and verify improvement.
Golden Rule — Measure First: Profile → Confirm bottleneck → Fix → Measure again → Verify improvement. Every optimization needs baseline metrics, profiler evidence, the fix, post-fix metrics, and a delta. Full rule in references/cpu-and-memory-profiling.md.
Core Capabilities
- CPU profiling — Clinic.js/V8 flamegraphs (Node), py-spy/cProfile/scalene (Python), pprof (Go), Chrome DevTools (browser).
- Memory profiling — heap snapshots and before/after comparison, GC pressure analysis, leak detection, retained object graphs.
- Database optimization — EXPLAIN ANALYZE plan reading, N+1 detection and batching, slow query logs, missing-index identification, connection pool sizing.
- Bundle analysis — webpack/Next.js analyzers, tree-shaking, dynamic imports, heavy dependency identification.
- Load testing — k6 ramp-up scripts, SLA threshold enforcement in CI, P50/P95/P99 latency tracking, concurrent user simulation.
When to Use
- App is slow and you do not know where the bottleneck is.
- P99 latency exceeds SLA before a release.
- Memory usage grows over time (suspected leak).
- Bundle size increased after adding dependencies.
- Preparing for a traffic spike (load test before launch).
- Database queries taking >100ms, or verifying no regressions after a dependency upgrade.
Clarify First
Before profiling, confirm these inputs. If any is unknown or vague, ASK — do not assume:
- [ ] Runtime & symptom — Node / Python / Go and CPU / memory / bundle / query / load-spike (selects the profiler and toolchain)
- [ ] Baseline + SLA target — current numbers and the P95/P99 (or size) threshold to beat (measure-first needs both to verify a delta)
- [ ] Environment — local / staging / prod determines the safe profiling method and whether load testing is allowed
Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the artifact.
Tools
| Tool | Purpose | Command |
|------|---------|---------|
| benchmark_reporter.py | Parse benchmark results and report regressions/improvements vs thresholds | python scripts/benchmark_reporter.py results.json --fail-on-regression |
| bottleneck_detector.py | Analyze logs/traces to flag slow latency, queries, and spans | python scripts/bottleneck_detector.py trace.json --latency-threshold 200 |
| resource_analyzer.py | Analyze CPU/memory/disk usage data and flag anomalies and trends | python scripts/resource_analyzer.py metrics.json --cpu-threshold 80 |
All three accept a file path or - for stdin and support --json.
References
Load the reference that matches the task — keep this file lean and pull detail on demand:
- references/cpu-and-memory-profiling.md — the full Measure-First rule, Node.js CPU profiling (Clinic.js flamegraphs, V8 CPU profiles), and memory leak detection (Node heap snapshots, Python memray/tracemalloc). Read when chasing CPU or memory issues.
- references/database-and-bundle.md — EXPLAIN ANALYZE workflow, N+1 detection patterns and middleware script, Next.js bundle analyzer setup, quick size checks, and the common-bundle-wins table. Read when optimizing queries or bundle size.
- references/load-testing-and-methodology.md — full k6 load-test script, the before/after measurement template, quick-win optimization checklist, common pitfalls, best practices, troubleshooting table, and success criteria. Read when load testing or documenting a win.
Scope & Limitations
This skill covers:
- CPU and memory profiling for Node.js, Python, and Go applications using flamegraphs and heap snapshots
- Database query optimization including EXPLAIN ANALYZE interpretation, N+1 detection, and index recommendations
- Frontend bundle analysis and size reduction strategies for webpack and Next.js projects
- Load testing methodology with k6 including ramp-up patterns, threshold enforcement, and CI integration
This skill does NOT cover:
- Application Performance Monitoring (APM) platform setup and configuration (Datadog, New Relic, Grafana) — see
engineering/observability-designer - Infrastructure-level performance tuning (kernel parameters, network stack, container resource limits) — see
engineering/senior-devops - Security-focused performance concerns such as DDoS mitigation or rate limiting — see
engineering/senior-security - Mobile application profiling (iOS Instruments, Android Profiler) — see
engineering/senior-mobile
Integration Points
| Skill | Integration | Data Flow |
|-------|-------------|-----------|
| engineering/observability-designer | Performance profiling findings feed into observability dashboard design; alerting thresholds derived from profiling baselines | Profiler baselines and SLA thresholds → Prometheus/Grafana alert rules and dashboard panels |
| engineering/ci-cd-pipeline-builder | k6 load tests and bundle size checks integrate as CI pipeline gates | k6 threshold configs and bundle budget scripts → CI pipeline stage definitions |
| engineering/database-designer | Query optimization recommendations inform schema design decisions; index suggestions feed back to schema migrations | EXPLAIN ANALYZE findings and index recommendations → schema migration files and index definitions |
| engineering/senior-backend | Backend architecture decisions incorporate profiling data; connection pool sizing and caching strategies validated by load tests | Profiling reports and load test results → architecture decision records and implementation guidance |
| engineering/tech-debt-tracker | Performance regressions and unresolved bottlenecks are tracked as technical debt items with measured impact | Before/after measurement reports and unresolved findings → tech debt backlog with quantified cost |
| engineering/senior-frontend | Bundle analysis results drive frontend optimization work; code-splitting and lazy-loading decisions backed by profiler data | Bundle analyzer output and Lighthouse scores → frontend optimization tasks and component refactoring plans |