Voltstream is a programmable CDN with caching you control line by line. Write a rule, push once, and it runs in 312 cities — no origin round-trips, no purge lag, no surprises out at the p99.
export const onRequest = (req, edge) => {
// pin the hottest 1% in RAM at every PoP
if (req.path.startsWith('/v2/assets'))
return edge.cache(req, { ttl: '30d', tier: 'hot' });
// stale-while-revalidate: never block on origin
return edge.cache(req, { swr: '24h', key: req.geo.country });
}Delivering for streaming platforms, storefronts, and developer tools
What the network holds at full tilt
Most CDNs hand you a dashboard of checkboxes. Voltstream hands you the request. Cache, rewrite, route, and respond in JavaScript that runs microseconds from the user.
Run real code on every request at the PoP — auth, A/B splits, personalization, redirects. There is no cold start to pay down; your function is already resident in the isolate when the request lands.
Set TTLs, surrogate keys, and stale-while-revalidate per route in code. Cache fragments, not just whole pages.
Tag-based invalidation that clears every edge worldwide in under 200 ms. Ship content the moment it changes.
A regional shield layer absorbs misses before they ever reach your origin, collapsing origin load by up to 95%.
Per-PoP hit rates, latency histograms, and request logs streamed live — no five-minute lag, no sampling, no guessing which city is slow.
Volumetric floods are soaked up across all 312 PoPs before a single packet reaches your origin. Always on, no scrubbing-center detour, no traffic re-route.
Every one of these moved off a busy origin server and onto an edge function running microseconds from the user. Same logic, a tenth of the latency, none of the round-trips.
Rewrite the response per visitor — geo, cohort, feature flags — without a single call back to origin. The page is personal and still fully cached.
Bucket users into experiments at the edge with a stable hash. Variants are decided before the first byte, so neither arm waits on a flag service.
Verify a JWT, check a session, or sign a URL in the function itself. Unauthorized requests never burn an origin hit — they're turned away at the edge.
Resize, re-encode, and reformat to AVIF or WebP at the PoP, then cache the result by surrogate key. One source asset, every variant, zero origin work.
Stitch, filter, and reshape upstream JSON close to the caller. Trim payloads and collapse fan-out so mobile clients pull less over the slowest hop.
Route each request to the nearest healthy origin and fail over the instant one degrades. The reroute happens in the function, not in a five-minute DNS TTL.
Version your edge config, preview it on a real URL, and roll it out or back in one command. The whole network behaves like one machine you can reason about.
Your routing, caching, and headers live in your repo. Review them in a pull request, not a control panel.
Each commit gets an isolated edge deployment on its own URL, so you test cache behavior before it ships.
Every deploy is immutable and addressable. Revert the entire global edge to a known-good state in seconds.
First-class TypeScript types for requests, responses, and cache primitives. Autocomplete the whole edge runtime.
“We moved personalization from origin to a Voltstream edge function and our TTFB dropped from 340 ms to 11 ms globally. Add-to-cart rate climbed 6% the week it shipped.”
“Tag-based purge changed how we ship. An editor hits publish and the change is live in every region by the time the toast clears. The 'wait five minutes for the cache' Slack thread is gone.”
“Tiered cache cut our origin egress bill by 91% in the first month. The migration paid for a year of Voltstream by week three.”
Flat, predictable pricing with no egress fees and no per-request gotchas. Cache as hard as you want.
For side projects and prototypes.
For production apps under real load.
For high-volume streaming and platforms.
Traditional CDNs cache static files and expose a dashboard of toggles. Voltstream runs your JavaScript on every request at the edge, so caching, routing, and personalization are programmable logic you version in your repo — not settings you click.
Tag-based invalidation reaches all 312 PoPs in under 200 ms on average. You purge by surrogate key, so clearing one product page never blows away your whole cache.
No egress fees and no per-GB overage traps. Plans include a generous traffic allotment, and Power runs on committed flat rates. The more you cache, the less you ever touch origin.
Yes. Point a single CNAME, run Voltstream in shadow mode against live traffic to validate hit rates, then cut over. Most teams are fully migrated within a day with zero dropped requests.
A V8 isolate runtime with a typed Web-standard API — Request, Response, fetch, and our cache primitives. If you know the platform's Fetch API, you already know the edge.
Surge carries a 99.99% monthly availability SLA; Power carries 99.999% with financial credits. Both measure edge request success, and the status page publishes every region's real numbers — not a marketing average.
Deploy to all 312 cities in minutes. No credit card, no sales call, no egress bill waiting at the end of the month.