Performance metrics evolve. Core Web Vitals were introduced in 2020. They replaced older metrics (FCP, FID). Five years from now, new metrics will replace Core Web Vitals.
Future metrics will measure: AI loading (how long until AI features respond), real-time responsiveness (how long until streaming responses appear), user-perceived performance (how does page feel, not just technical metrics).
Question for now: how do we prepare for future metrics without knowing what they are. Answer: measure what matters for your business. Core Web Vitals measure general user experience. Custom metrics measure business-specific outcomes. Prepare for future by building flexibility into measurement systems.
Tracking metrics evolution
Core Web Vitals are current standard. But they are not permanent.
Timeline:
- 2020: Core Web Vitals introduced (LCP, CLS, FID)
- 2022: FID replaced with INP (responsiveness metric refined)
- 2024: discussion of next metrics (interaction wait time, streaming response time)
- Future: new metrics emerge
Pattern: as technology changes, metrics change. When pages became interactive, interactive metrics (INP) became important. As AI integration becomes common, AI response time may become important metric.
Lesson: focus on principles (user perceives fast, responsive, stable page), not metrics themselves. Principles are stable even as metrics change.
AI and real-time performance
AI features are becoming common. Chatbot on website takes two seconds to respond. User expects faster.
Emerging metric: AI response time (time from user question to first token of AI response).
Example: customer service chatbot on support page. User asks question. Chatbot takes two seconds to return first response token. User perception: chatbot is slow, unresponsive.
Optimization: streaming response. Return first token in five hundred milliseconds, stream remaining response. User perceives response as instant, even if full response takes two seconds.
Future metric: measure time to first token (TTF), not total response time. TTF under five hundred milliseconds is good.
Real example: SaaS with embedded AI assistant.
Current user experience:
- User clicks assistant icon
- Assistant takes one point five seconds to appear
- User waits, perceives slowness
- Chat experience feels slow
Future optimization:
- User clicks assistant icon
- Icon animates immediately (instant feedback, one hundred milliseconds)
- Chat window opens (two hundred milliseconds)
- First AI response appears (five hundred milliseconds)
- Remaining AI response streams (one to two seconds)
User perception: instant response (animation + window open is visible immediately).
Edge computing and distributed performance
Edge computing brings computation closer to users. Server moved from New York to Los Angeles edge. TTFB improves dramatically.
Future: computation happens at edge. HTML generation happens at edge. JavaScript execution happens at edge. Database queries distributed to edge.
Impact on metrics: TTFB becomes negligible (network latency approaches zero). LCP depends on rendering, not server response.
Future optimization focus: rendering performance, not server response performance.
Example: future edge-powered homepage.
Current state:
- TTFB: two hundred milliseconds (server in New York, user in Los Angeles)
- LCP: two seconds (LCP = TTFB + rendering time)
Future state (edge computing):
- TTFB: twenty milliseconds (server at Los Angeles edge)
- LCP: one point five seconds (rendering time is bottleneck, not server response)
Optimization: improve rendering performance (CSS, JavaScript) becomes more important than improving server response.
User-perceived performance and subjective metrics
Objective metrics: LCP is two seconds (measurable, objective).
Subjective metrics: page feels responsive (subjective, perceived).
Research shows: page that feels responsive may have same technical metrics as page that feels slow. Difference is animation, visual feedback, perceived loading.
Future metric: perceived responsiveness. Measure user's perception, not just technical metric.
Example: two pages with same LCP (two seconds).
Page one: loads instantly to blank page, then content appears at two second mark. User perceives slowness.
Page two: shows skeleton screen immediately (two hundred milliseconds), gradually fills in content to two second mark. User perceives faster (skeleton screen creates illusion of faster load).
Technical metrics (LCP): same for both (two seconds).
User perception: page two feels faster.
Future metric: user perception score (measure subjective experience alongside technical metrics).
Streaming and progressive rendering
Current approach: _blocked_ entire page, send to client. Client renders page. Page is interactive.
Streaming approach: send page parts as they _blocked_. Client receives and renders parts progressively. Page is partially interactive before fully loaded.
Impact: page that takes two seconds to fully load can be interactive in zero point five seconds if streamed.
Future metric: time to interactive (TTI). How long until user can interact with page.
Example: product page with recommendations.
Current approach:
- HTML loads (zero point five seconds)
- CSS loads (zero point three seconds)
- JavaScript loads (zero point five seconds)
- API call for recommendations (one second)
- Page is interactive at two point three seconds
Streaming approach:
- HTML streams (zero point one seconds) - page structure visible
- CSS streams (zero point two seconds) - page styled
- JavaScript streams (zero point three seconds) - page interactive
- API call for recommendations continues in background
- Page is interactive at zero point five seconds
- Recommendations appear at one second and beyond
User can interact (add to cart, click buttons) at zero point five seconds. Full content appears at one second and beyond.
Future metric (TTI): zero point five seconds (from two point three seconds). Huge improvement in user perception.
Frequently asked questions
Should we start measuring AI response time now?
Yes if your site has AI features. Measure time to first token. Track daily. Set targets (under five hundred milliseconds is good). Prepare for future where this becomes standard metric. Even if it is not official metric yet, measuring what matters for your users prepares you for future. With WEMASY's website builder, you can set this up directly on your website.
How do we prepare for future performance metrics we do not know yet?
Build flexible measurement system. Measure Core Web Vitals (current standard). Also measure custom metrics (what matters for your business). When future metrics emerge, you can add them alongside existing metrics. Flexibility is key.
Should we invest in edge computing for performance?
Yes if you have global users. Edge computing reduces TTFB dramatically (network latency eliminated). Worth investment. If your users are concentrated in one geography, CDN is sufficient. Global audience benefits from edge computing.
How do we measure user-perceived performance?
Survey users. Ask: does page feel fast, responsive, stable. Correlate survey results with technical metrics. You may find that users perceive page as faster even if technical metrics are same. Use feedback to inform design (add skeleton screens, animations, visual feedback).
Is time to interactive (TTI) becoming the new standard metric?
Possibly. TTI is more meaningful than LCP for interactive pages (user can act before page fully loads). But as of now, Core Web Vitals (LCP, CLS, INP) are standard. TTI is emerging but not yet official. Monitor both.
How do we stay updated on new performance metrics and standards?
Follow official sources: Google performance updates, Web.dev blog, W3C standards groups. Follow industry: Smashing Magazine, WebPageTest blog, engineering conference talks. New metrics emerge through these channels. Stay informed. Adopt early when new standard becomes relevant to your site.