NITRO

We optimize your Core Web Vitals to green scores in 14–21 days.

LCP, INP, CLS — we fix what Google measures
We work on your existing code — no 'rebuild for sport'
Bundle size reduction and render-blocking elimination
Performance budget enforced in CI — no regressions

Book a 15-min consultation

No obligations. NDA on request.

Performance

100

Best Practices

SEO

LCP < 2.5s CLS < 0.1 90+ Lighthouse

THE COST OF INACTION

A slow site burns your budget and hands customers to your competitors.

Your ads drive traffic — your site drives frustration. Every extra second of load time costs you 7% of conversions.
53% of mobile users leave a page that loads longer than 3 seconds (Google data). They go to the competitor.
Technical debt on the frontend accumulates silently — until the rewrite costs 10x more than the fix.
Google uses CWV as a ranking signal. Poor performance = lower positions = less organic traffic.

Load Time vs. Drop Rate

Drop Rate

Conversion

DELIVERABLES

NITRO = audit, hard fix and result protection.

Three pillars that turn a slow site into a performance-certified product.

CWV Audit

Lighthouse CI report with priorities (P0–P3)
CrUX field data analysis (real users, not lab)
Critical rendering path mapping
Bundle analysis — tree-shaking, code splitting gaps

SSR/CSR Optimization

Render-blocking resource elimination
Image optimization (AVIF/WebP, lazy loading, sizing)
Third-party script audit and deferral strategy
Server-side rendering tuning and streaming SSR

CI Performance Gates

Lighthouse CI thresholds in every PR
Bundle size budget — PR blocked on regression
Real User Monitoring (RUM) dashboard
Automated performance reporting — weekly digest

CORE WEB VITALS

Glossary: what we optimize and why.

Six metrics that determine how Google and your users perceive your site.

LCP

Largest Contentful Paint

Time to render the largest visible element. Target: < 2.5s. Directly affects first impression and bounce rate.

INP

Interaction to Next Paint

Measures responsiveness to user interactions (clicks, taps, keyboard). Target: < 200ms. Replaced FID in March 2024.

CLS

Cumulative Layout Shift

Sum of unexpected layout shifts during page lifecycle. Target: < 0.1. Prevents 'content jumping' that frustrates users.

TTFB

Time to First Byte

Time from request to first byte of response. Target: < 800ms. Reflects server, CDN and backend efficiency.

PERFORMANCE BUDGET

Performance Budget

A set of limits on bundle size, request count and metric values enforced in CI. Prevents performance regressions before they reach production.

WCAG

Web Content Accessibility Guidelines

Accessibility standard (AA level). Overlaps with performance — semantic HTML, proper image alt, focus management improve both speed and usability.

PROCESS

NITRO process: 4 steps, zero guesswork.

A repeatable, measurement-driven framework refined over dozens of optimization projects.

Baseline measurement

Lighthouse CI, CrUX field data, WebPageTest waterfall. We document the current state and set metric targets.

Quick wins

Image compression (AVIF/WebP), third-party defer, critical CSS inline, font optimization. Visible improvement within 3–5 days.

Deep refactoring

Code splitting, lazy loading, SSR/streaming tuning, render-blocking elimination. Surgical changes — no rewrite.

Result protection

Lighthouse CI gates in every PR, bundle size budget, RUM dashboard, weekly performance digest. Zero regressions.

HARD PROOF

Results you can verify without question.

Real metrics from real projects — open Lighthouse and check.

E-commerce

LCP from 4.1s to 1.2s — 40% more transactions

Before

After

Next.js 14 store with 12k products. Image pipeline migration to AVIF, streaming SSR, code splitting of product page bundle.

SaaS

INP from 680ms to 120ms — users stopped complaining

Before

After

React 18 dashboard with heavy charting library. Virtualized tables, deferred hydration, Web Worker offloading for data processing.

FinTech

TTFB from 2.4s to 180ms — SEO traffic +65%

Before

After

Landing page cluster on WordPress + headless migration to Astro. Edge caching, ISR, critical CSS extraction.

lighthouse-ci.yml

# .github/workflows/lighthouse-ci.yml
name: Lighthouse CI
on: [pull_request]
jobs:
  lighthouse:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
      - uses: treosh/lighthouse-ci-action@v11
        with:
          budgetPath: ./budget.json
          uploadArtifacts: true
      # PR blocked if score < 90

PACKAGES

Choose scope: one-time sprint or ongoing protection.

Every option starts with a hard measurement and ends with verifiable proof.

Audit & Roadmap

Discovery

Lighthouse CI + CrUX field data analysis
Critical rendering path mapping
Bundle analysis with tree-shaking audit
Prioritized fix roadmap (P0–P3)
Executive summary for stakeholders

Order audit

Recommended

Nitro Sprint

Fix

Everything from Audit & Roadmap
14–21 day implementation sprint
Image pipeline (AVIF/WebP) + font optimization
Code splitting + lazy loading + SSR tuning
Lighthouse CI gates configured in your repo
Before/after report with CrUX validation

Start sprint

Nitro Guard

Maintenance

Everything from Nitro Sprint
Monthly performance review + report
RUM dashboard (real users, not synthetic)
Dependency update + regression prevention
SLA: response < 4h on performance incidents
Quarterly CWV health check

Secure results

What we DON'T do

Full site redesign — we optimize existing code
Backend rewrite — we focus on frontend and delivery
Content creation or copywriting
Marketing campaign management

We price the scope of work, not the number of pages.

COMMON CONCERNS

Common concerns — and our ironclad rules.

"Will you break our code?"

Every change goes through staging first. We prepare a rollback plan before touching production. Automated tests verify that nothing is broken. You approve every deployment.

"What about security and access?"

NDA on request. We work with minimal permissions — read access to the repo, staging deploy rights. No access to production databases or admin panels.

"We already have fast hosting"

Hosting is 10–20% of the problem. 80% of performance issues live in the frontend: render-blocking resources, oversized bundles, layout shifts, unoptimized images. That's where we operate.

"How do we know it won't regress?"

Lighthouse CI gates block PRs that lower scores below thresholds. Bundle size budget catches regressions at the PR level. RUM dashboard monitors real users 24/7.

"Our framework limits our options"

We've optimized Next.js, Nuxt, Gatsby, Angular, WordPress, Shopify, and custom React SPAs. Every framework has performance levers — you need to know which ones to pull.

FREE TOOLS

Measure your performance gap in seconds

Run a free Core Web Vitals check, calculate the ROI of fixing performance issues, and assess your technical debt.

Core Web Vitals Checker

Instant audit of LCP, CLS, and INP for any URL — see where you stand vs. Google thresholds.

Performance ROI Calculator

Translate speed improvements into revenue impact with conversion and bounce-rate modelling.

Technical Debt Calculator

Quantify hidden costs of technical debt and prioritise refactoring efforts.

Project Estimator

Get a full project estimate with timeline, team, and budget breakdown.

TECH STACK

Technologies and standards that build the result.

We don't sell tools — we sell outcomes. These are the instruments we use to get there.

< Lighthouse CI /> { WebPageTest } [ CrUX API ] fn bundleAnalyzer() < Next.js SSR /> { Vite } [ Webpack 5 ] < Edge Caching /> { Cloudflare } [ Vercel Edge ] fn imageOptim() < AVIF / WebP /> { RUM / APM } [ Sentry Perf ] fn treeshake() < Playwright />

< Lighthouse CI />{ WebPageTest }[ CrUX API ]fn bundleAnalyzer()< Next.js SSR />{ Vite }[ Webpack 5 ]< Astro />< Lighthouse CI />{ WebPageTest }[ CrUX API ]fn bundleAnalyzer()< Next.js SSR />{ Vite }[ Webpack 5 ]< Astro />< Lighthouse CI />{ WebPageTest }[ CrUX API ]fn bundleAnalyzer()< Next.js SSR />{ Vite }[ Webpack 5 ]< Astro />

{ Cloudflare }< Edge Caching />[ Vercel Edge ]fn imageOptim()< AVIF / WebP />{ RUM / APM }[ Sentry Perf ]< Playwright />{ Cloudflare }< Edge Caching />[ Vercel Edge ]fn imageOptim()< AVIF / WebP />{ RUM / APM }[ Sentry Perf ]< Playwright />{ Cloudflare }< Edge Caching />[ Vercel Edge ]fn imageOptim()< AVIF / WebP />{ RUM / APM }[ Sentry Perf ]< Playwright />

FAQ

Frequently asked questions about time, cost and safety.

How long does it take to achieve green Core Web Vitals?

Quick wins (images, fonts, third-party scripts) show improvement within 3–5 days. Full sprint with deep refactoring takes 14–21 days. Field data (CrUX) needs 28 days to reflect changes.

How much does a performance optimization project cost?

Audit & Roadmap: from €2,000. Nitro Sprint (audit + implementation): from €5,000. Nitro Guard (ongoing SLA): from €1,500/month. We provide an estimate after reviewing your site's current state.

Do you work with WordPress / Shopify / custom stacks?

Yes. We optimize Next.js, Nuxt, Gatsby, Angular, WordPress (with and without headless), Shopify, and custom React/Vue SPAs. Every framework has performance levers — the approach differs, the methodology doesn't.

Will you need access to our production environment?

For the audit — no. We work with publicly available CrUX data and Lighthouse scans. For implementation — we need read access to the repo and deploy rights on staging. Production deploys are always handled by you.

What if the results don't improve?

We start every project with a baseline measurement and set specific, numeric targets. If targets aren't met, we continue work at no additional cost until they are. This is in the contract.

How do you prevent performance from regressing after the project?

We configure Lighthouse CI gates in your CI/CD pipeline — every PR is automatically checked. We set a bundle size budget. Optionally, Nitro Guard provides ongoing RUM monitoring and monthly reviews.

GET STARTED

Give us the URL. You'll get a plan, priorities and an estimate.

Book a free 15-minute consultation or send us your URL.

Loading calendar...