Everything we ship, documented

Edge caching is generally available on every plan, including Free. Over six months of beta, teams served 4.8 billion cached responses with a 96% median hit rate and 6ms p50 — numbers we are now confident enough to put an SLA behind. Nothing changes in your code: cache.swr() works exactly as it did in beta.

Tag-based invalidation is hardened for GA: limits are raised from 8 to 64 tags per entry. Attach tags when you cache — cache.swr(key, fn, { tags: ['user:42'] }) — then purge globally with cache.purge({ tags: ['user:42'] }) or vega cache purge --tag user:42 from the CLI. Purges propagate to all 28 regions in under 300ms.

Four new regions — Seoul, Toronto, Madrid, and Dubai — bring the network to 28, and cached responses are served from all of them on day one. The Cache tab now reports hit rate, origin load saved, and bandwidth per route.

Vega 2.0 also moves the runtime baseline to Node 22 APIs. This is backward compatible — code deployed on 1.x keeps running — and Scale plans now carry a 99.99% uptime SLA, up from 99.95%.

You can now search every trace, not just the flagged ones. The query syntax composes filters — route:/checkout status:500 duration:>200ms region:fra — and returns results in under a second across 30 days of data. Saved searches live in the sidebar and are shareable by URL.

Traces also export over OTLP to any OpenTelemetry-compatible backend, so Vega can feed the observability stack you already run. Export is configured per environment, batched, and adds no request overhead.

Retention is longer at no price change: Pro plans keep traces for 30 days, up from 7, and Scale keeps them for 90.

Fixed: waterfalls with more than 500 spans render without locking the tab, and cache hits are attributed to the cache span instead of the handler.

vega dev now runs the exact runtime we run in production — same isolate version, same cache semantics, same trace format. Requests against localhost:7700 produce the same waterfalls you would see in the dashboard, viewable locally with vega dev --trace. The class of bug that only appears after deploy gets a lot smaller.

Deploys are faster. Uploads are content-addressed, so only changed modules leave your machine: the median deploy went from 8.4s to 3.1s, and builds for a typical service finish in 1.2s. vega deploy --watch redeploys on save for staging environments.

Smaller things: shell completions for bash, zsh, and fish via vega completions, a --json flag on every command for CI pipelines, and exit codes are now documented and stable.

@vega/sdk 2.0 infers types from your route definitions. Path parameters are typed from the path string itself — '/users/:id' gives you params.id as a string with no annotations — and response types flow through to vega types, which generates a typed client for your frontend. Mismatched handlers fail at compile time, not in production.

Breaking change. Handlers now receive a single context object instead of positional (req, res) arguments, and they return a Response instead of writing to res:

// SDK 1.x
api.get('/users/:id', async (req, res) => {
  const user = await db.users.find(req.params.id);
  res.json(user);
});

// SDK 2.0
api.get('/users/:id', async ({ params }) => {
  const user = await db.users.find(params.id);
  return Response.json(user);
});

Run npx @vega/codemod sdk-2 to migrate automatically — it converted 96% of handlers across a test corpus of 1,800 repositories. SDK 1.x continues to receive security patches until July 31, 2026, and existing deploys keep running unchanged.

cache.swr() is now available on every paid plan. Wrap any async function and Vega serves the cached value from the nearest region while revalidating in the background — stale-while-revalidate semantics without a CDN configuration in sight. Cache hits return in 6ms at the median; misses run your handler as usual.

api.get('/products/:id', async ({ params, cache }) => {
  const product = await cache.swr(
    `product:${params.id}`,
    () => db.products.find(params.id),
    { ttl: 60, stale: 600 },
  );
  return Response.json(product);
});

Defaults are ttl: 60 and stale: 600 — fresh for a minute, served stale for up to 10 minutes while a single background revalidation runs per key per region. Both are configurable per call.

During the private beta, 212 teams cut origin load by a median of 91% and served 1.4 billion cached responses. The beta is on by default for Pro and Scale; hit rates per route are tracked in the new Cache tab.

Every request now produces a full trace — routing, middleware, handler execution, and upstream calls — with no instrumentation required. The waterfall view shows where each millisecond went, and overhead stays under 0.4ms per request. Tracing is on by default for Pro and Scale plans, with 100% sampling and 7-day retention.

Per-route latency breakdowns landed alongside. The Routes view shows p50, p95, and p99 for every endpoint in every region, with week-over-week deltas, so a regression in one region no longer hides inside a global average.

Spans slower than 100ms are flagged automatically and grouped by upstream host — usually enough to identify a slow database query or third-party API without reading a single trace by hand.

Fixed: trace timestamps render in your dashboard timezone instead of UTC, and traces for requests that hit the 30s handler limit are no longer truncated.

Vega is now live in São Paulo, Mumbai, Osaka, Stockholm, Sydney, and Johannesburg, bringing the network to 24 regions. New deploys pick up the regions automatically; existing apps can opt in with vega regions add. Free-tier apps continue to run in the 3 regions closest to their traffic.

Cold starts dropped from 96ms to 31ms at the median, and from 240ms to 88ms at p99. Isolates are now snapshotted after module initialization and restored from the snapshot on first request, so your imports no longer run on the cold path.

Anycast routing re-evaluates the nearest healthy region every 30 seconds instead of every 5 minutes, which cut p99 latency by 9ms for traffic near region boundaries.