Website performance is rarely solved by addressing a single Lighthouse warning. On complex websites, improving PageSpeed requires a deeper understanding of how the application loads assets, manages dependencies, delivers content, and interacts with the browser.
For a national membership-based organization with a large public-facing website, Visus faced exactly that challenge. The site ran on Progress Sitefinity and ASP.NET Core and supported a broad audience through editorial content, directories, search functionality, interactive components, and third-party integrations. As the website evolved, performance overhead accumulated across the front end.
Large JavaScript bundles, third-party libraries, inefficient asset loading, inconsistent caching, and components loading more code than necessary all contributed to slower rendering and unnecessary bandwidth and processing.
The client needed to improve performance without disrupting the functionality that users and internal teams relied on.
Moving Beyond a PageSpeed Checklist
The challenge went beyond enabling compression or reducing image sizes.
The website combined Sitefinity, ASP.NET Core rendering, Kendo UI, custom widgets, third-party scripts, and legacy front-end patterns. Many of the optimization opportunities had dependencies that were not immediately obvious.
For example, replacing a full Kendo UI bundle required identifying which components the application actually used and understanding the dependencies required to support them. Similarly, lazy loading could improve performance for many images but negatively affect Core Web Vitals if applied to the page's primary visual content.
Each change required careful investigation and validation.
Rather than treating each Lighthouse recommendation as an isolated task, Visus developed a repeatable framework for evaluating and improving website performance while protecting existing functionality.
Building a Repeatable Optimization Framework
The framework established consistent practices for how the application handled front-end assets.
Visus standardized ASP.NET Core asset management through _ViewImports, Tag Helpers, and asp-append-version. Environment-aware asset loading allowed development environments to use readable source files while production environments delivered optimized assets.
The team also introduced CSS and JavaScript bundling and minification through bundleconfig.json and implemented long-lived caching for versioned static assets.
Where third-party libraries were adding unnecessary overhead, Visus evaluated whether native browser capabilities or simpler JavaScript implementations could provide the same functionality with less code.
Image loading provided another opportunity. Instead of relying on unnecessary third-party solutions, the framework favored native browser capabilities where they provided an effective alternative.
The team also analyzed Kendo UI usage to determine whether the application needed the entire kendo.all bundle or only specific components and their required dependencies. Reducing the bundle to what the application actually used helped eliminate unnecessary front-end payload.
Third-party scripts were also reviewed and scoped more carefully to reduce the amount of code loaded on each page.
Throughout the process, every optimization was validated through PageSpeed and Lighthouse testing as well as browser-level functional testing. The goal was not simply to improve a score. It was to improve performance without introducing regressions.
From Project Experience to Reusable AI Expertise
The most valuable outcome of the engagement extended beyond the performance improvements themselves.
As Visus worked through the optimization process, the team documented the investigation patterns, implementation practices, validation steps, and failure modes discovered along the way.
That knowledge became a reusable optimization methodology.
Visus then packaged the methodology as an AI Skill, allowing AI-assisted development tools to apply the same standards and engineering practices to future Sitefinity and ASP.NET Core projects.
Instead of starting every performance engagement from scratch, future teams can use the AI Skill to establish a common baseline, identify familiar optimization opportunities, and follow proven implementation patterns.
The AI Skill does not blindly apply generic PageSpeed recommendations. It provides a structured approach for investigating each application's architecture and determining which optimizations make sense for that specific project.
That distinction matters.
A performance recommendation that works well for one website can create problems on another. By combining reusable expertise with project-specific analysis and validation, the AI Skill helps teams move faster without sacrificing engineering judgment.
Creating a Capability That Scales
The immediate result was measurable improvement in PageSpeed and Lighthouse performance, along with reduced front-end payload and more efficient static asset delivery.
But the longer-term value is the capability created from the work.
The framework gives Visus a consistent way to approach performance optimization across projects. The AI Skill extends that capability by making proven knowledge available during future development and optimization work.
Future teams can use it to:
- Audit projects against an established performance baseline.
- Identify common optimization opportunities faster.
- Apply proven implementation patterns consistently.
- Avoid previously discovered failure modes.
- Validate changes against the application's actual behavior.
- Preserve project-specific engineering judgment rather than blindly following generic recommendations.
This creates a repeatable cycle for AI-assisted consulting:
Solve the problem → document the pattern → validate the pattern → package it as reusable AI expertise.
The Bigger Lesson
PageSpeed optimization should be treated as an engineering discipline, not a checklist of Lighthouse warnings.
The most valuable improvements come from understanding how an application actually works and establishing repeatable practices around asset management, caching, dependency analysis, browser capabilities, and regression testing.
There is also a broader opportunity for organizations adopting AI-assisted development.
When a team solves a complex technical problem well, the knowledge gained should not disappear when the project ends. It can become reusable infrastructure that helps future teams make better decisions and avoid repeating the same investigation.
That is what makes this approach different.
Visus did more than optimize a client's website. The engagement transformed practical engineering experience into a reusable AI-enabled delivery capability.
The result is better website performance today and a stronger, more consistent way to solve similar performance challenges tomorrow.