What Happens to a Website's Complexity After Launch
Left alone, every website gets heavier, slower and less secure after launch — here's the data and what to do about it.
A website does not stay the way it was on launch day. Pages get heavier, dependencies pile up, security exposure widens, and the cost of changing anything goes up — all without anyone making a single "bad" decision. This is not a maintenance scare tactic. It is a documented, industry-wide pattern, and the data shows it is getting worse, not better.
Pages get heavier even if nobody touches the code
The clearest evidence of post-launch complexity is simple page bloat. HTTP Archive's Web Almanac has tracked this for over a decade, and the numbers are stark. Between June 2012 and June 2022, median page weight increased by 221% (1.6 MB) for desktop, and 594% (1.7 MB) for mobile. Looking at the more recent window, median page weight grew from 1,208 KB (desktop) and 505 KB (mobile) in October 2014 to 2,652 KB (desktop) and 2,311 KB (mobile) by October 2024.
A separate analysis stretching the same HTTP Archive dataset across 14 years found the growth compounds to a 5.3x increase in median desktop page weight, and 11.5x on mobile. Mobile pages, which usually run on slower networks and cheaper devices, have gotten heavier faster than desktop pages — the opposite of what you'd want.
Worse, this isn't a stable trend you can plan around once and forget. The 2025 Web Almanac reports that page size growth is accelerating, with a noticeable upward trend since October 2024, especially on mobile, and that home page weight accelerated even earlier, around late 2022. Home pages — usually the highest-traffic, most business-critical page on a site — bloat faster than the rest of the site.
None of this requires a redesign or a rebuild. The same analysis attributes much of this creep to things that get bolted on after launch: consent banners, analytics scripts, chat widgets, A/B testing tools, and third-party tags piling up over time.
Why it happens: nobody is watching
Performance-monitoring vendor SpeedCurve puts it bluntly: page bloat happens when people stop paying attention. A site launches lean, everyone moves on to the next project, and then over the following 12–24 months a marketing team adds a heatmap tool, a sales team adds a chat widget, an ops team adds a new analytics suite, and a vendor's tracking pixel gets pasted in without anyone removing the old one.
SpeedCurve's recommendation is to treat performance as an ongoing engineering discipline, not a launch checkbox: pages need to be monitored consistently over time, and integrating performance testing into CI/CD, combined with performance budgets, is how you fight regression.
Google's own guidance backs this up. Core Web Vitals — the metrics Google uses to judge loading speed, interactivity, and visual stability — are described as an ongoing target, not a one-time audit: Google highly recommends site owners achieve good Core Web Vitals for success with Search and to ensure a great user experience generally. The tooling that supports this — PageSpeed Insights and DevTools panels documented on web.dev — is built for repeated checks, not a single pre-launch report.
The financial version of the same problem: technical debt
Page weight is the visible symptom. Underneath it, code and architecture accumulate "technical debt" — shortcuts, workarounds, and outdated dependencies that make every future change slower and riskier.
Software Improvement Group (SIG) cites Deloitte's estimate that technical debt absorbs 21% to 40% of total IT spending. SIG's own modeling attaches a number to what poor maintainability actually costs in developer time: using an average loaded developer cost of €150,000/year, the direct labor cost of poor maintainability runs to roughly €870,000 per system per year for a 2-star system, and close to €9 million per year across a 10-system portfolio.
A separate industry estimate, citing the Consortium for IT Software Quality's 2022 report, puts a national-scale figure on the same phenomenon: accumulated software technical debt in the US has grown to roughly $1.52 trillion, and the broader cost of poor software quality has grown to at least $2.41 trillion.
These two figures are not directly comparable — one is a per-system labor cost, the other a national aggregate — and that mismatch is itself informative: there is no single agreed-upon number for "how much technical debt costs," only consistent agreement that it is large and growing. Below is a rough summary of the different lenses these sources use:
| Source | What it measures | Figure |
|---|---|---|
| Deloitte (via SIG) | Share of IT budget | 21%–40% of total IT spending |
| SIG modeling | Labor cost per poorly-maintained system | ~€870,000/year per 2-star system |
| CISQ / Unqork | US-wide accumulated debt | ~$1.52 trillion |
| CISQ / Unqork | US-wide poor software quality cost | ~$2.41 trillion |
The security surface grows with every plugin you add
Every component added after launch — a plugin, a theme, a third-party script — is a new thing that can be exploited. WordPress, as the world's most widely used CMS, is a useful proxy for this because its ecosystem is tracked closely by security researchers.
Patchstack's 2024 research found 7,966 new vulnerabilities in the WordPress ecosystem in 2024, primarily in third-party plugins — a 34% increase over 2023, and that high-priority vulnerabilities were up 11% year on year. SecurityWeek's independent coverage confirms the scale: nearly 8,000 new vulnerabilities affecting the WordPress ecosystem were reported in 2024, nearly all in plugins and themes.
The follow-up problem is that these vulnerabilities often don't get fixed quickly. Patchstack's 2025 report found that more than half of the plugin developers notified of a vulnerability did not patch it before public disclosure. The real-world consequence: Sucuri alone observed over 500,000 websites infected in 2024, with WordPress core, plugin and theme vulnerabilities responsible for almost half of all malware infections.
The lesson generalizes beyond WordPress: a site's security exposure at launch is close to its minimum. It only grows from there, as a function of how many components you've added and how long any of them have gone unpatched.
What this means if you commissioned a site and haven't touched it since
If your website launched a year or two ago and hasn't had a deliberate review since, you likely have some combination of the following, based on the patterns above:
- More page weight than you think. Marketing and analytics tools accumulate silently — third-party tags, chat widgets, A/B testing scripts and consent banners are named specifically as drivers of post-launch bloat.
- Slower Core Web Vitals scores than at launch, even if the code hasn't changed, because Google evaluates these metrics continuously, not once.
- Unpatched plugin or theme vulnerabilities, if the site runs on a CMS with third-party extensions — a real risk given that more than half of reported plugin vulnerabilities go unpatched before disclosure.
- A rising cost of making changes, the practical effect of technical debt, which SIG estimates costs roughly €870,000/year in extra developer labor per poorly-maintained system.
A basic checklist for a post-launch review, drawn directly from the sources above:
- Run the site through PageSpeed Insights and compare current Core Web Vitals scores against launch-day numbers, not just against a pass/fail threshold.
- Audit every third-party script currently loading on the home page — analytics, chat, heatmaps, ad pixels — and remove anything not actively used, since this accumulation is a named driver of bloat.
- If on WordPress or a similar plugin-based CMS, check plugin and theme versions against known vulnerabilities, given the 34% year-on-year rise in ecosystem vulnerabilities.
- Set a performance budget and a recurring monitoring cadence rather than a one-time cleanup, following SpeedCurve's recommendation to integrate performance testing into ongoing development workflow.
A note on India-specific data
Worth being upfront about: the sources behind this article — HTTP Archive's Web Almanac, Google's Search Central documentation, web.dev, Patchstack, and Software Improvement Group — are global, US-, or Europe-centric. None of them publish India-specific figures on page weight growth, technical debt cost, or CMS vulnerability counts for Indian websites specifically. Indian businesses should read the numbers above as directional global benchmarks — the underlying mechanics (unmonitored scripts pile up, unpatched plugins accumulate, Core Web Vitals scores drift) apply regardless of where a site is hosted or who built it, but the exact percentages and dollar figures are not India-calibrated.
Questions people also ask
Does a website need active maintenance after launch, or is "build once" enough?
The data says no site stays static on its own. Median page weight has grown by 5.3x on desktop and 11.5x on mobile over a 14-year measurement period, largely from things added after launch, not the original build. Without monitoring, this accumulation is the default outcome, per SpeedCurve's assessment that bloat happens when people stop paying attention.
How often should Core Web Vitals be checked after a site goes live?
Google's documentation treats this as continuous, not a one-time launch gate: it recommends site owners achieve good Core Web Vitals for both Search success and general user experience, implying ongoing measurement. Pairing tools like PageSpeed Insights with a regular review schedule — quarterly at minimum — catches drift before it compounds.
Is technical debt really that expensive, or is it an overstated concern?
Estimates vary by methodology, but all point in the same direction. Deloitte's estimate, cited by SIG, is that technical debt absorbs 21%–40% of total IT spending, while CISQ's 2022 report puts the total cost of poor software quality at roughly $2.41 trillion at a national scale. The figures aren't directly comparable, but neither source treats technical debt as a minor line item.