yceffort
20 POSTS

Web-performance 1

  • #web-performance#debugging#blogging

    Which Element Caused This Blog's CLS

    Two causes found through the shifted elements recorded alongside CLS values: a decorative element that follows the cursor and was counted as a layout shift, and a home page list that pushed the footer down while the overall p75 stayed at 0.000. Both were confirmed with field data and lab reproductions.

    20 min read
  • ◆ Page Preservation in Next.js Part 2
    #nextjs#memory#web-performance

    Why Did Next.js's Last Three Leave Nine Posts Behind?

    Next.js is said to preserve the last three pages, yet nine posts remained on this blog. A sequential navigation experiment measures how far preservation reaches, then looks at managing memory by separating work to stop when hidden from state worth keeping.

    16 min read
  • ◆ Improving number-flow Part 4
    #web-performance#animation#debugging

    How Far Will Agents Fix number-flow?

    I compared number-flow as fixed by five coding agents against my fork v0.2.1 once more. Performance reports changed with the font, the code went through a review with the authors hidden, and a follow-up experiment ended with keeping the mask default.

    Updated 31 min read
  • ◆ Improving number-flow Part 3
    #web-performance#browser#debugging

    Reducing Forced Synchronous Layout in the number-flow Update Path

    Every time the value of number-flow changed, style and layout were being recalculated several times over. This post records the performance change observed after 0.2.1 reordered how the library reads and writes the DOM, and the costs that remain.

    Updated 26 min read
  • #web-performance#software-engineering#essay

    In Performance Work, the Techniques Were Short and the Judgment Was Long: Preparation, Observation, Response, Verification, Measurement

    What should come before choosing a performance technique? This post follows the order used in practice: settling the support range and dependencies, measuring, deciding priorities, responding when the cause lives in someone else's code or infrastructure, guarding against regressions, and reporting results.

    35 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 4
    #web-performance#devops#debugging

    Self-Hosting Core Web Vitals Collection for a Quiet Blog

    Moved a Core Web Vitals collection setup designed for shared observability infrastructure to my personal blog. Fixed a dashboard left empty by sparse traffic and changed when metrics are collected for ordinary browsers. Along the way I found why some query results went missing, and worked out how much five days of data can support.

    32 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 3
    #web-performance#devops#debugging

    Sending the Core Web Vitals of an App Webview to a Shared Observability Platform

    Sent the Core Web Vitals measured in an app webview to an observability platform shared by many teams. The webview gave no signal on leaving, and tail sampling, delta-to-cumulative conversion and Tempo queries each dropped values in their own way without raising an error. For every setting that could not be changed, re-measured what was lost in a reproduction environment.

    Updated 37 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 2
    #web-performance#debugging#browser

    Sending Core Web Vitals at the Moment of Leaving the Page

    Traced why CLS and INP go missing when the page is left, through the transport of OTel JS and the order in which flush runs.

    Updated 22 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 1
    #web-performance#debugging#browser

    When Does web-vitals Report Core Web Vitals

    Checked the conditions under which web-vitals 6.2.3 reports each metric, and why INP goes missing when the page is left right after a click.

    Updated 33 min read
  • ◆ Improving number-flow Part 2
    #web-performance#animation#browser

    Improving number-flow Performance: Moving Animations onto the Compositor Thread

    In the number-flow fork I built to support old browsers, animations in modern browsers were still recalculating styles on every frame. In 0.2.0 I moved the motion built with additive compositing into transform and opacity keyframes, but costs remain in the mask and in interruptions.

    Updated 24 min read
  • ◆ Building coldpath Part 3
    #debugging#web-performance

    Tracing Toss Securities JavaScript Without Source Maps

    Chuseok side quest, part 3: with love, to Toss Securities

    26 min read
  • ◆ Building coldpath Part 2
    #web-performance#bundler#debugging

    Building a Bundle Analyzer with V8 Coverage and Source Maps

    Chuseok side quest, part 2: building a V8 coverage analyzer, one dead end after another.

    Updated 24 min read
  • ◆ Building coldpath Part 1
    #web-performance#bundler#blogging

    Tracing When This Blog's JavaScript Actually Runs

    Chuseok side quest, part 1: starting with my own blog

    20 min read
  • #web-performance#javascript#browser

    I Grew Never-Executed JavaScript to 10MiB

    How much do you lose when 10MiB of functions you never call ships to the browser? I ran 855 measurements to separate the cost of file size from the cost of code shape. Uncalled declarations cost about 21ms per MiB, while initialization code that runs the moment the file is read took 201ms per MiB on the main thread. With real libraries, merely importing a module was enough to evaluate it.

    32 min read
  • #bundler#web-performance#debugging

    Tearing Apart a Third-Party SDK and Rebuilding It My Way: Without Touching a Single Line of Logic

    I imported one constant and 97.7% of the bundle came along with it. The vendor had no timeline for a fix, so I recovered over 400 TypeScript files from the published source maps, rebuilt the build, entry points, and dependencies while leaving the logic alone, and cut the raw size of /send by 77.5%. All 1,932 tests passed, but a few of them were checking nothing at all, so I had to work out again how far I could confirm that the rebuilt SDK behaves the same as the original.

    41 min read
  • ◆ Service Worker Caching Deep Dive Part 3
    #service-worker#web-performance#caching

    Measuring the Cost of Going Through a Service Worker: Building in the Lab the Control Group GA4 Could Not Give Me

    I set out to confirm the 500 ms that part 2 left as the cost of going through the worker, but the hard reloads that would form the control group arrive at under one a day. With a control group built from Playwright and a shaping proxy, going through the worker cost 2 ms on a navigation. Most of the extra time on a post click came from the worker saving the post HTML in the background over the same connection, and the gap between lab and field data was a measurement definition difference caused by 103 Early Hints.

    Updated 50 min read
  • ◆ Service Worker Caching Deep Dive Part 2
    #service-worker#caching#nextjs

    Applying Service Worker Caching: App Router Traps and GA4 Field Data

    I made this blog (Next.js App Router) open offline. On the first deploy, the post I had just read would not open offline; on the second, posts opened but every image was broken. After fixing the problems from soft navigation, prefetching, and next/image one at a time, GA4 real-user data showed returning-visitor FCP 634ms faster on average and TTFB 525ms slower on average.

    Updated 27 min read
  • #animation#web-performance#debugging

    Killing Frame Drops in a framer-motion Banner: Two Wrong Turns and One Easing Function

    A banner built with framer-motion made the entire home screen stutter for the 0.6 seconds it took to open. My guess at the cause from reading the code was overturned twice by measurement, and in the end a single easing function removed the reflow.

    30 min read
  • ◆ Service Worker Caching Deep Dive Part 1
    #service-worker#caching#browser

    How Service Worker Caching Works: The Proxy, the Lifecycle, and Five Strategies

    This post covers the service worker material that did not fit into the cache chapter of Frontend Performance Optimization Deep Dive (published in Korean). It works through why caches go stale, why the old version shows up after a deploy, what to store under which strategy, and whether you should use one at all, and measures a 104KB opaque response being counted as 6.6MB of storage.

    Updated 24 min read
  • ◆ Kubernetes for Frontend Developers Part 5
    #kubernetes#devops#web-performance

    Autoscaling Is Automatic but Not Instant: HPA's Timeline, Measured Segment by Segment

    Raise traffic 12x and it takes 31.5 seconds for a new pod to receive its first request, 22.5 of them spent before the HPA notices the load. The post also covers the conditions under which the autoscaler stops responding in the five minutes right after a deploy, why scale-down comes down in steps, why memory-based HPA does not fit Node apps, and scaling ahead of time with KEDA.

    25 min read