iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
ScribeToAny says it reduced anonymous visitors’ wait for cached HTML from multi-second cold-edge responses to under 50 ms on an edge-cache hit, while its reported desktop Lighthouse Performance score rose from about 68 to 95. The team’s explanation for the original delay was a mismatch between a 5 ms median Worker CPU time and the larger cost of starting an isolate and loading and compiling a roughly 11 MB bundle.
The account is a first-party case study, not an independent benchmark. Its measurements and outcomes are the ScribeToAny team’s reported results; the detailed write-up was published by Ray Mac on DEV Community on September 8, 2026, and edited September 22. Read the detailed case study.
Why did a 5 ms Worker still take seconds to respond?
ScribeToAny describes its product as an audio and video transcription platform built with React 19 and deployed to Cloudflare Workers. GPU-heavy Whisper transcription, diarization, and translation ran asynchronously on Modal, while the web app’s server-side rendering, authentication, and database queries ran on Workers.
The team reported that Cloudflare Observatory real-user monitoring showed a 75th-percentile time to first byte (TTFB) of 3,128 ms, with more than 57% of hits rated “poor.” It also said direct curl requests to cold edge nodes measured 3.4–3.6 seconds on the homepage and SEO tool pages. Yet the team’s Worker metrics showed a median CPU wall time of 5 ms.
Those figures measure different parts of a request. CPU time describes work performed by the Worker, while TTFB includes the time before the first response byte reaches the client. ScribeToAny’s proposed explanation was that cold requests also paid for isolate creation and the download and compilation of its approximately 11 MB Worker bundle. The team said the app had more than 80 audio, video, conversion, and transcription tool routes, and baseline traffic was around 0.1 requests per second. These are figures reported by ScribeToAny in 2026, not independently verified measurements.
The practical lesson is to measure end-to-end latency as well as handler CPU time. A fast handler does not, by itself, establish that a visitor is receiving a fast response.
How did the team make public pages cacheable?
ScribeToAny used Cloudflare Workers’ caches.default for HTML pages that render the same for anonymous visitors. The point was not to cache every response: the design put explicit checks around which requests could use the shared edge cache.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Restrict cache eligibility
- Bypass cache reads and writes when the request contains a
better-auth.session_tokencookie. - Allowlist public pages such as the homepage, pricing, about, changelog, tools, blog, and legal pages.
- Keep dashboard, API, and settings routes out of the public-page cache.
- Store only HTTP 200 HTML responses that do not include a
Set-Cookieheader.
These conditions help prevent a shared cache from serving personalized content or interfering with session-setting responses. The approach depends on the application’s routes and authentication behavior; a site should define and test its own eligibility rules rather than copy a list blindly.
Make a new deployment use new cache keys
To avoid serving old HTML after a release, the team injected a compile-time build identifier into the cache key as an internal __ev query parameter. According to the write-up, that parameter was used only when matching and storing cache entries—not sent to the client or upstream origin. A changed build identifier therefore made prior entries unreachable under the new key, while they aged out according to their TTL.
The team reported using s-maxage=86400 (24 hours) and stale-while-revalidate=604800 (7 days), and said edge cache hits returned in under 45 ms. Those are the case study’s configuration and result, not a latency guarantee for other Worker deployments or routes.
What did ScribeToAny remove from the initial browser workload?
The team’s second area of work was reducing code and configuration that public visitors received even when they did not need it.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesSplit shared configuration and vendor code
The root layout had imported a site configuration containing metadata, navigation, pricing matrices, and 84 tool route names, according to the case study. ScribeToAny moved tool metadata and pricing calculations into separate modules so a visitor would not load all tool definitions as part of the shared path. It also configured Vite vendor chunks for icons, React, TanStack Query, and Zod.
Keep dashboard-only interface code off public routes
The team removed a global TooltipProvider from public routes and scoped it to the dashboard and editor. It also moved Markdown typography CSS out of the global stylesheet so it would load only on pages that needed it. Both changes target shared work that would otherwise affect pages where the related interface or styling was not used.
How did the team defer below-the-fold and third-party work?
ScribeToAny kept the hero, trust strip, and Whisper section synchronously imported, while wrapping lower page sections in React.lazy() and Suspense with minimum-height fallbacks. The author said those placeholders prevented layout shift and reported that the initial hydration JavaScript payload fell by more than 40%.
The team also moved Google One Tap out of initial hydration. Its implementation used requestIdleCallback with an eight-second fallback and triggered the authentication prompt when the browser was idle or after initial user interaction. The authors characterized this as removing main-thread interference during initial paint; the case study does not establish that the same change will have the same effect for every application.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →What rendering, accessibility, and SEO changes completed the work?
The final pass addressed visual timing and audit findings as well as bundle size. ScribeToAny reported that it:
- Preloaded critical CSS and removed an entrance delay from the main heading.
- Corrected an
aria-orientationvalue and added descriptivearia-labelattributes. - Improved primary-button contrast to meet WCAG AA.
- Replaced vague link text with descriptions that identify their destinations.
The case study links these adjustments to its accessibility and SEO audit results. They are distinct from the edge-cache changes: caching can reduce response delay for eligible requests, while semantic labels, contrast, link text, and CSS loading address other aspects of the page experience and audit scores.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What results did the team report?
ScribeToAny said it ran Google PageSpeed Insights on scribetoany.com. The following figures are the team’s 2026 before-and-after and audit results; they are not independently verified. The reported mobile results were under simulated mobile conditions.
| Measure | Before | After or reported result |
|---|---|---|
| P75 edge TTFB | Approximately 3,128 ms, with 57% of hits rated poor, according to the team’s reported monitoring | Under 50 ms for an edge-cache hit, as reported by the team; cold Worker TTFB was said to be bypassed for anonymous visitors |
| Desktop Lighthouse Performance | Approximately 68 | 95 |
| Simulated mobile Lighthouse Performance | Approximately 42 | 78 |
| Desktop Accessibility | 92 | 100 |
| SEO | 90 | 100 |
| Cumulative Layout Shift (CLS) | 0.03 | 0.00 |
| Desktop Best Practices | Not stated in the case study | 96 |
| Desktop Agentic Browsing audit | Not stated in the case study | 3/3 |
A Lighthouse score is an audit result, not a promise about every visitor’s real-world experience. The reported under-50-ms TTFB applies specifically to an edge-cache hit; it should not be read as the latency of every request, including personalized, uncached, or cold requests. The case study presents one team’s before-and-after implementation, not a controlled comparison of caching against static generation, another runtime, or a different caching policy.
What can other teams take from the case study?
- Track user-facing TTFB alongside CPU time; they describe different parts of the wait.
- Cache shared HTML only when it is genuinely public, and explicitly preserve session and personalized behavior.
- Use a deployment-aware cache key when a release needs to stop matching entries created by an earlier build.
- Keep route-specific configuration, styling, and interface code out of shared initial paths when visitors do not need it.
- Defer below-the-fold sections and third-party work only when the product can tolerate loading them later, and use fallbacks that preserve layout.
- Report lab audit scores with their device and simulation context instead of treating them as universal real-user outcomes.
The publisher’s case-study page lists the same title and a September 8, 2026 date; the detailed account and implementation examples are in Ray Mac’s DEV Community cross-post. ScribeToAny case-study page.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
