Web Performance Budgets and Core Web Vitals in Practice
By Mykhailo Boichuk · Co-founder & Vice-President
In short
A performance budget is an explicit limit on metrics like bundle size and load timing that a build must not exceed. Tying budgets to Core Web Vitals gives them a user-centered meaning: loading, interactivity, and visual stability. The value comes from enforcing budgets in continuous integration so regressions are caught before release, and from measuring real users rather than only lab conditions.
Budgets make performance a constraint
Performance erodes one small addition at a time. A library here, an unoptimized image there, and a site that once loaded quickly becomes slow without any single change being obviously to blame. A performance budget prevents this by setting an explicit ceiling that a build must respect, turning speed from an aspiration into a constraint the team agrees to honor.
A budget is only useful if it is concrete and enforced. Vague intentions to keep the site fast do not survive deadline pressure. A numeric limit on JavaScript size or load timing, checked automatically, does.
Core Web Vitals give budgets meaning
Core Web Vitals express performance from the user’s perspective in three dimensions: how quickly the main content loads, how soon the page responds to input, and how stable the layout is as it loads. Anchoring budgets to these metrics keeps the team focused on what users feel rather than on numbers that do not correspond to experience.
- Largest Contentful Paint measures when the main content becomes visible.
- Interaction to Next Paint measures responsiveness to user input.
- Cumulative Layout Shift measures unexpected movement of content as it loads.
Enforce in CI, measure real users
A budget that is checked only occasionally is not a budget. The discipline is to enforce it in continuous integration so a change that pushes a metric over the limit fails the build and is addressed before it ships. This shifts the cost of a regression to the moment it is introduced, when it is cheapest to fix.
Setting numbers that hold
Useful budgets are derived from the experience you want on the devices and networks your users actually have, not from whatever the current build happens to score. Set the limit at or slightly below current performance so the budget prevents regression, then tighten it as the team improves. A budget that merely records today’s number gives no protection against tomorrow’s slow creep.
Key takeaways
- A performance budget is an explicit, enforced ceiling on speed-related metrics.
- Core Web Vitals tie budgets to loading, interactivity, and visual stability.
- Enforce budgets in continuous integration so regressions fail before release.
- Measure real users, not only fast lab conditions.
- Set budgets from the experience you want, then tighten over time.
Frequently asked questions
- What is a web performance budget?
- An explicit limit on metrics such as bundle size or load timing that a build must not exceed, turning performance into an enforced constraint rather than an aspiration.
- What do Core Web Vitals measure?
- Loading via Largest Contentful Paint, interactivity via Interaction to Next Paint, and visual stability via Cumulative Layout Shift.
- Why measure real users instead of lab tests?
- Lab tests on fast machines hide problems that users on slower devices and networks experience, so field data reveals the performance people actually get.
References
About the author
Mykhailo Boichuk
Co-founder & Vice-President
Mykhailo is an engineer who builds native applications and the systems behind them. He concentrates on macOS and iOS performance, local-first data architecture, and the synchronization problems that come with offline-capable software.