Performance
Profiling, load testing and making software faster or leaner.
Download all 90
- 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.
- Compare benchmark runs
Decides whether the difference between two sets of benchmark or performance-test results is real or noise, from spread, run counts, distribution shape and setup, and says what would settle it.
- Diagnose a CPU spike in production
Finds what a production process is doing when CPU spikes or stays pinned, with safe sampling profilers and thread and throttling metrics, separating hot code from GC, retry storms and throttling.
- Find lock contention
Finds where threads wait on locks when throughput stops scaling with cores or concurrency, using lock profiles and thread dumps, then shrinks or splits critical sections with before-and-after numbers.
- 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 excess Compose recomposition
Finds excess Jetpack Compose recompositions with Layout Inspector counts and compiler stability reports, then fixes unstable types, early state reads, lambdas and missing keys.
- Fix event loop blocking
Finds synchronous or CPU-heavy work that blocks a Node.js or Python asyncio event loop and makes every request slow at once, measures loop delay, and moves the work off the loop.
- Fix janky web animation and scrolling
Fixes stuttering web animations, transitions and scroll effects by moving to compositor-only properties and removing forced layouts and heavy paints, verified frame by frame.
- Fix scroll jank in a mobile list
Finds why scrolling a list stutters on Android, iOS or cross-platform apps from frame timing and traces on a low-end device, and fixes cell binding, image decoding, layout and recycling.
- 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.
- Fix slow Vue rendering
Fixes slow Vue 3 or Nuxt rendering caused by deep reactivity on large data, unstable props, missing keys, template method calls, deep watchers and heavy hydration.
- 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.
- Inline critical CSS and drop unused CSS
Stops stylesheets from blocking first paint by inlining above-the-fold CSS, loading the rest without blocking, and removing unused rules, measured by FCP and LCP.
- Investigate a performance regression between releases
Finds why a new release is slower by confirming the slowdown is real, comparing profiles and metrics between versions, and narrowing it to the commit and code responsible.
- Speed up Elasticsearch searches and indexing
Speeds up slow Elasticsearch or OpenSearch searches and indexing with query rewrites, mapping fixes, filter context, shard sizing and bulk settings, using the profile API and node stats.
- Optimise a site's images
Sets up responsive, modern-format, correctly sized and correctly lazy-loaded images through an image CDN, framework component or build step, measured in bytes saved and LCP.
- Raise Kafka consumer throughput and cut lag
Raises Kafka consumer throughput and cuts lag by measuring where time goes, then tuning fetch and poll settings, batching, commits, partition counts and in-partition parallelism without losing order.
- Optimize slow MongoDB queries
Speeds up slow MongoDB finds and aggregations from explain output, with compound indexes in equality-sort-range order, projections and schema changes, verified by docs examined.
- 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.
- Speed up SQLite in an app
Speeds up slow SQLite reads and writes in a mobile, desktop or CLI app by batching writes in transactions, adding indexes from EXPLAIN QUERY PLAN and moving queries off the UI thread.
- Optimise web font loading
Cuts web font cost with WOFF2, subsetting, fewer files, targeted preloads, font-display and metric-matched fallbacks so text appears fast without layout shift.
- Parallelize a slow Python job
Picks threads, processes, asyncio or vectorisation for a slow Python job based on whether it is I/O- or CPU-bound and the GIL, then implements it and measures the speed-up against the original.
- Run independent I/O calls concurrently
Cuts request latency by running independent HTTP, database or service calls concurrently instead of one after another, with a limit, timeouts and clear error handling, measured.
- 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.
- Process a huge file in constant memory
Rewrites code that loads a huge CSV, JSON, XML or log file into memory so it streams the input in constant memory with chunked processing and batched output, keeping results identical.
- Profile a slow Java or Kotlin service
Profiles a slow Java or Kotlin service with JDK Flight Recorder or async-profiler, reads CPU, allocation and lock profiles correctly, and fixes the top hotspots with before-and-after measurements.
- 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.
- Cut allocations in a Go hot path
Cuts heap allocations in a Go hot path using alloc profiles and escape analysis, with preallocation, buffer reuse, sync.Pool and fewer interface conversions, proven with benchmarks.
- Reduce a service's memory footprint
Cuts steady-state memory of a service or container that is too big but not leaking, splitting heap from native and runtime overhead, then ranks fixes by megabytes saved and verifies under load.
- Reduce iOS or Android app size
Shrinks an iOS or Android app's download and install size from the store size reports by trimming assets, libraries, architectures, resources and dead code, with before and after numbers.
- 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.
- Reduce serverless cold starts
Cuts cold start latency of serverless functions or scale-to-zero containers by measuring init time and frequency, then trimming package and init work before paying for warm capacity.
- Reduce excess SwiftUI view updates
Finds why SwiftUI views re-evaluate their body too often using Instruments and debug tracing, then fixes observation scope, view identity and expensive work in body.
- Reduce tail latency
Lowers p99 and p99.9 latency by finding the sources of the tail (queueing, GC, fan-out, retries, slow dependencies) from histograms and traces, then applying fixes such as deadlines and hedging.
- Review a diff for performance regressions
Reviews a diff for changes that will make production slower, such as N+1 queries, unbounded loads, sync I/O on hot paths, missing indexes and quadratic loops, sized by real data volumes.
- 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 slow API responses
Cuts API response size and time per endpoint by removing over-fetching, adding field selection and pagination limits, fixing serialization cost and enabling compression, measured on real requests.
- 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 Angular change detection
Speeds up a sluggish Angular app by finding excess change detection with the profiler, then applying OnPush, signals, tracked loops, pure pipes and zone controls.
- 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 a batch job
Makes a slow nightly or scheduled batch job fit its window by timing each stage, then fixing row-by-row writes, per-item lookups, full reprocessing and unbounded parallelism, with correctness checks.
- Speed up a command-line tool's startup
Makes a CLI start fast by measuring time to first output, profiling imports and initialisation, then lazy-loading subcommands and removing startup network calls and config scans.
- Cut C++ compile and link times
Cuts C++ compile and link times by measuring which headers and translation units cost most, then fixing include hygiene, adding precompiled headers, ccache, unity builds and a faster linker.
- 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.
- Cut dbt run time
Cuts the run time and warehouse cost of an existing dbt project by finding the slowest models in run artifacts, then fixing materializations, incremental logic, selection and threads.
- Speed up a slow Django view
Speeds up a slow Django or DRF view by measuring queries and time, then applying select_related, prefetch_related, only, annotations, bulk operations and targeted caching, with a query-count test.
- Speed up a .NET hot path
Speeds up a hot .NET code path with BenchmarkDotNet and profiler evidence, cutting allocations with Span and pooling, fixing LINQ and async overhead, and avoiding boxing and needless copies.
- Speed up EF Core queries
Speeds up Entity Framework Core data access from logged SQL, using AsNoTracking, Select projections, split queries, server-side filtering, bulk updates and compiled queries, with measurements.
- Speed up an Electron app
Cuts Electron app startup time and memory by bundling and lazy-loading modules, unblocking the main process, removing sync IPC and trimming windows, measured on a slow machine.
- Speed up a slow FastAPI endpoint
Speeds up a slow FastAPI endpoint by profiling it, fixing blocking calls in async routes, sequential awaits, slow database access and heavy response serialization, with timings before and after.
- Fix Flutter jank and slow screens
Fixes Flutter jank and slow screens from a profile-mode DevTools timeline by scoping rebuilds, removing costly layout and raster work, and moving heavy computation to isolates.
- Speed up a slow Webpack or Vite build
Speeds up a slow Webpack or Vite dev server start, hot reload and production build by profiling plugins and loaders, fixing dependency pre-bundling and caching, measured on one machine.
- Speed up a slow Gradle or Android build
Speeds up Gradle and Android builds using a build scan or profile to fix slow configuration, uncached or non-incremental tasks, annotation processing and module structure.
- Speed up a slow GraphQL API
Speeds up a slow GraphQL API by tracing resolvers, batching data access with DataLoader, limiting query depth and cost, and caching safely, with per-operation numbers before and after.
- Speed up a slow Laravel app
Speeds up a slow Laravel route or app with measured fixes, covering eager loading and withCount, chunked queries, config and route caching, OPcache, queued work and Debugbar or Telescope evidence.
- Speed up rendering of long lists and tables
Makes a web page with thousands of rows fast by measuring render cost and choosing pagination, virtualization or content-visibility, keeping find-in-page, keyboard and screen readers working.
- Cut model inference latency and cost
Cuts latency and cost of a self-hosted ML model's inference with batching, a compiled or optimised runtime, quantisation and right-sized hardware, checking accuracy holds on real data.
- Make monorepo builds run only what changed
Makes a monorepo build and test only what a change affects by fixing the Nx, Turborepo or Bazel task graph, task inputs and outputs, and local plus remote caching, measured by cache hit rate.
- Speed up a slow Next.js page
Speeds up a slow Next.js App Router page by fixing accidental dynamic rendering, request waterfalls, missing caching, absent streaming and oversized client components.
- Speed up a Node.js hot path
Speeds up CPU-bound Node.js code from a CPU profile, fixing slow algorithms, allocation churn, JSON and regex costs and V8 deoptimisations, verified with repeatable benchmarks.
- Speed up slow Python code
Speeds up slow Python code by profiling with cProfile, py-spy or line_profiler, then fixing hot loops, data structures, I/O and repeated work one change at a time with before-and-after timings.
- Speed up PyTorch training throughput
Raises GPU utilisation and samples per second in a PyTorch training loop by fixing data loading stalls, host-device syncs and precision, then applying torch.compile, checked against loss curves.
- Speed up a slow Rails endpoint
Speeds up a slow Rails controller action or page with measured fixes from includes and preload, counter caches, pluck, select, batched writes and fragment caching, guarded by a query-count test.
- Speed up a slow React Native app
Fixes slow screens, laggy lists and dropped frames in a React Native app by profiling JS and UI threads in a release build, then cutting re-renders, list costs, bridge traffic and heavy startup work.
- Speed up a slow Rust program
Speeds up a Rust program from profiles and criterion benchmarks by removing needless clones and allocations, choosing better collections and hashers, and setting release profile options.
- Cut Rust compile times
Cuts Rust build and incremental rebuild times using cargo timings and self-profiling, then splits crates, trims dependencies, generics and proc macros, and picks a faster linker and dev profile.
- Speed up a Shopify storefront
Speeds up a Shopify storefront by removing leftover app code, controlling app scripts, fixing slow Liquid loops, and serving responsive images and lighter theme assets.
- Cut Spring Boot startup time
Cuts Spring Boot startup time by measuring with the startup actuator or logs, then trimming slow beans, auto-configuration and classpath scanning, and weighing lazy init, CDS, AOT and native images.
- Speed up slow text search queries in SQL
Speeds up slow LIKE '%term%', ILIKE and full-text searches in Postgres or MySQL with trigram or full-text indexes, query rewrites and result limits, checked with query plans before and after.
- Speed up slow TypeScript type checking
Speeds up slow tsc runs and editor IntelliSense by tracing the compiler, fixing expensive types, and using project references, incremental builds and skipLibCheck where they fit.
- Speed up a WordPress site
Speeds up a slow WordPress or WooCommerce site by auditing hosting, caching, plugins, theme, database and media, then ranking fixes by measured gain and safe order.
- Cut Xcode build times
Cuts Xcode clean and incremental build times using the build timeline and Swift type-checking warnings, fixing slow expressions, build settings, script phases and module structure.
- Tame third-party scripts
Measures what analytics, tag manager, chat, ad and embed scripts cost a page, then removes, delays, facades or isolates them, with before-and-after numbers for each.
- Size app server workers and threads
Sizes Gunicorn, Uvicorn, Puma, PHP-FPM or Node cluster workers and threads from CPU count, memory per worker and the I/O mix of requests, and checks the result under load.
- Tune a connection pool
Sizes and configures database or HTTP client connection pools from measured hold times and throughput, with the server's connection limit across all instances, timeouts and leak detection.
- 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.
- Fix slow JPA and Hibernate data access
Fixes slow JPA or Hibernate data access using SQL logs and statistics, with fetch joins or entity graphs, batch fetching, DTO projections, JDBC batching and read-only queries.
- Fix slow or overloaded Redis
Fixes slow or overloaded Redis by finding big keys, hot keys, O(N) commands, missing pipelining and wrong eviction or persistence settings, from metrics, the slow log and client code.
- Vectorise Python loops with NumPy
Replaces Python loops over arrays with NumPy vectorised operations, broadcasting, ufuncs and memory-aware dtypes, verifying identical results within tolerance and measuring speed and memory.
- 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.
- Write a microbenchmark
Writes a trustworthy microbenchmark with the language's harness, guarding against dead-code elimination, warm-up, setup cost and unrealistic inputs, and reports a distribution, not one number.
Wins over code-review and debugging when speed or resource use is the outcome.