Performance
Profiling, load testing and making software faster or leaner.
Download all 23
- Fix N+1 queries
Finds N+1 database queries behind an endpoint, page or job by counting real queries, fixes them with eager loading or batching, and adds a query-count test so they do not return.
- Profile and speed up a hot path
Measures a slow operation, profiles where the time goes, and makes it faster one verified change at a time, with before-and-after numbers. Use when an endpoint, command or function is too slow.
- Reduce JavaScript bundle size
Measures a web app's JavaScript bundles, finds the largest avoidable contributors, and shrinks them with verified changes ranked by bytes saved. Use when page load is slow or a size budget is blown.
- Analyse load test results
Interprets k6, JMeter, Locust or Gatling results, finding the knee where latency climbs, separating load-generator limits from server saturation, and judging the pass criteria.
- Find a memory leak
Finds a memory leak from heap snapshots, memory metrics and code, naming the retaining path and the minimal fix with a regression check. Use when memory grows until a process is killed or restarted.
- Fix slow or excessive React re-renders
Finds why React components re-render too often or render slowly, measures before changing anything, then fixes the cause with state changes or targeted memoisation. Use when a React UI feels laggy.
- Hit a game frame budget
Diagnoses frame drops against a 16.6 or 33.3 ms budget from profiler captures, separating CPU from GPU bound, and ranks fixes by milliseconds saved per effort. Use before shipping on weak hardware.
- Hot path performance rules
Standing rules for code on latency-sensitive paths covering no queries in loops, bounded result sets and allocations, timeouts on remote calls, and measuring before and after any optimisation.
- Improve an algorithm's time or space complexity
Analyses the time and space complexity of a piece of code on realistic input sizes, finds a better algorithm or data structure, and proves the gain with a benchmark and tests.
- Improve Core Web Vitals
Diagnoses poor Core Web Vitals (LCP, INP, CLS) from a Lighthouse, field-data or trace report and ranks fixes by expected improvement. Use when a page fails the vitals thresholds.
- Optimise a slow SQL query
Speeds up a slow SQL query from its execution plan, proposing rewrites and indexes with expected gains and their write-cost trade-offs. Use when one query dominates latency or database load.
- Performance engineer
Acts as a performance engineer who profiles before optimising, changes one thing at a time and reports gains with numbers and variance. Use for latency, throughput or memory work.
- Performance investigation track
Takes a vague "it is slow" complaint through gated steps, from metric and target to baseline, profile, one hypothesis at a time, fix and a verified write-up. Use when handed a slowness report.
- Plan a caching strategy
Designs caching for a slow path, covering what to cache at which layer, keys, TTLs, invalidation, stampede protection and measuring hit rate and staleness. Use when fixing latency or database load.
- Plan a load test
Designs a load test with a workload model, scenarios, ramp profile and pass or fail thresholds, then writes the script for the chosen tool. Use before a launch, a traffic event or a capacity decision.
- Read a flame graph
Teaches how to read a flame graph or profiler call tree using the learner's own capture, covering width versus height, self versus total time, the widest plateau and what to try next.
- Reduce mobile battery drain
Finds what drains battery in a mobile app (wakelocks, location, polling, background work, radio wake-ups, hidden animation) from energy reports and code, and fixes it with platform APIs.
- Set performance budgets
Sets performance budgets (bundle size, LCP, INP, API p95, startup time, memory) from baseline data and wires them into CI so regressions fail the build with a clear message. Use to stop slow creep.
- Shrink firmware flash and RAM use
Reads a linker map and size report to cut firmware flash and RAM use, from the biggest symbols and pulled-in libraries to stack sizing and flags such as -Os and LTO. Use when out of memory.
- Speed up app cold start
Measures and cuts mobile app cold start by deferring SDK setup, removing main-thread I/O and using baseline profiles, measured on a low-end device. Use when an app is slow to open.
- Speed up dataframe code
Speeds up slow pandas or Polars code by replacing row loops and apply with vectorised operations, fixing dtypes, chunking or pushing work to the database, measured on your data size.
- Tune a garbage collector
Diagnoses GC pauses and memory churn on the JVM, .NET or Go from GC logs and metrics, fixes allocation hotspots first, then chooses collector and heap settings. Use for latency spikes.
- Write a k6 load test
Writes a k6 load test script from a workload model, with arrival-rate scenarios, thresholds that fail the run, test data and tagged metrics. Use when the load plan is settled and you need the script.
Wins over code-review and debugging when speed or resource use is the outcome.