- Home
- Skills
- APIs & Backend
- Performance Optimization: Web and Backend
More screenshots
Works with the AI Agents you already use
Performance Optimization: Web and Backend
Fix slowness by evidence: budgets first, profiling over guessing, fixes ordered from less work to cheaper work, and CI guards so the win survives the next deploy.
$5
Performance Optimization: Web and Backend
Example session with this skill installed
Our checkout API got slow over the last two weeks — p95 went from about 400 ms to 2.1 seconds. The team wants to rewrite the pricing module. Where do we actually start?
- Read your context and instructions
- Compiled the performance optimization
Start where this method always starts: not with the rewrite, and not with code. Your budget — assume p95 under 500 ms for checkout; correct it if that is wrong — is breached about 4x, and the shape of the breach matters. A single bad deploy spikes overnight. A two-week climb points at growth: more data, more traffic, or a degrading dependency. The pricing module may be guilty, but nothing yet says so.
First probes, in order — roughly an hour of measurement before any fix. One: the database query log for the checkout endpoints, sorted by total time (count times average). Two-week climbs are classically an unindexed filter meeting a growing table, or an N+1 whose cost scales with items per order. Two: if every endpoint climbed together rather than checkout alone, check connection-pool wait time before touching a single query. Three: skim the deploy log for the window anyway — a small change, a new synchronous call, heavier logging, can stay invisible until volume grows into it.
The fix, at the highest level that applies. Expect the profile to name one query family owning most of the time. If checkout fetches data it never renders — a full order history behind a totals call — that is level 1: delete the work, no index needed. If the same query repeats per line item, level 2: batch it into one query. Only then level 3: an index matched to the actual filter shape, verified with the query plan before and after. The pricing-module rewrite does not enter the plan unless the flame graph puts pricing there — measure it, and let the number argue.
Verify and guard. Re-measure p95 with the same method that produced 2.1 seconds; a stopwatch on one warm request proves nothing. Then make it permanent: a CI budget on the checkout endpoint's query count, and an alert on p95 sustained above budget for 15 minutes, so the next climb is caught in week one instead of week three.
Connects securely to your tools. The creator never sees your data.
About this skill
Most performance work is spent tuning the wrong thing, because the bottleneck is almost never where intuition points — it is the N+1 query, the unindexed filter, the 4 MB hero image, the payload nobody needed. This skill enforces the loop that avoids that waste: budget, baseline, profile, fix the actual bottleneck, re-measure, guard.
You start by writing the budget down — p95 under the SLA rather than an average, largest contentful paint under about 2.5 seconds, jobs inside their scheduling window — on a one-row-per-surface worksheet, so "fast enough" is a decision procedure instead of a feeling. Measurement is split honestly into synthetic (reproducible, for finding and fixing) and real-user (messy, the only proof users felt it), and a first-probe table maps symptoms to the first measurement worth taking: one slow endpoint, every endpoint slow at once, slow only for some users, slow right after a deploy.
Fixes follow a five-level hierarchy that most teams run backwards: do less work, do the work once, do the work cheaper, do it later, do it elsewhere. Backend and frontend pattern sections cover the repeat offenders — N+1 queries, indexing for the query shape rather than the column, connection-pool sizing, unbounded anything, bundle weight, main-thread discipline. A worked example walks a dashboard from a 3.8-second p95 to 1.9 seconds with a single batched query, after the profile showed the team's planned renderer rewrite owned 0.2 seconds of the problem. Every fix runs a pre-change checklist and ends with a guard — a CI budget, a production alert, or a code note with the measured numbers — so the next refactor cannot quietly hand the regression back.
- It cannot measure for you: without a profiler, query log, or trace to work from, the honest output is a measurement plan, not a diagnosis.
- Thresholds given (p95 budgets, ~2.5 s paint targets) are sound defaults, not your SLA — the worksheet step exists to replace them with numbers your product actually owes its users.
- It optimises within your current architecture; if profiling proves the architecture itself is the ceiling, it will say so with the numbers, but the redesign is a separate project.
- Load testing for a known traffic event is a companion discipline — this skill finds and fixes bottlenecks, it does not certify capacity.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 24 days ago
Requires