Direct comparison & capabilities showcase
DataVec replaces virtualized serverless runtime layers with compiled execution. Explore our billing, API standard compliance, and supported frameworks below.
Billing & Cost Comparative Metrics
Comparing infrastructure-priced VMs vs utility-metered serverless platforms.
DataVec compiled C
Billing unit
VM-time, cost-plus
Starter bill
$17.00 / mo
Bandwidth fees
Included ($0)
Cold starts
None (resident)
Isolation
Per end user
Cloudflare Workers
Model
Metered requests
Starter bill
$5.00 / mo
Bandwidth fees
Free
Cold starts
V8 isolate warmup
Isolation
Shared per core
Vercel Edge
Model
Metered CPU + Seats
Starter bill
$20.00 / user / mo
Bandwidth fees
$0.15 / GB metered
Cold starts
Subprocess boot delay
Isolation
Shared per core
Coming from Cloudflare Workers or Vercel Edge.
You write the same handler you write there — export default { async fetch(request, env) } — against the same web-standard objects, and your bindings map straight across. Your repo builds the way it already does, then compiles to native code. Here is exactly what you get.
Binding map
| Cloudflare | DataVec | |
|---|---|---|
| D1 (SQL) | env.DB | same prepare().bind().first()/.all()/.run() shape |
| R2 (object storage) | env.BUCKET | get / put / list / delete |
| KV | env.KV | get / put / list / delete, with TTLs |
| Queues | env.QUEUE | send from a handler; a queue() entrypoint consumes |
| Durable Objects | env.DO | env.DO.get(id).fetch(request) — dispatch holds the object’s input gate; plus per-object storage, isolated per id |
| Workers AI | env.CONVERSATION | streaming model tokens (SSE) |
| Hyperdrive / Postgres | env.SQL | managed Postgres over the wire protocol |
| Service bindings | env.SVC | call another service by name; the target is host-resolved, never a URL in your code |
| WebSockets | websocket entrypoint | RFC 6455 + RFC 8441, in and out — written as an async loop, not onmessage callbacks |
Locality
Elsewhere, “where does this live?” is decided for you, differently by each product. Here it is one choice you make per binding, in the same words every time — because the honest answer depends on how many machines your service runs on.
connectionLives in the connection and dies with it.
Per-end-user scratch and caching, inside the isolate that serves that one connection. No syscalls, nothing shared, nothing to clean up.
instanceDurable on this machine.
A SQLite file on the VM serving the request. Fast and durable — and when you run replicas, each has its own copy, so it is a cache rather than shared truth. That is the default, and we say so rather than letting you discover it.
serviceOne source of truth for the whole service.
A designated primary owns the data and every replica reads and writes through it — the scope a Durable Object is unique across. Promotion is deliberate and fenced: writes fail rather than letting two machines both believe they are primary.
A binding that asks for service-wide state and quietly gets per-machine state has been handed the wrong guarantee, so we refuse that rather than downgrade it silently. Durable Objects go further and require you to say the scope outright — the scope an object is unique across isits locality, and inheriting a default would mean “unique per replica,” which is not a Durable Object at all. That one refuses to start on a default rather than guess.
✓ Runs today
Your build, unchanged
we run bun install && bun run build on your repo — the same toolchain and dependencies you already use
fetch() over HTTPS
outbound requests from your handler, TLS included
Request / Response / Headers / URL
the same objects you write against today
Streams
ReadableStream, WritableStream, TransformStream — plus CompressionStream
Web Crypto
SHA-2 digests, HMAC, AES, and ECDSA P-256 — compiled to native code
AbortController / AbortSignal
fetch(url, { signal }) and AbortSignal.timeout(ms) — state and throwIfAborted(), not abort event listeners
Server-sent events
chunked + SSE streaming, the AI-gateway shape included
WebSockets
RFC 6455 over HTTP/1.1 and HTTP/2 (RFC 8441), inbound and outbound, Autobahn-tested — written as for await (const msg of ws) rather than onmessage callbacks, so a callback-style worker needs that one loop rewritten
SQL + object storage
env.DB (D1-shaped), env.SQL (Postgres), env.BUCKET (R2-shaped)
Automatic TLS
point a domain at it; certificates are issued and renewed for you
◷ Coming next
Locality on every binding
each interface above is getting the full range of scopes to choose from
Timers
setTimeout and setInterval, as the runtime surface widens
Durable Object alarms
scheduled wake-ups for an object, alongside the input gate that already serializes its requests
✗ Not a goal
Node.js APIs. No fs, child_process, net, or native addons — same as Cloudflare Workers and Vercel Edge. If your code runs on their edge runtimes, it isn’t relying on these either.
Porting something specific and want to know where it stands? Ask us— we’ll tell you straight, before you spend a day on it.
What you can bind today, and what is coming
The Worker bindings a service can configure or call right now, stated plainly. Where something exists in the platform but is not yet open to customers, it says so.
env.SQL
Managed SQL over the PostgreSQL wire protocol, via named prepared statements.
env.BUCKET
S3/R2-compatible object storage — get, put, list, delete, including streaming gets.
env.SITE
Static-site deploys through a streaming deploy worker; every service also serves a static root.
env.CONVERSATION
Live model-token streaming for AI responses. Bring your own Anthropic key — this is a model binding, not a hosted model catalog.
Outbound fetch
Standard fetch to any host, from inside your connection’s own process.
env.KV
Key–value storage for small, hot configuration and state.
Config & secrets
Plain environment variables, sealed request-header secrets, and sealed environment secrets.
WebSockets
RFC 6455 over HTTP/1.1 and HTTP/2, inbound and outbound.
Web Crypto & SSE
crypto.subtle compiled to native code, server-sent events, and chunked streaming.
Email (env.MAILTX)
Outbound send is wired through the platform outbox, with inbound routing and IMAP on the platform. Not yet opened for general use — ask us first.
Queues
Producer and a consumer entrypoint exist in the platform; not yet exposed in the console.
Durable Objects
Gate plus storage, a memory-durable tier, and per-service audiences run internally; not yet a customer binding.
Service bindings
Worker-to-worker over the service host is implemented internally; not yet exposed to customers.
Cron triggers
scheduled() workers run inside the platform; not yet offered to customers.
Vectorize
Not yet. The planned route is sqlite-vec inside env.SQL.
Hyperdrive
Unnecessary — env.SQL is already managed Postgres.
Analytics Engine
Not offered.
Cache API
Not offered.
Browser Rendering
Not offered.
Images
Not offered.