Vercel¶

Vercel (vercel.com/blog) is the Frontend-Cloud-and-Next.js company. Tier-3 source on the sysdesign-wiki — the blog carries significant product-launch / marketing load ("Introducing…", "Now supports…", feature- announcement roundups) which is routinely skipped per the wiki's scope rules, but occasional posts are genuine engineering deep- dives or empirical studies and those are on-scope.

Wiki-scope filter¶

Skip: feature launches, v0 / AI SDK release notes, Workflow DevKit roundups, "how we built the v0 iOS app" product-PR posts, hiring posts, company-acquisition PR (e.g. NuxtLabs joining).
Include: empirical-measurement studies (like the 2024-08-01 Google-rendering post), CDN / edge-network internals, rendering- strategy retrospectives with concrete operational numbers, cache-design deep-dives, infrastructure-migration retrospectives, agent-product-reliability mechanism disclosures (like the 2026-01-08 v0 composite-pipeline post), bot-management / adapter-architecture launch posts when adapter-pattern internals (streaming fallback, per-platform rendering, pluggable state) are load-bearing (2026-04-21 Chat SDK).
Borderline: rendering-strategy advice posts — include if anchored on production numbers, skip if pure framework pedagogy.

The current Vercel raw queue has 19 articles with 12 ingested; the remaining 7 skew toward product launches (AI SDK 6, Workflow Builder, v0 iOS app, AgentsMD) — twelve distinct posts (2026-04-21 BotID Deep Analysis, Bun runtime, Knowledge Agent Template, Chat SDK, Workflow DevKit, Content Negotiation, Bloom-filter routing, Inside-Workflow-DevKit framework integrations, 2026-04-21 Turborepo Performance, 2026-04-21 CDN request-collapsing, 2026-04-21 fast-webstreams 10× post, and the original 2024-08-01 MERJ empirical study) have now passed scope on infrastructure-disclosure grounds, retiring the one-dimensional "launch voice = skip" heuristic. The 2026-04-21 fast-webstreams post is the strongest single engineering-deep-dive in the corpus to date — no candidates remain in the queue; remaining posts are launch / PR shape.

Key systems¶

Vercel v0 — Vercel's AI-powered website builder. Canonical wiki instance of the composite model pipeline thesis ("reliability is a pipeline problem, not a single- model problem"). Three-stage composition wrapping the core LLM: dynamic system prompt → LLM Suspense (streaming rewrite) → post-stream autofixers. Disclosed ~10 % baseline LLM-alone error rate reduced by a "double-digit" percentage-point margin via the pipeline.
Vercel AI SDK — Vercel's open-source TypeScript LLM toolkit. Ships major/minor releases regularly, making it the paradigmatic driver of the training-cutoff dynamism gap that v0's dynamic-prompt mechanism exists to fix. The AI SDK team co-maintains with v0 a curated read-only filesystem of LLM-consumption-optimised code samples.
systems/lucide-react — the default icon library v0 generates against; weekly icon-namespace churn is the canonical case of LLM icon hallucination, mitigated by v0's embedding- based name resolution.
Knowledge Agent Template — Vercel's open-source filesystem-based knowledge-agent reference architecture (2026-04-21). Composes five substrates in one deployable artifact: Sandbox (isolated compute with snapshot filesystem loaded), Workflow (Postgres → snapshot repo sync orchestrator), Chat SDK (multi-platform adapter surface), AI Gateway (complexity-router transport), and the AI-powered admin agent. Canonical production datum: 4× cost reduction on Vercel's internal sales-call summariser after replacing the vector pipeline with filesystem + bash.
Vercel Sandbox — isolated compute substrate; per-request sandbox loads the snapshot repo and exposes bash / bash_batch tools to the agent. Canonical agent- retrieval sandbox on the wiki for the patterns/bash-in-sandbox-as-retrieval-tool pattern.
Chat SDK — Vercel's multi-platform adapter framework, TypeScript, open-source public-beta. Adapter set as of 2026-04-21: Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear, WhatsApp. Canonical on-wiki instance of patterns/multi-platform-chat-adapter-single-agent and composition host for three adjacent patterns disclosed in the 2026-04-21 launch post: patterns/platform-adaptive-component-rendering (JSX Table / Card / Modal / Button with native per-platform rendering — Block Kit on Slack, GFM on Teams / Discord, monospace widget on Google Chat, code block on Telegram), patterns/streaming-markdown-to-native-conversion (fallback streaming path with per-intermediate-edit markdown conversion), and patterns/pluggable-state-backend (Redis / ioredis / newly-production-ready Postgres, TTL cache + distributed locks + namespaced prefixes). Also disclosed: WhatsApp adapter's 24-hour messaging window as an SDK-level caveat; bidirectional clear-text name resolution as the minimum-viable benefit even on single-platform deployments; thread.post(result.textStream) as the one-line AI-SDK-stream integration.
Vercel Workflow / Workflow DevKit (WDK) — durable background orchestrator + open- source SDK. Two roles on the wiki: (a) the corpus-sync orchestrator in the Knowledge Agent Template pipeline (2026-04-21 Knowledge Agent Template post); (b) the cross-framework SDK whose integration pattern is the subject of the 2026-04-21 Inside-Workflow-DevKit post — canonical instance of the two- phase framework integration pattern with one SWC plugin, three transform modes (client/step/workflow) and per-framework adapters for 8 frameworks via Nitro shim + per-handler request-converter injection.
Nitro (UnJS) — server toolkit chosen as WDK's build-system shim for bundlerless frameworks (Express, Hono); provides file-based routing, esbuild orchestration, and virtual-handler injection at runtime. One of WDK's two launch-support frameworks alongside Next.js. Not to be confused with AWS Nitro.
Vercel AI Gateway — model-provider abstraction layer; the transport surface for the complexity-router tier dispatch in the Knowledge Agent Template. Adjacent to systems/cloudflare-ai-gateway / systems/instacart-ai-gateway / systems/unity-ai-gateway at different altitudes.
Vercel Edge Functions — V8-isolate-based serverless runtime; the substrate for the Edge Middleware used in the 2024-08-01 bot-beacon-injection study. Prior wiki context: one of three launch-target edge runtimes for PlanetScale's HTTP-based serverless driver (Cloudflare Workers / Netlify Edge Functions / Vercel Edge Functions).
Vercel Routing Service — the single-threaded front door in front of every Vercel deployment. Decides per-request whether to serve, rewrite, or 404. Likely runs on a LuaJIT / OpenResty stack (inferred from the FFI code sample in the 2026-04-21 Bloom-filter post). Canonicalised via the 2026-04-21 Bloom-filter-substitution retrospective: 200× p99 improvement on path lookup; 15 % routing-service heap drop; 10 % aggregate TTFB improvement across every routed request. First wiki-ingested disclosure of this tier.
Vercel CDN — the globally distributed edge-cache tier that sits behind the routing service and handles cache semantics, request collapsing, and response delivery. Three-tier cache hierarchy: per-node in-memory → per-region regional → global ISR cache → function invocation. Canonicalised via the 2026-04-21 request-collapsing post: 3M+ requests/day collapsed on cache miss + 90M+/day on background revalidation, via a two-level lock (in-memory node + distributed regional) with double-checked locking and concepts/lock-timeout-hedging|3 s timeout hedging. Zero-config: the Next.js build output tells the CDN which routes are ISR / SSG / dynamic via framework- inferred cache policy. Sister system to the routing service — together they're Vercel's edge-infrastructure pair (routing decides which backend; CDN decides cache semantics), both zero-config, both consume Next.js build metadata.
Vercel Functions — Vercel's general serverless function primitive (distinct from Edge Functions at the V8-isolate altitude). Runs on Fluid compute with Active CPU pricing. As of 2026-04-21, supports multiple runtimes — Node.js (default) and Bun (public beta) — switchable per project via bunVersion in vercel.json. Canonical wiki instance of patterns/multi-runtime-function-platform.
Fluid compute — the substrate Vercel Functions runs on. Key property: "handles multiple concurrent requests on the same instance." Structural fit with Active CPU pricing — customers pay for on-CPU execution time, not wall-clock including I/O wait.
Bun — JavaScript/TypeScript runtime built in Zig; second runtime launched on Vercel Functions in public beta 2026-04-21. Performance: "28 % latency reduction in CPU-bound Next.js rendering workloads compared to Node.js" (TTLB, 1 vCPU / 2 GB, iad1). Slower cold starts than Node.js; partial Node API compatibility ("edge-case differences may exist").
Hono — lightweight Fetch-API-based web framework; one of four launch-supported frameworks for Bun on Vercel Functions (alongside Next.js, Express, Nitro).
Next.js — Vercel-backed React application framework. The measured site (nextjs.org) runs a mix of SSG / ISR / SSR / CSR + React Server Component streaming; Googlebot renders all of it 100 %.
Vercel BotID — Vercel's edge bot-detection product for "sensitive routes like login, checkout, AI agents, and APIs." Ships with a standard single-pass classification path and a sophisticated Deep Analysis sub-path that runs cross-session correlation and forced re-verification. The 2026-04-21 production-incident post discloses a 10-minute hands-free detect-to-zero-traffic window on a 40-45-profile coordinated bot fleet.
Kasada — branded third-party ML backend that powers Vercel BotID / Deep Analysis. Wiki-first disclosure via the 2026-04-21 post; strategic dependency.
Turborepo — Vercel's Rust- written task runner for JavaScript / TypeScript monorepos; every turbo run constructs a task graph before executing any work. Subject of Anthony Shew's 2026-04-21 retrospective — 8-day agent-assisted campaign that drove Time to First Task 8.1 s → 716 ms on Vercel's 1,000-package monorepo (91 % faster in v2.9.0). Turborepo's --profile flag emits Chrome Trace Event Format JSON that loads directly in Perfetto; the turborepo-profile-md crate (PR #11880) adds an agent-friendly companion format.
Perfetto — Chromium's successor to chrome://tracing; the UI Vercel engineers use to visualise Turborepo profiles. The post's critique of the format applies to consumption by agents, not the UI itself.
hyperfine — the Rust CLI benchmark tool (warmup + many-runs + statistical reporting) used as the end-to-end validation gate in the supervised Plan-Mode-then-implement loop.
xxhash-rust — the faster hashing crate Turborepo swapped to from twox-hash for a ~6 % task-graph-construction win (PR #11874). One of 3 PRs produced by the 8-agent phone-spawn experiment.

Key concepts / patterns canonicalised (from Vercel posts)¶

Routing-service axis (2026-04-21 Bloom-filter post)¶

concepts/bloom-filter — canonical wiki concept page (first-class introduction via the Vercel case). Compact probabilistic set-membership structure: never false negatives, bounded false positives, O(k) query cost.
concepts/probabilistic-data-structure — parent family. Space-for-accuracy trade-off; canonical members include Bloom, HyperLogLog, DDSketch, count-min sketch.
concepts/false-positive-vs-false-negative-asymmetry — the design principle behind substrate choice. Path-lookup false negatives are SEO-damaging; false positives are one extra storage roundtrip. The asymmetry motivates the Bloom-filter substitution.
concepts/event-loop-blocking-single-threaded — why a 250 ms JSON parse on one heavy tenant degrades every concurrent request's latency. The 15 % aggregate memory / CPU drop post-migration is evidence the blocking was cross-polluting every tenant's latency.
concepts/path-enumeration-attack — the security side-benefit: pre-storage membership check denies attackers timing / storage side-channels they'd use to probe the directory structure.
concepts/base64-as-byte-buffer-inline — the zero-allocation decode technique. LuaJIT FFI uint8_t[256] decode table + direct-buffer byte reads during membership queries — never materialise the decoded byte string.
patterns/bloom-filter-membership-test-before-storage-fetch — the composite pattern. Hot-path filter check + fallback authoritative storage check. Canonical wiki case.
patterns/jsonl-parameters-plus-base64-payload — the file format. Line 1 JSON parameters; line 2 Base64 payload. Self-describing, text-safe, zero-tool-dep.

Agent-reliability axis (2026-01-08 v0 post)¶

concepts/llm-code-generation-error-rate — first wiki disclosure: "code generated by LLMs can have errors as often as 10 % of the time."
concepts/training-cutoff-dynamism-gap — model parametric knowledge frozen at cutoff vs. frequently- releasing library; AI SDK + lucide-react are the paradigmatic instances.
concepts/llm-icon-hallucination — named failure mode: LLM references icons "that no longer exist or never existed."
concepts/web-search-telephone-game — small summariser model between search results and parent model "becomes a bad game of telephone."
concepts/prompt-cache-consistency — dynamic-prompt injection kept stable within intent class to preserve prompt-cache hits.
patterns/composite-model-pipeline — the overarching pipeline shape.
patterns/dynamic-knowledge-injection-prompt — intent- detect via embeddings + keywords, inject version-pinned library knowledge into the system prompt; preferred over web-search RAG.
patterns/streaming-output-rewrite — LLM Suspense: token- stream find-and-replace + embedding-resolved rewrites that run during streaming so "the user never sees an intermediate incorrect state."
patterns/embedding-based-name-resolution — verbatim five-step mechanism for churning-namespace library APIs; canonical Triangle as VercelLogo worked example.
patterns/deterministic-plus-model-autofixer — AST-based invariant detection + small fine-tuned placement model; <250 ms, conditional.
patterns/read-only-curated-example-filesystem — co- maintained with library vendor; agent searches the fs instead of web-searching.

Runtime / platform axis (2026-04-21 Bun launch)¶

concepts/active-cpu-pricing — billing model where customers pay for on-CPU execution time, not wall-clock including I/O wait; structural fit with Fluid compute's multi-request-per-instance shape.
concepts/ttfb-vs-ttlb-ssr-measurement — Vercel's methodology pivot for SSR benchmarking. TTFB rewards shell flush; TTLB captures per-chunk transform + GC cost. The 28 % Bun advantage is a TTLB number.
concepts/web-streams-as-ssr-bottleneck — the profiling finding. "Buffer scanning and data conversions added measurable CPU cost. Garbage collection also consumed a significant share of total processing time under heavy load." Sibling to Cloudflare's same-quarter finding at a different runtime.
concepts/runtime-choice-per-workload — the design axis Vercel's multi-runtime launch opens: runtime is a per-workload choice on four trade-off dimensions (performance, cold start, compatibility, ecosystem).
patterns/multi-runtime-function-platform — Vercel Functions as canonical wiki instance: Node.js + Bun native on the same platform, no emulation, per-project bunVersion config axis.
patterns/workload-aware-runtime-selection — the customer-side pattern pairing with the platform pattern: pick runtime based on dominant cost axis of the workload.

Knowledge-agent axis (2026-04-21 Knowledge Agent Template post)¶

concepts/filesystem-as-retrieval-substrate — filesystem + bash as alternative to vector DB; rides on LLMs' code-training skill distribution.
concepts/embedding-black-box-debugging — three- axis failure taxonomy (chunking boundary + embedding model + similarity threshold) explaining why vector- DB wrong-answers are opaque to debug.
concepts/snapshot-repository-as-agent-corpus — versioned immutable corpus view as middle tier between live admin DB and per-request sandbox.
concepts/traceability-of-retrieval — success property distinguishing filesystem search from vector search: "debugging a question, not a pipeline."
patterns/bash-in-sandbox-as-retrieval-tool — the canonical retrieval pattern; bash / bash_batch tools against a snapshot-loaded sandbox filesystem.
patterns/multi-platform-chat-adapter-single-agent — one agent pipeline fronted by per-platform adapters; canonical Chat SDK shape.
patterns/snapshot-sync-from-postgres-to-repo — Workflow-driven async producer for the snapshot repository.
patterns/ai-powered-admin-agent-self-debug — meta-agent with read-only tools over primary agent's telemetry; "debug your agent with an agent."
Extends patterns/complexity-tiered-model-selection with the chatbot-router altitude (always-on per-question classification via AI Gateway transport, not per-input heuristic).
Extends patterns/read-only-curated-example-filesystem from library-API altitude (v0 × AI SDK) to arbitrary enterprise corpora altitude.
Extends concepts/grep-loop with the paired inverse framing: bounded-corpus sandbox grep is desired retrieval, unbounded-web-doc grep is failure mode.
Extends concepts/web-search-telephone-game with retrieval-pipeline-altitude dual at the vector-DB layer.

Bot-management axis (2026-04-21 BotID Deep Analysis post)¶

concepts/browser-telemetry-fingerprint — browser-side telemetry (fingerprints + behavioural patterns) as the content-independent feature set Kasada's classifier operates on. Sibling of concepts/ml-bot-fingerprinting at the TLS/HTTP layer.
concepts/proxy-node-correlation-signal — the "tell-tale sign" of coordinated bot activity: identical browser fingerprints appearing across multiple proxy-node IPs.
concepts/adaptive-bot-reclassification — the short window (~4 minutes in the canonical incident) during which a novel stealth bot is classified as human before a correlation signal triggers reclassification.
concepts/coordinated-bot-network — 40-45 browser profiles sharing fingerprint shape while diverging on proxy-node IPs; the attack class Deep Analysis is designed to catch.
patterns/correlation-triggered-reverification — on coordination trigger, force sessions back through fresh telemetry collection and re-score with correlation priors, rather than blocking directly.
patterns/hands-free-adaptive-bot-mitigation — the product-design property: the full detect-correlate- reclassify-mitigate loop runs inside the ML backend with zero customer-authored rule changes.

SEO / rendering axis (2024-08-01 Google rendering post)¶

concepts/universal-rendering — Google's post-2018 pipeline renders every HTML page, not just JS-heavy ones.
concepts/stateless-rendering — Google renders each page with no cookies, no state, no click interactions.
concepts/rendering-queue — the Web-Rendering-Service queue that mediates crawl → render → index.
concepts/rendering-delay-distribution — p50 = 10 s, p75 = 26 s, p99 ≈ 18 h on nextjs.org (April 2024).
concepts/client-side-removal-of-noindex-ineffective — Google enforces noindex pre-render; client-side JS removal never runs.
concepts/link-discovery-vs-link-value-assessment — Google discovers links via body-text regex at crawl time; assesses link value only after render.
concepts/google-asset-caching-internal-heuristics — WRS decides asset freshness internally, independent of HTTP Cache-Control.
concepts/crawl-budget-impact-of-js-complexity — CSR tax on 10,000+ page sites.
concepts/rendering-strategy-crawl-efficiency-tradeoff — SSG / ISR / SSR / CSR × Google-facing capabilities matrix.
patterns/edge-middleware-bot-beacon-injection — measure your own search-engine rendering by injecting a JS beacon from edge middleware on bot requests.
patterns/server-beacon-pairing-for-render-measurement — recover a rendering-delay distribution by pairing server access logs with post-render client-side beacons.
patterns/link-in-non-rendered-json-payload-discovery — Google extracts URLs via regex over the full response body, including non-rendered JSON payloads.

Agent-friendly-docs axis (2026-04-21 Content Negotiation post)¶

concepts/markdown-content-negotiation — second-vendor instance (after Cloudflare's 2026-04-17). Vercel's measured datum: 99.37 % payload reduction (~500 KB HTML → ~3 KB markdown) on one representative blog post via Accept: text/markdown negotiation.
concepts/markdown-sitemap — new canonical concept. Hierarchical markdown table-of-contents served at /blog/sitemap.md / /docs/sitemap.md as an agent- navigable alternative to flat XML sitemaps. Two canonical shapes: flat-by-date for blog, recursive- hierarchy for docs.
patterns/accept-header-rewrite-to-markdown-route — canonical Next.js implementation pattern. next.config.ts rewrites rule with has header matcher routes header-matching requests to a dedicated /md/:path* route handler that performs CMS rich-text → markdown conversion on the fly. Portable to nginx / Caddy / Express / CloudFront / Fastly.
patterns/link-rel-alternate-markdown-discovery — new canonical pattern. <link rel="alternate" type="text/markdown" title="LLM-friendly version" href="/llms.txt"> in HTML <head> as the third layer of a three-layer agent-discovery stack (Accept header → markdown sitemap → link rel=alternate), covering agents that fetched HTML without sending the header but do parse <head>.
Architectural argument preserved: "content negotiation requires no site-specific knowledge" — Vercel's explicit framing against URL-suffix conventions like Cloudflare's /index.md. The two primitives compose (a site can expose both) but Vercel argues for Accept-header-as-primary on cross-site-composability grounds.

Agent-assisted engineering axis (2026-04-21 Turborepo Performance post)¶

Canonicalises the eighth Vercel axis — agent-assisted performance engineering — via Anthony Shew's 2026-04-21 retrospective of an 8-day campaign that drove Turborepo's task-graph construction 91 % faster (Time to First Task 8.1 s → 716 ms on 1,000- package monorepo). Distinct from the knowledge-agent axis (Vercel Sandbox as agent-execution substrate) — this axis canonicalises Vercel Sandbox as a benchmarking substrate and the supervised-agent loop as a performance-engineering discipline.

CDN / caching axis (2026-04-21 Request Collapsing post)¶

Canonicalises the ninth Vercel axis — edge-CDN cache-stampede prevention — via the 2026-04-21 request-collapsing deep dive on the Vercel CDN. Canonical primitives named: concepts/request-collapsing (per-region dedup of concurrent cache misses), concepts/cache-stampede (the TH sub-shape at the cache-miss boundary), concepts/double-checked-locking (correctness protocol), concepts/two-level-distributed-lock (node + regional lock topology; the node level is explicitly there to prevent the regional lock from itself becoming a TH bottleneck), concepts/lock-timeout-hedging (3 s bounded-wait- then-hedge policy). Canonical pattern named: patterns/framework-inferred-cache-policy (CDN learns per-route cacheability from Next.js build output, zero-config). Canonical system named: systems/vercel-cdn (distinct from systems/vercel-routing-service — routing decides which backend, CDN decides cache semantics). Operational numbers: 3M+/day collapsed on cache miss + 90M+/day on background revalidation on the Vercel CDN, 100% of ISR projects auto-enrolled. This is a sister axis to the routing-service axis — both post groups describe edge-infrastructure systems at Vercel with zero-config adoption via framework- integration and both ship metadata from Next.js build output to every CDN region at deploy time. Together the Bloom-filter routing post + this request-collapsing post form the Vercel edge-infrastructure pair.

Streaming-runtime-perf axis (2026-04-21 fast-webstreams post)¶

Canonicalises the tenth Vercel axis — userland reimplementation of a W3C standard API + upstream PR landing — via the 2026-04-21 fast-webstreams post. Canonical new system: systems/fast-webstreams (experimental-fast-webstreams on npm; reimplementation of ReadableStream / WritableStream / TransformStream on top of Node's older stream.* classes; 1,100 / 1,116 WPT passes; up to 14.6× native on the React Flight pattern). Three other new systems: systems/lite-readable (minimal array-based Readable replacement for byte streams), systems/react-flight (the extremum benchmark workload), systems/wpt-web-platform-tests (the conformance oracle that made AI-driven reimplementation tractable). Three new concepts: concepts/synchronous-fast-path-streaming (buffered read() returns Promise.resolve() — the spec-compliant allocation elimination that landed upstream in Node PR #61807 at ~17-20 % native buffered-read improvement), concepts/spec-compliant-optimization (the "observability-preserving allocation removal" discipline; WPT as the oracle), concepts/microtask-hop-cost (per-read scheduling cost that cannot be eliminated, only batched around). Three new patterns: patterns/ai-reimplementation-against-conformance-suite (the AI + WPT + benchmarks inner loop — "built most of fast-webstreams with AI"), patterns/record-pipe-links-resolve-at-sink (deferred pipeThrough resolution + single stream.pipeline() call at sink; zero per-chunk Promises), patterns/global-patch-constructors-for-runtime-optimization (patchGlobalWebStreams() replaces globals + Response.prototype.body accessor; transparent fleet rollout mechanism). Extends patterns/upstream-contribution-parallel-to-in-house-integration (library + Node.js PR #61807 in parallel) and patterns/tests-as-executable-specifications (WPT as the canonical cross-runtime executable-spec corpus). Operational numbers: 1,100/1,116 WPT passes (vs native 1,099); 14.6× / 9.8× / 3.7× / 3.2× on four measured patterns; PR #61807 lands ~17-20 % buffered-read + ~11 % pipeTo improvement for every Node.js user. Load-bearing quote: "The spec is smarter than it looks. We tried many shortcuts. Almost every one of them broke a Web Platform Test, and the test was usually right." This axis sits at the opposite altitude from the Bun runtime axis — same profiling diagnosis (Web-Streams + GC), different mitigation surface. The Bun axis argues runtime switch is the lever; this axis argues library/upstream is the lever. The two are not contradictory — they stack: fast- webstreams on Bun is untested, but both can attack the same pathology on different margin axes.

systems/turborepo — new system; Rust-written task runner for JS monorepos; the subject of the campaign. Task-graph construction is a first-order cost (paid before first task runs) that scales with repo size; 1,000-package monorepos paid 8.1 s per invocation before v2.9.0.
systems/perfetto — new system; Chromium project's trace visualiser, consumes Chrome Trace Event Format JSON. Canonical UI consumer whose JSON format's agent-hostility motivated the Markdown companion.
systems/hyperfine — new system; Rust-written CLI benchmark tool (warmup + many-runs + statistical reporting) used as the end-to-end validation gate.
systems/xxhash-rust — new system stub; the faster hashing crate Turborepo swapped to from twox-hash for a ~6 % win (PR #11874).
systems/vercel-sandbox (extended) — this ingest adds the benchmarking-substrate altitude to the prior agent-execution-substrate framing. Same primitive, two canonical uses.
concepts/markdown-as-agent-friendly-format — new concept; line-per-record + column-alignment + grep- friendliness makes Markdown materially better for agent consumption than UI-optimised JSON/binary formats. Canonical heuristic: "if something is poorly designed for me to work with, it's poorly designed for an agent, too."
concepts/chrome-trace-event-format — new concept; documents the specific structural properties of Chromium's trace JSON (line-split function names, single-letter keys, interleaved metadata) that hurt agent reasoning.
concepts/sandbox-benchmarking-for-signal-isolation — new concept; the practice of running A/B benchmarks inside an ephemeral minimal-dependency container specifically to eliminate the laptop noise floor. Critical caveat: within-sandbox A/B only (no dedicated-hardware guarantee across sandboxes).
concepts/source-code-as-agent-feedback-loop — new concept; canonicalises Shew's observation that merged source code becomes the agent's implicit long-term memory across sessions without explicit context transfer. "Your own source code is the best reinforcement learning out there." Distinct from the explicit CONTEXT.md pattern.
concepts/agent-hyperfixation-failure-mode — new concept; canonical named failure mode where agents commit to first hypothesis and verbalise the need to reconsider without actually reconsidering.
concepts/microbenchmark-vs-end-to-end-gap — new concept; canonical 97 % microbench / 0.02 % end-to-end datapoint. Agents chase the biggest microbenchmark number absent an end-to-end validation gate.
concepts/run-to-run-variance — new concept; measurement-noise floor; canonical variance- reduction datum from PR #11984 stack-allocated OidHash (48 % / 57 % / 61 % variance reduction across three repo sizes). Variance reduction is a real performance win even when the mean stays the same.
patterns/markdown-profile-output-for-agents — new canonical pattern; emit companion .md alongside profile JSON; keeps Perfetto working while giving the agent line-per-record tables. Turborepo turborepo- profile-md crate; precedent in Bun's --cpu-prof-md.
patterns/ephemeral-sandbox-benchmark-pair — new canonical pattern; cross-compile main + branch, load both into one sandbox, hyperfine --warmup 2 --runs 15 'main' 'branch', collect reports. The single-sandbox-instance invariant is load-bearing.
patterns/plan-mode-then-implement-agent-loop — new canonical pattern; supervised 5-step loop (agent Plan Mode → human review → agent implement → hyperfine validate → PR). 20+ PRs in 4 days in the Turborepo campaign. Sibling to Cloudflare Agent Memory's benchmark- score-validated loop at the wall-clock-validated altitude.
patterns/agent-spawn-parallel-exploration — new canonical pattern; fan out N unattended agents with prompt variations overnight, review results asynchronously. 3 of 8 shippable (37 % yield) is the canonical unattended-agent baseline datum at Vercel-internal-prompt-quality on Rust-performance work.
patterns/codebase-correction-as-implicit-feedback — new canonical pattern; merge corrections once, future agent sessions discover them implicitly. Complement to Figma's explicit CONTEXT.md pattern and Shopify's hybrid in-code annotations. Three altitudes of codebase-as-agent-substrate.
Extends patterns/measurement-driven-micro-optimization with the agent-augmented supervised-loop altitude. The parent pattern's discipline (profile → target → fix → validate) stays intact; this ingest adds the agent-mediated-proposal-and-implementation axis.
Extends concepts/flamegraph-profiling with the markdown-format-for-agent-consumption altitude. Prior canonical instances (Fly.io 2025-02, Netflix 2026-03) were human-reader altitudes; this ingest opens the agent-reader altitude.
Extends concepts/monorepo with the task-graph-construction-as-monorepo-tax framing. The canonical 8.1 s → 716 ms Turborepo datum is the first wiki-canonical number for this specific monorepo-scale cost.

Recent articles (most recent first)¶

2026-04-21 — We Ralph Wiggum'd WebStreams to make them 10x faster · Vercel's 2026-04-21 engineering retrospective on fast-webstreams, an experimental npm library reimplementing the WHATWG Streams API on top of Node.js's older stream.* internals. Headline numbers at 1 KB chunks on Node v22: 14.6× native on the React Flight byte-stream pattern (1,600 MB/s vs 110 MB/s); 9.8× on chained pipeThrough (6,200 vs 630 MB/s); 3.7× on read loops; 3.2× on fetch() → 3 transforms. Passes 1,100 / 1,116 Web Platform Tests (native Node passes 1,099) — built via an AI-driven reimplementation workflow gated by the WPT suite + a locally-built benchmark suite (patterns/ai-reimplementation-against-conformance-suite). Core architectural primitives: (1) patterns/record-pipe-links-resolve-at-sink — pipeThrough records upstream links without piping; pipeTo() at sink walks the chain and fires a single stream.pipeline() call, zero per-chunk Promises; (2) concepts/synchronous-fast-path-streaming — buffered read() returns Promise.resolve({value, done}) directly; (3) LiteReadable — minimal array-based byte-stream buffer with direct callback dispatch (no EventEmitter), ~5 µs less per construction; (4) patchGlobalWebStreams() — replaces global constructors + Response.prototype.body accessor, unmodified consumer code hits fast paths. Two ideas landed upstream via Node.js TSC member Matteo Collina's PR nodejs/node#61807 — ~17-20 % faster buffered reads, ~11 % faster pipeTo natively; canonical patterns/upstream-contribution-parallel-to-in-house-integration instance at streaming-runtime altitude. Load-bearing diagnostic quote: "The spec is smarter than it looks. We tried many shortcuts. Almost every one of them broke a Web Platform Test, and the test was usually right." 4 new systems (systems/fast-webstreams, systems/lite-readable, systems/react-flight, systems/wpt-web-platform-tests) + 3 new concepts (concepts/synchronous-fast-path-streaming, concepts/spec-compliant-optimization, concepts/microtask-hop-cost) + 3 new patterns (patterns/ai-reimplementation-against-conformance-suite, patterns/record-pipe-links-resolve-at-sink, patterns/global-patch-constructors-for-runtime-optimization). Extends systems/web-streams-api (third primary source on performance critique; table of fast/native deltas), systems/nodejs (upstream PR landing path), concepts/promise-allocation-overhead (canonical primary source of 12.5× gap + enumeration of the 4 per-read() allocations), concepts/web-streams-as-ssr-bottleneck (first library-level mitigation with measured numbers), concepts/stream-adapter-overhead (inverted-adapter instance — adapter runs faster than native), systems/bun (counter-lever: Node streaming gap is closable at library/upstream level, not only by runtime switching), systems/vercel-functions (planned fleet rollout target). Seventh 2026-04-21 Vercel ingest.
2026-04-21 — Preventing the stampede: Request collapsing in the Vercel CDN · Vercel's 2026-04-21 engineering post documenting the CDN request-collapsing feature that prevents cache stampedes on ISR routes. The mechanism: when many concurrent requests hit the same uncached cacheable path, a two-level distributed lock (per-node in-memory + per-region distributed) + double- checked locking + [[concepts/lock-timeout-hedging|3 s lock timeout on both levels]] ensures one function invocation per region; all other waiters receive the cached response once it's populated. Canonical numbers: 3M+ requests/day collapsed on cache miss + 90M+/day on background revalidation (~30×). Zero- config adoption: the Next.js build output tells the CDN which routes are ISR / SSG / dynamic via framework- inferred cache policy — same pattern as the 2026-04-21 Bloom-filter routing post (both Vercel edge systems consume Next.js build metadata, both are zero-config for developers). The node-level lock is specifically there to prevent the regional lock from itself becoming a thundering herd bottleneck on popular keys — Vercel explicitly frames TH as the failure mode at both the cache-miss layer (the problem being solved) and the naive-lock layer (the failure mode of a careless fix). Canonical CDN-altitude request collapsing deep dive on the wiki; sister primitive to Vitess query consolidation at the SQL-proxy altitude, Go's singleflight in-process, and Envoy's request hedging at the RPC altitude — all applying the same idiom (dedup concurrent identical work) at different layers. Scope-rationale: clear include on edge-infrastructure grounds — the post is a dedicated single-feature CDN architectural deep dive with implementation sketch (node lock + regional lock + double-checked locking + lock timeouts), production numbers, and explicit failure modes (error caching policy, slow-invocation hedging, three cacheability classes distinguished). Caveats captured: lock substrate not named, no latency distributions, global-cold-miss behaviour accepted as N regional invocations, negative-caching policy absent, stale-while-revalidate interaction not explicitly described (but implied by the 90M/day background-revalidation collapsing figure).
2026-04-21 — Making Turborepo 96 % faster with agents, sandboxes, and humans · Anthony Shew's 2026-04-21 engineering retrospective on an 8-day performance campaign that improved Turborepo's task-graph construction time by 81-91 % on Vercel's internal repositories (up to 96 % on external customer repos). Canonical headline: Time to First Task on Vercel's 1,000-package monorepo dropped from 8.1 s → 716 ms (91 % faster, 11× speedup) in v2.9.0. The post is simultaneously a performance retrospective (three categories of wins: parallelisation, allocation elimination, syscall reduction — with PR numbers) and an engineering-process retrospective on what unattended and supervised AI agents actually delivered. Five load-bearing architectural lessons: (1) Markdown profile output beats Chrome Trace Event JSON for agent consumption — same model + harness + data, "radically better optimization suggestions" after adding a turborepo-profile-md crate emitting a companion .md alongside the JSON (PR #11880); canonical heuristic verbatim "if something is poorly designed for me to work with, it's poorly designed for an agent, too"; (2) Vercel Sandbox provides clean-signal benchmarking laptops can't — laptop noise drowns out 2 % real wins once code gets fast enough; sandbox eliminates ambient load so hyperfine A/B becomes reliable; critical caveat: within-sandbox A/B only, no dedicated-hardware guarantee across sandboxes; (3) Source code is implicit long-term agent memory — merged corrections propagate across new conversations without any explicit context transfer; "your own source code is the best reinforcement learning out there"; (4) Five unattended-agent failure modes ( hyperfixation, microbenchmark-vs-end-to-end gap, no dogfood-loop awareness, no regression tests, no --profile usage) motivating the supervised Plan-Mode-then-implement loop; (5) Plan-Mode-then-implement beats unattended spawn for production-critical work — 20+ performance PRs in 4 days via the supervised loop. 15 new canonical pages: source + 4 systems (systems/turborepo, systems/perfetto, systems/hyperfine, systems/xxhash-rust) + 6 concepts (concepts/markdown-as-agent-friendly-format, concepts/chrome-trace-event-format, concepts/sandbox-benchmarking-for-signal-isolation, concepts/source-code-as-agent-feedback-loop, concepts/agent-hyperfixation-failure-mode, concepts/microbenchmark-vs-end-to-end-gap, concepts/run-to-run-variance) + 5 patterns (patterns/markdown-profile-output-for-agents, patterns/ephemeral-sandbox-benchmark-pair, patterns/plan-mode-then-implement-agent-loop, patterns/agent-spawn-parallel-exploration, patterns/codebase-correction-as-implicit-feedback). Extends systems/vercel-sandbox with the benchmarking-substrate altitude (prior canonicalisation was per-request agent sandbox only); extends patterns/measurement-driven-micro-optimization with agent-augmented supervised-loop altitude. Canonical operational numbers: 91 % / 81 % / 80 % Time-to-First-Task improvement on 1000 / 132 / 6 package repos; 8 background agents → 3 of 8 shippable (37 % yield); 20+ PRs in 4 days via supervised loop; PR #11984 stack-allocated OidHash dropped new_from_gix_index self-time 15 % and run-to-run variance 48 % / 57 % / 61 % across three repo sizes; PR #11985 syscall elimination dropped fetch self- time 35 % over 962 cache fetches; without agents Shew estimates ≥ 2 months to complete same campaign. This is the tenth Vercel ingest + opens the agent-assisted engineering axis (eighth Vercel axis after SEO/rendering, agent-reliability, bot- management, platform-runtime, knowledge-agent, content-negotiation, routing-service, workflow-devkit). Tier-3 on-scope decisively on concrete-operational- datum + vocabulary-canonicalisation + architectural- density grounds.
2026-04-21 — Making agent-friendly pages with content negotiation · Vercel's 2026-04-21 engineering post documenting production implementation of HTTP markdown content negotiation across vercel.com/blog and vercel.com/changelog, second major vendor instance after Cloudflare's 2026-04-17 Agent Readiness Score rollout. Mechanism: Next.js next.config.ts rewrites rule with has: [{ type: 'header', key: 'accept', value: '(.*)text/markdown(.*)' }] routes Accept: text/markdown requests internally to a dedicated /md/:path* route handler that converts CMS rich text to markdown on the fly. Canonical datum: ~500 KB HTML → ~3 KB markdown = 99.37 % payload reduction on one representative blog post — a different measurement axis from Cloudflare's 80 % token-reduction claim (server-side bytes vs client-side tokens). Also introduces markdown sitemaps (flat for /blog/sitemap.md, hierarchical recursive for /docs/sitemap.md) as a companion agent- discovery primitive contrasting with flat XML sitemaps, and a <link rel="alternate" type="text/markdown" href="/llms.txt"> tag in HTML <head> as the third discovery layer for agents that don't send the header. Three-layer agent- discovery stack (Accept header → markdown sitemap → link rel=alternate) covers different agent-implementation gaps. Also named: Next.js 16 remote cache (use cache) keeping HTML and markdown synchronised via shared slug keys. Architectural-composability argument: "content negotiation requires no site-specific knowledge" — any agent that sends the right header gets markdown from any site that supports it, without per-site URL-convention knowledge. New canonical wiki patterns: patterns/accept-header-rewrite-to-markdown-route (Next.js-specific but portable to nginx/Caddy/CloudFront/ Lambda@Edge/Fastly) and patterns/link-rel-alternate-markdown-discovery. Scope-rationale: clear include on web-standards- implementation grounds; Vercel's second-vendor independent validation of a primitive where prior only Cloudflare had disclosed production details.
2026-04-21 — Inside Workflow DevKit: How framework integrations work · Vercel's 2026-04-21 engineering post on how the Workflow Development Kit (WDK) integrates with 8 frameworks (Next.js, Nitro, SvelteKit, Astro, Express, Hono, + 2 others) without writing N independent integrations. Load-bearing thesis verbatim: "What looks like six different problems is really one problem solved six different ways." Canonical two- phase integration pattern — build-time handler generation + runtime handler exposure — with per-framework adapters at the bridge points. Three core mechanisms disclosed: (1) one SWC compiler plugin, three transform modes — client / step / workflow (patterns/swc-plugin-three-mode-transform) — emits three deployment artefacts from one source file by reading "use workflow" / "use step" directives. (2) Nitro shim for bundlerless frameworks — Express + Hono lack a build system; WDK uses Nitro to esbuild-bundle workflows + mount them as virtual handlers injected into the user's HTTP server at runtime (patterns/virtual-handler-via-nitro-for-bundlerless-frameworks). (3) Per-handler injected request converter — instead of a fat cross-framework abstraction, WDK injects a small convertSvelteKitRequest-style function into each generated handler to bridge framework-specific request shapes to the standard Web Request API (patterns/injected-request-object-converter). HMR integration via Vite's hotUpdate hook with a directive-regex gate before triggering esbuild rebuild (patterns/vite-hotupdate-directive-triggered-rebuild). Framework taxonomy made explicit: file-based-routing vs bare-HTTP frameworks (concepts/file-based-routing-vs-bare-http-framework-taxonomy). Vite-based frameworks (SvelteKit, Astro, Nuxt) share ~90% of integration code via "core Vite integration once, adapted per framework". Launch-voice post but architecture density ~55% (four named mechanisms + one taxonomy — all new-to-wiki). Adoption claim: >1,300 GitHub stars. Fifth 2026-04-21 Vercel ingest to recalibrate the launch-voice = skip heuristic; now five consecutive same-day Vercel posts have required override. 13 wiki pages touched: source + 4 new systems (Nitro UnJS, SvelteKit, systems/express, systems/esbuild) + 3 new concepts (concepts/use-directive-as-compilation-marker, concepts/build-time-vs-runtime-phase-separation, concepts/file-based-routing-vs-bare-http-framework-taxonomy)
5 new patterns (the four named + two-phase-framework- integration) + extensions to systems/vercel-workflow, systems/hono, systems/astro, systems/vite, systems/rollup, systems/nextjs.
2026-04-21 — How we made global routing faster with Bloom filters · Vercel's 2026-04-21 engineering retrospective on replacing the global routing service's per-deployment path-lookup JSON tree with a Bloom filter. The prior substrate was a JSON file enumerating every deployed path (static assets, pages, API routes, webpack chunks, Next.js route segments); at scale (e-commerce catalogues, documentation sites, dynamic-routing apps) these files reached 1.5+ MB, taking ~100 ms at p99 and ~250 ms at p99.9 to parse on the routing service's single-threaded reactor — blocking every concurrent request for the full parse duration. Bloom-filter substitution exploits the false-positive vs false-negative asymmetry of the problem: a false negative would wrongly 404 a valid page (SEO damage, broken links); a false positive costs one extra storage fetch that correctly 404s. Measured results: path-lookup p99 drops ~100 ms → ~0.5 ms (200×); p999 drops ~250 ms → ~2.4 ms (100×); routing-service heap / memory drops 15 %; TTFB p75–p99 across all routed requests improves 10 % (the last number reaches traffic that never went anywhere near the heavy-site tenants — because the previous heavy-site parse cost had been stealing reactor time from every other tenant on the same process). File format is two-line JSONL: parameters JSON + Base64 bit array with n, p, m, k, s Bloom-filter parameters on line 1 and the bit array Base64-encoded on line 2. The routing service reads the Base64 data as a byte buffer directly, decoding sextets on demand during membership queries via a LuaJIT FFI uint8_t[256] decode table — never materialising the decoded byte array as a string (concepts/base64-as-byte-buffer-inline). The membership check doubles as an enumeration-attack defence: uniform fast 404s for non-existent paths deny attackers the timing / storage side-channels they'd use to probe a deployment's directory structure. Canonical load-bearing pattern: patterns/bloom-filter-membership-test-before-storage-fetch. Fifth Vercel ingest on the wiki; opens the routing-service infrastructure axis alongside the six prior axes (SEO / rendering 2024-08-01, agent-reliability 2026-01-08, bot-management, runtime / platform, knowledge-agent, chat-adapters). Architecturally load- bearing quotes: "Bloom filters can return false positives, but never false negatives. For path lookups, this property is valuable. If the Bloom filter says a path does not exist, we can safely return a 404; if it says a path might exist, we fall back to checking the build outputs." and "Given that our routing service is single-threaded, parsing this JSON file also blocks the event loop. This means that for those websites whose path lookups take 250 milliseconds to parse, it literally takes 250 milliseconds longer to serve the website while we wait for the operation to finish." Tier-3 on-scope decisively — genuine engineering retrospective with mechanism depth + canonical operational numbers + cross- service coordination disclosure, unambiguously above the Tier-3 borderline.
2026-04-21 — Chat SDK brings agents to your users · Vercel's launch post for the open-source, public-beta Chat SDK — a TypeScript library for building chat bots that run on Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear, and WhatsApp from a single codebase. Architectural thesis: adapter-based factoring, analogous to AI SDK's model-provider abstraction — "just like the AI SDK unified model provider APIs into a single interface, we built Chat SDK to abstract the quirks of messaging APIs into a simple framework for developers and their coding agents." Canonical wiki instantiation of multi- platform chat adapter with single shared agent (fills a prior dangling-link debt from the 2026-04-21 Knowledge Agent Template post). Three substantive substrate disclosures: (1) streaming-fallback design — Slack has a native path rendering formatting in real time; other platforms use a fallback path "passing streamed text through each adapter's markdown-to-native conversion pipeline at each intermediate edit" so users no longer see literal **bold** mid-stream (patterns/streaming-markdown-to-native-conversion); (2) component-rendering matrix — JSX <Table> / <Card> / <Modal> / <Button> rendered natively per platform (Block Kit on Slack, GFM markdown on Teams / Discord, monospace widget on Google Chat, code block on Telegram, WhatsApp interactive reply buttons with ≤3 options) with graceful fallback (patterns/platform-adaptive-component-rendering); (3) pluggable state adapters — Redis / ioredis (launch) + Postgres now production-ready (PR #154 by @bai), with auto-schema on first connect, TTL caching, distributed locks across instances, namespaced key prefixes (patterns/pluggable-state-backend). Plus WhatsApp adapter caveats (PR #102 by @ghellach): no message history / edit / delete; auto-chunking; multi-media (images, voice, stickers) downloads; location sharing; all subject to WhatsApp's 24-hour messaging window. Single-platform value proposition: bidirectional clear-text name resolution — inbound <@UXXX> → @alice for prompt context; outbound @alice → <@UXXX> so notifications fire. AI-SDK composition shape: await thread.post(result.textStream). Marginal tier-3 include on adapter-architecture grounds — cross-platform messaging adapter design is legitimate distributed-systems-at-the-edge work (streaming semantics, platform-imposed constraints, notification contracts). Fourth Vercel ingest to pass on recalibrated launch-voice filter.
2026-04-21 — Build knowledge agents without embeddings · Vercel's launch post for the open-source Knowledge Agent Template — a production-ready knowledge- agent architecture that replaces the vector-DB / chunking / embedding-model retrieval stack with a filesystem plus bash. Five-layer pipeline: admin Postgres → Vercel Workflow → snapshot repository → per-request Vercel Sandbox loads snapshot → agent runs bash / bash_batch tools (grep, find, cat, ls). Motivating datum from Vercel's internal sales-call summariser: ~\$1.00 → ~\$0.25 per call (4× cost reduction) with output quality improved after replacing the vector pipeline. Architectural thesis: embedding retrieval is opaque (chunking boundary + embedding model + similarity threshold are three composed transformations), while filesystem retrieval is traceable — "you're debugging a question, not a pipeline." Skill-alignment argument: "LLMs already understand filesystems. They've been trained on massive amounts of code ... you're not teaching the model a new skill; you're using the one it's best at." Plus three additional substrates shipped in the template: Chat SDK multi-platform adapter layer (Slack / Discord / Teams / Google Chat / GitHub with one shared agent pipeline via patterns/multi-platform-chat-adapter-single-agent); complexity router over Vercel AI Gateway classifying each question simple/ hard and dispatching to cheap/powerful models (new chatbot-router altitude Seen-in on patterns/complexity-tiered-model-selection); AI-powered admin agent with read-only tools (query_stats, query_errors, run_sql, chart) — "you debug your agent with an agent" (patterns/ai-powered-admin-agent-self-debug). Canonical sibling framing with concepts/grep-loop (Cloudflare 2026-04-17 named agentic grep as failure mode on unbounded web corpora; this post names it as desired retrieval primitive on bounded sandbox corpora — both framings coexist). Canonical retrieval-pipeline-altitude extension of concepts/web-search-telephone-game (v0's 2026-01-08 framing of web-search-RAG as summariser-corrupted) into the vector-DB retrieval layer. 13 new canonical pages (source + 5 systems + 4 concepts + 4 patterns); 5 extended pages. Tier-3 on-scope on vocabulary- canonicalisation grounds + concrete operational datum (4× cost reduction) + architectural- disclosure density ~35 % of body despite launch voice + CTAs.
2026-04-21 — Bun runtime on Vercel Functions · Vercel's public-beta launch of Bun as a second runtime option alongside Node.js on Vercel Functions, selected per project via bunVersion in vercel.json. Runs on Fluid compute with Active CPU pricing (customers pay for on-CPU time, not wall-clock I/O wait). Launch framework support: Next.js, Express, Hono, Nitro. Headline: 28 % latency reduction on CPU-bound Next.js rendering (TTLB, 1 vCPU / 2 GB, iad1) vs Node.js. Post is Vercel's engineering response to Theo Browne's cf-vs-vercel-bench: methodology pivot from TTFB to TTLB (time-to-last-byte) disclosed verbatim as more representative of SSR user experience; profiling surfaced Node.js Web Streams + transform operations as dominant CPU cost "buffer scanning and data conversions added measurable CPU cost. Garbage collection also consumed a significant share of total processing time under heavy load" — concepts/web-streams-as-ssr-bottleneck. Canonical four-axis runtime trade-off table (Performance / Cold starts / Compatibility / Ecosystem maturity) with Bun favoured for performance-critical; Node.js for broad compatibility + cold-start-sensitive. 11 canonicalisations: 4 new systems (bun, vercel-functions, vercel-fluid-compute, hono), 4 new concepts (active-cpu-pricing, ttfb-vs-ttlb-ssr-measurement, web-streams-as-ssr-bottleneck, runtime-choice-per-workload), 2 new patterns (multi-runtime-function-platform, workload-aware-runtime-selection), plus extensions to systems/nodejs + systems/nextjs + concepts/streaming-ssr. Vercel explicitly acknowledges ecosystem-wide wins from the benchmark cycle: Cloudflare V8 GC tuning + proposed node#60153
OpenNext Next.js improvements. Forward-looking gain: Bun's react-dom/server integration promises further React SSR improvement.
2026-04-21 — BotID Deep Analysis catches a sophisticated bot network in real-time · Vercel's production-incident narrative of a 10-minute window on October 29 at 9:44 am during which BotID Deep Analysis (powered by Kasada's ML backend) detected and auto-mitigated what was likely a brand-new browser-bot network: ~40-45 new browser profiles making "thousands of requests" across proxy nodes, 500 % traffic spike above baseline. First-pass classification stayed "human" for ~4 minutes (the adaptive- reclassification window) until cross-session correlation — "identical browser fingerprints cycling through proxy infrastructure" (concepts/proxy-node-correlation-signal) — fired at 9:48 am, triggering forced re-verification at 9:49 am, and attack traffic dropping to zero by 9:54 am. Full detection-to-mitigation loop hands-free: "No manual intervention required. No emergency patches or rule updates. The customer took no action at all." Central design thesis: standard bot detection handles the majority; Deep Analysis exists for sophisticated-actor edge cases where the FP (block a human) vs FN (let a bot through) trade-off can't be resolved by a single threshold. On tier-3 scope ground it passes decisively as a production-incident + bot-management infrastructure disclosure, despite marketing-voice framing. Second wiki instance of concepts/ml-bot-fingerprinting after Cloudflare's 2025-08-04 stealth-crawler post, at a different feature-space layer (browser telemetry + behavioural patterns vs TLS / HTTP network fingerprints). Wiki-first disclosure of Kasada as a Vercel dependency.
2026-01-08 — How we made v0 an effective coding agent · Vercel's mechanism retrospective on the three techniques that convert v0's ~10 % vanilla-LLM code-generation error rate into production-grade success: (1) dynamic system prompt injecting version-pinned library knowledge via intent detection (embeddings + keywords), cache-stable within intent class, pointing at a co-maintained read-only filesystem of LLM-consumption-optimised examples; (2) LLM Suspense — streaming rewrite layer doing find-and-replace, long-token compression, and <100 ms embedding-resolved icon-import rewrites (Triangle-as- VercelLogo worked example) during streaming so users never see intermediate broken state; (3) post-stream autofixers — AST-based deterministic invariant checks (e.g. QueryClientProvider wrap, package.json completion) + small fine-tuned placement model, conditional <250 ms. Disclosed claim: composite pipeline produces "double-digit" percentage-point increase in success rate. Load-bearing quote: "Your product's moat cannot be your system prompt. However, that does not change the fact that the system prompt is your most powerful tool for steering the model." Second load-bearing quote: web-search RAG is a "bad game of telephone" where the summariser model can "hallucinate, misquote something, or omit important information" — motivating the direct-injection preference. Canonical entry point for v0 on the wiki.
2024-08-01 — How Google Handles JavaScript Throughout the Indexing Process · Vercel + MERJ joint empirical study of Googlebot's rendering on nextjs.org (April 2024, 100,000+ fetches, 37,000+ server- beacon pairs). Debunks four SEO myths with distributional data: Google renders JS 100 % of the time (not selectively); JS pages aren't processed differently; rendering-queue delay is p50 = 10 s (not days); JS-heavy-sites don't have slower page discovery. Canonical rendering-delay distribution (p25 ≤ 4 s, p50 = 10 s, p75 = 26 s, p90 ≈ 3 h, p95 ≈ 6 h, p99 ≈ 18 h). Query-string URLs render dramatically slower (p75 ≈ 31 min vs 22 s path-only). Client-side noindex removal is SEO- ineffective (enforced pre-render). Streamed RSCs fully rendered. Google discovers links via regex over response body (including non-rendered JSON). SSG/ISR/SSR/CSR capability matrix. First Vercel ingest on the wiki. Tier-3 on-scope decisively on empirical-measurement grounds.

Queue status¶

12 ingested / 7 pending / 19 raw articles downloaded (Vercel Blog tier 3). All distributed-systems-internals posts in the queue have now been ingested; remaining posts are launch / PR shape with no architecture signals surviving the filter. Recalibration progression: the 2026-04-21 BotID Deep Analysis post first recalibrated the launch-voice filter (product-PR framing doesn't automatically disqualify); the Bun runtime post doubled that recalibration (launch + infrastructure profiling + methodology); the Knowledge Agent Template tripled it (launch + agent-retrieval architecture); the Chat SDK post quadrupled it on adapter-architecture grounds; the Workflow DevKit and Content Negotiation posts (concurrent-pipeline ingested) extended it further on platform-API and web-standards grounds; the 2026-04-21 Bloom-filter routing post is a different shape again — a genuine engineering retrospective with hard production numbers (200× p99 improvement, 10 % aggregate TTFB improvement, 15 % heap reduction), the first Vercel ingest that lands squarely in the unambiguous architecture-disclosure category rather than the launch-voice-with-substance category. The 2026-04-21 request-collapsing post joins Bloom-filter routing in the unambiguous-architecture category — same shape (single- feature CDN-altitude deep dive, with production numbers: 3M+/day collapsed on miss + 90M+/day on background revalidation, two-level lock topology, 3 s lock timeout) — though without the before/after percentage improvements. The pair together is starting to look like a pattern: Vercel's edge-infrastructure engineering posts, published as part of a product-marketing wave, carry real distributed-systems content that the wiki must surface.