Website Performance Optimization Case Study

Client
Confidential
Service
Technical SEO + Frontend Performance
Platform
HTML/CSS/JS, React, PHP
Tools
Google PageSpeed, Lighthouse, WebPageTest

Background

The importance of website performance in today's digital landscape

Improving website performance is essential today, both for better user experience and higher search rankings. Slow websites often frustrate visitors, increase bounce rates, and hurt conversions—especially on mobile devices. For this project, the main objective was to boost loading speed and overall performance on both desktop and mobile, using Google PageSpeed Insights and Core Web Vitals as benchmarks.
pagespeed-report26

pagespeed-report50

Challenge

Critical performance issues affecting user experience and search rankings

Poor PageSpeed Scores

The original site scored poorly on mobile (26/100) and moderately on desktop (50/100).

Core Web Vitals Failures

Core Web Vitals such as LCP (Largest Contentful Paint) and CLS (Cumulative Layout Shift) were failing thresholds as long as 7450 ms.

Performance Bottlenecks

Render-blocking scripts, unused CSS, unoptimized images, and lack of lazy loading were key bottlenecks and were costing 500 kbs of extra network load.

Slow Time to Interactive

Time to Interactive (TTI) was slow due to inefficient JavaScript and large third-party scripts.



pagespeed-report94


pagespeed-report85
Audit & Analysis

Comprehensive performance analysis using industry-standard tools

⚡ Performance Audit Process

Using Google PageSpeed Insights and Lighthouse reports, we conducted a full audit of the site performance. The most pressing issues included:

  • Uncompressed Images: WebP suggested but not implemented
  • Render-blocking resources: CSS/JS blocking critical rendering path
  • Excessive DOM size: Large DOM and third-party scripts
  • No preloading or font optimization: Missing critical resource hints
  • Inefficient code loading: Too many synchronous JavaScript calls
pagespeed-report-50
Solution & Implementation

Multi-pronged technical SEO and performance engineering approach

1. Image Optimization

  • WebP Conversion: Converted all major images to WebP format
  • Lazy Loading: Implemented lazy loading for off-screen images
  • Responsive Images: Used srcset for responsive image delivery

2. Critical CSS Extraction & Minification

  • Inline Critical CSS: Extracted and inlined above-the-fold CSS
  • CSS/JS Optimization: Minified and deferred non-critical CSS and JS
  • Unused CSS Removal: Removed unused CSS using PurgeCSS

3. JavaScript Optimization

  • Async/Defer Loading: Deferred and async-loaded JS
  • Third-party Script Cleanup: Removed unused third-party scripts
  • Bundle Size Reduction: Reduced JS bundle size by modularizing scripts

4. Server & Hosting Improvements

  • Compression: Implemented GZIP compression and browser caching
  • CDN Implementation: Used a CDN (Cloudflare) for asset delivery
  • HTTP/2 Enablement: Enabled HTTP/2 for faster asset multiplexing

5. Core Web Vitals Enhancements

  • LCP Improvement: Improved LCP by reducing initial server response time and prioritizing hero image loading
  • CLS Reduction: Reduced CLS by reserving space for ads, images, and fonts
  • FID/TTI Enhancement: Improved FID and TTI with better JS handling and minimal DOM updates
Results

Significant performance improvements across all metrics

📈 Performance Improvements

Metric Before After Improvement
Mobile Performance Score 48 85 +45 Points
Desktop Performance Score 50 95 +45 Points
Takeaway

Key insights from the performance optimization project

We improved the website's speed and performance by making a series of changes across the frontend, media files, and server settings. This included cleaning up the code, optimizing images, and improving how the site loads behind the scenes. As a result, the site now loads faster, performs better on mobile devices, meets Core Web Vitals standards, and is more search engine–friendly—leading to a better user experience and higher chances of conversions.

FAQ – Structured Data

Fixing critical structured data issues for better search visibility

Issue with FAQ Structured Data

The website initially had incorrect or incomplete FAQ schema markup, which prevented Google from recognizing and displaying FAQs in search results. The main problems included:

  • Missing @type definitions: Some FAQ entries were missing the required @type: "Question" and @type: "Answer" properties.
  • Improper nesting: Answers were not correctly nested under their corresponding questions.
  • Invalid HTML tags: Invalid HTML tags within the answer content, causing parsing errors.
  • No JSON-LD format: FAQs were hardcoded as plain HTML without proper structured data markup using JSON-LD or Microdata.

What We Fixed

  • JSON-LD Implementation: Implemented valid JSON-LD format using @context: "https://schema.org" and @type: "FAQPage".
  • Correct Structure: Ensured each FAQ item had the correct structure.
  • HTML Tag Cleanup: Escaped or removed unsupported HTML tags from the text field.
  • Validation: Validated the implementation using Google's Rich Results Test and Schema Markup Validator to confirm there were no warnings or errors.
valid4
questions
valid4

Issue with Breadcrumb Structured Data

The website's breadcrumb markup was either missing or incorrectly implemented, which prevented search engines from displaying breadcrumb navigation in the search results. The key issues identified were:

  • Missing structured data: Missing structured data altogether on some pages, even though breadcrumb navigation was present visually.
  • Incorrect @type usage: Some items used "ListItem" without properly wrapping them in a BreadcrumbList.
  • Missing position values: Missing position values, which are required to define the order of breadcrumb items.
  • Invalid URLs: Invalid or non-canonical URLs in the item field, causing Google to flag them as errors.

What We Fixed

  • Correct JSON-LD Structure: Implemented the correct JSON-LD structure using @type: "BreadcrumbList" and @type: "ListItem" for each step in the breadcrumb.
  • Required Fields: Added position, name, and item fields for every breadcrumb entry.
  • URL Matching: Ensured all breadcrumb URLs matched canonical URLs on the page.
  • Validation: Verified structured data using Google's Rich Results Test to confirm successful implementation.
valid6
Need Similar Results?

Get expert performance optimization for your website

If your website loads slowly or doesn't meet Core Web Vitals standards, we can help. Visit qaushik.com to get expert support in making your site faster, more efficient, and better optimized for Google and your users.