Speed up your Next.js product — without rewriting everything.
I help SaaS teams fix slow pages, poor Core Web Vitals, sluggish frontend interactions, and backend bottlenecks — so the product feels faster, converts better, and scales more cleanly.
60%
Latency cut
15m → 3m
Build time
CWV
Focused fixes
Core Web Vitals
— client fit analysis
Who this is for
Not for brochure-site tweaks or cosmetic fixes. This is for teams where product quality directly affects growth.
Your SaaS is live but feels slower than it should
You've built and launched. Users are coming in. But the dashboard takes 4 seconds to load, filters stall on every interaction, and something feels off. You're not sure where the problem lives — you just know it's costing you churn you can't fully explain.
Core Web Vitals are in the red
LCP is over 4 seconds. INP makes buttons feel broken. Your Lighthouse score is something you'd rather not show anyone. You need someone who actually understands what these metrics mean and has already fixed them before — not someone who will just run a report and email you a PDF.
You're preparing for a growth push or fundraise
Marketing spend is ramping. A fundraise deck needs a demo that doesn't embarrass you. Onboarding is about to go live. You know the product isn't ready for 10x the traffic — and now is the right time to fix the foundations before the load arrives.
Performance has been on the roadmap for months
Your team is smart and working hard — but they're heads-down shipping features. 'Fix performance' has been backlogged for six months. You need someone to come in, own the work completely, and hand back a product that is noticeably faster without pulling your team off their sprint.
Brochure websites, cosmetic-only redesigns, or projects where business outcomes don't depend on how the product actually performs.
— active issue detection
The problems I solve
Most products feel 'kind of slow' for a long time before the team realises how much damage it is doing to conversion, retention, and trust. These are the patterns I see most.
LCP: 4.8s
target < 2.5s
Dashboard loads after users have already doubted you
Users form their first impression in the first 3 seconds. At 4.8s, they've already questioned whether the product works before they've seen anything useful.
Bundle: 1.4MB JS
target < 250KB
Every user downloads code they will never run on that page
On a 4G connection, 1.4MB of JavaScript adds 2–3 seconds of parse time on top of download time — on every single page load, for every user.
INP: 380ms
target < 200ms
Clicks feel broken. Users think something is wrong.
When a button takes 380ms to respond, users tap again. Then again. Then they wonder if their action registered — and that doubt makes your product feel unreliable.
API wait: 2.3s avg
target < 500ms
The loading spinner is the most memorable part of the experience
Every cold API hit adds seconds. Strategic caching alone can cut this by 60–80%. The work is not glamorous but the user impact is immediate.
CLS: 0.28
target < 0.10
The UI jumps while loading. Trust erodes with every shift.
Layout instability makes a product look hastily built. Even if every feature works correctly, the physical jumping of elements signals a lack of polish.
CI build: 15 min
target < 4 min
Slow builds slow down your whole team, not just deploys
A 15-minute build means every hotfix, every performance fix, every iteration takes 20 minutes to verify. Across a team, that compounds into hours of lost velocity every week.
— deep analysis
What a performance audit
actually looks like
Not a generic Lighthouse screenshot. A systematic, prioritized breakdown of what is slowing your product and exactly what to fix first.
Request waterfall
— work plan generated
What you get
The goal is not just "better scores." It is a product that feels noticeably faster for real users and is easier for your team to keep fast as you ship.
4 phases · 15 deliverables
UNDERSTAND → FIX → POLISH → PROTECT
- Performance audit of all key pages and user flows
- Core Web Vitals review — LCP, INP, CLS with real data
- Bundle-size analysis: what ships vs what actually needs to
- Rendering strategy review — what is server vs client vs cached
- Client/server rendering strategy improvements
- Image, font, and asset loading optimization
- API and database bottleneck analysis
- Caching and stale-while-revalidate implementation
- Expensive component and state-flow cleanup
- Dashboard, table, and search performance fixes
- Build-time and deployment pipeline optimization
- Interaction and transition performance tuning
- Monitoring setup to catch future regressions
- Performance budgets and CI/CD guardrails
- Team handoff with documentation on what was fixed and why
What makes my performance approach different
I optimize the experience, not just the report
PageSpeed scores are useful, but the real goal is faster user flows, better responsiveness, and less friction in the product. A green score that nobody notices is the wrong target.
High-impact bottlenecks first
Instead of chasing tiny gains everywhere, I identify the parts of the product that are actually hurting user experience and business outcomes and fix those first.
Built for products that already exist
This service is specifically for teams that don't need a rebuild. They need focused, surgical engineering improvements — not a proposal for a six-month rewrite.
Practical recommendations only
You get changes that are realistic to implement and worth maintaining. Not a giant theoretical audit that describes every possible improvement and leaves implementation entirely to you.
— transformation results
Typical outcomes
These are the kinds of changes that actually happen — not vague promises, but specific before-and-after shifts that users feel and businesses measure.
4.8s
Users wait. Page feels broken.
2.3s avg
Every API call hits the database cold.
15 min
Every fix takes 20 minutes to verify.
380ms
Clicks feel broken. Users tap twice.
0.28
UI jumps while loading. Trust erodes.
28 / 100
Google sees a slow page. So do users.
My process
1. Audit
Review key pages, user flows, and technical bottlenecks to find what is actually slowing things down.
2. Prioritize
Identify the highest-impact performance issues first — by user pain, business importance, and implementation effort.
3. Optimize
Fix bottlenecks across rendering, assets, data flow, backend response time, and frontend interaction.
4. Validate
Re-check using real flows, key metrics, and performance tools to confirm the gains are real.
5. Stabilize
Put guardrails in place so the product stays fast as new features keep shipping.
Selected proof
60% latency reduction
Improved backend-heavy product flows where speed directly affected usability and perceived product quality.
15m → 3m build time
Reduced build and release friction so the team could move faster with less waiting and fewer interruptions.
Core Web Vitals–focused
Performance work centred on real user experience signals — LCP, INP, and CLS — not just synthetic scores.
FAQ
Do you only optimize Next.js apps?
Mostly, yes. This page is built for Next.js products, but the same performance mindset applies to React-based SaaS products too.
Can you help if the app is already live?
Yes — this is especially useful for live products that have grown messy, slow, or harder to scale.
Will this require a full rewrite?
Usually not. In many cases the biggest wins come from focused improvements, not starting over from scratch.
Do you look at backend issues too?
Yes. If slow APIs, inefficient queries, or bad data-fetching patterns are contributing to the experience, I look at those too.
Is this mainly for Lighthouse scores?
No. Better scores can be useful, but the main goal is a faster, smoother experience for real users. The score is a byproduct.