cold start 38 ms serverless functions

FaaS that doesn't stall on cold start

Functions-as-a-Service on our edge in-country. Node 22, Python 3.12, Bun, Go, Rust — deploy with a single command. Cold start 38 ms, per-second billing with 100ms rounding. HTTP, Schedule, Queue, S3 events — out of the box.

Node · Python · Bun · Go · Rust · per-second billing · 1M invocations free

h3 fn deploy
$
cold start 38 msper-second billingNode 22 · Python · Bun · Go · RustHTTP · Schedule · Queue · S3warm pool · zero cold startedge in 5 in-country regionscustom domain · TLS · CORSh3 fn deploy in 11 seconds1M invocations free
cold start 38 msper-second billingNode 22 · Python · Bun · Go · RustHTTP · Schedule · Queue · S3warm pool · zero cold startedge in 5 in-country regionscustom domain · TLS · CORSh3 fn deploy in 11 seconds1M invocations free
why us

Why another serverless platform

AWS Lambda — slow cold starts, dollars, weird event objects. Your own container — you pay for idle. We tried to take the best of both worlds.

alternative A

AWS Lambda · GCF · Azure Functions

  • Rich SDKs and integrations
  • Cold start 200–800 ms by default
  • Prices in USD · FX risk
  • Their own weird event-object format
  • No FZ-152, data not in-country
h3llo · serverless

Functions by h3llo

  • Cold start 38 ms on Node 22, 60 ms on Python
  • Standard HTTP handler, no custom event objects
  • Prices in rubles, per-second (100ms rounding)
  • Edge in 5 in-country regions · FZ-152 / FZ-242
  • 1M invocations and 400K GB-sec/mo — free
  • Deploy via CLI, Terraform, GitHub Action
alternative B

Run a container on your own VM

  • Full control over the runtime
  • You tune autoscaling for burst yourself
  • You pay for idle 24/7
  • You keep routing and observability yourself
  • You handle graceful shutdown yourself
● dx

One CLI — and a handler.ts that learns nothing new

Deploy with a single command, no custom event objects. Plain HTTP handler, 38 ms cold start on Node 22, per-second billing rounded to 100 ms.

h3 fn deploy · 11 secondscopy
# 1. deploy with a single command
$ h3 fn deploy ./api/handler.ts \
    --runtime=node22 \
    --memory=256 \
    --timeout=30s \
    --domain=api-handler.h3llo.cloud

✓ Bundling (esbuild)             142 ms
✓ Uploading 1.8 MB              980 ms
✓ Deployed v17 · cold-start      38 ms

$ curl https://api-handler.h3llo.cloud/health
{"ok":true,"region":"msk-1","cold":true}

$ curl https://api-handler.h3llo.cloud/health
{"ok":true,"region":"msk-1","cold":false}
handler.ts · standard HTTPcode
// handler.ts — standard HTTP, no custom event objects
import { kv } from "@h3llo/edge";

export default async (req: Request): Promise<Response> => {
  const url = new URL(req.url);

  if (url.pathname === "/health") {
    return Response.json({ ok: true, region: "msk-1" });
  }

  if (url.pathname === "/count") {
    const n = await kv.incr("hits");
    return Response.json({ hits: n });
  }

  return new Response("not found", { status: 404 });
};
runtimes

Runtimes and real cold-start numbers

Measured with a 1.8 MB package, no-op handler, 256 MB of memory, msk-1 region. Numbers from our production cluster, not from a lab.

JS runtime · best · cold start

Bun

The fastest cold start. An alternative to Node for modern apps.

Version1.x
Cold start25 ms
Warm latency5 ms
Package sizeup to 50 MB
JS runtime

Node.js

The most common runtime. Full compatibility with the npm ecosystem.

Version22 / 20
Cold start38 ms
Warm latency8 ms
Package sizeup to 50 MB
JS runtime

Deno

TypeScript out of the box, secure by default. Good fit for edge handlers.

Version2.x
Cold start42 ms
Warm latency9 ms
Package sizeup to 50 MB
Python

Python

asyncio, FastAPI, Flask — all work. ML deps via layers.

Version3.12 / 3.11
Cold start60 ms
Warm latency12 ms
Package sizeup to 50 MB
binary

Go

Single-file binary, the fastest warm latency on CPU-bound tasks.

Version1.23
Cold start18 ms
Warm latency4 ms
Package sizeup to 50 MB (binary)
binary

Rust

Minimal cold start, zero-cost runtime. For latency-critical APIs.

Versionstable
Cold start12 ms
Warm latency3 ms
Package sizeup to 50 MB (binary)
custom

Custom · Docker

Your own OCI image — any language or system dependency you need.

VersionOCI
Cold start120 ms
Warm latency8 ms
Package sizeup to 250 MB
triggers

Triggers — what people usually wire up

01 / http

HTTP triggers

Custom domain, TLS, CORS, IP allow-list. WebSocket for long-lived. Standard Request/Response interface.

02 / schedule

Schedule (cron)

Cron syntax down to second granularity. Distributed locking — the function won't fire twice.

03 / queue

Queue / Events

Our own queue, S3 events, webhooks from external systems. At-least-once or exactly-once (by subscription).

04 / cron-jobs

Long-running jobs

Background jobs up to 15 minutes. Async handler with progress. Auto-retry with exponential backoff.

pricing

Pay for invocations — not for idle

1M invocations and 400,000 GB-seconds per month — free. After that — per-second with 100ms rounding. Fixed warm pool — for SLA-critical APIs.

free tier
For prototypes, hobby projects and small teams. No card, no minimums, no surprises.
0 ₽ · 1M invocations and 400K GB-sec/mo
  • 1M invocations per month
  • 400,000 GB-seconds of compute
  • 1 custom domain
  • All runtimes available
  • Community support
popular
pay-as-you-go
For production with variable load. Billing strictly for what you used — no minimums.
from 0.18 ₽ / 1,000 invocations · 0.42 ₽/GB-sec
  • No cap on invocations
  • Billing rounded to 100 ms
  • Custom domains with no cap
  • 24×7 support · response ≤ 1 hr
  • Metrics, logs, audit
warm pool
For regulated workloads and SLA-critical APIs. Zero cold start, fixed invoice.
from 1,800 ₽ / mo · reserved 1 vCPU 256 MB
  • Zero cold start (warm pool)
  • Guaranteed p99 latency
  • Reserved vCPU (1 / 2 / 4)
  • SLA 99.99% · 10× compensation
  • Isolated compute
quickstart

From install to first invocation — 60 seconds

No portal, no YAML manifests, no container builds. Just handler → deploy.

01

Install the CLI

`brew install h3llo/tap/cli` · or `curl get.h3llo.cloud | sh`.

02

Write a handler

Standard `(req) => Response` on Node, Python, Bun, Go, Rust. No custom event objects.

03

Deploy with one command

`h3 fn deploy ./handler.ts` · 11 seconds. Custom domain handed out immediately.

04

Pick your triggers

HTTP, Schedule, Queue, S3 events, WebSocket. Per-function config via CLI or Terraform.

faq

What people usually ask

How long is the cold start?
Median 38 ms on Node 22, 60 ms on Python 3.12, 25 ms on Bun. No provisioned concurrency and no prepayment. If you need zero cold start — there's a warm pool for a fixed fee.
Which runtimes are supported?
Node.js 22 / 20, Python 3.12 / 3.11, Go 1.23, Rust (binary), Bun 1.x, Deno 2.x. Custom runtimes go through a Docker image (with the same fast cold starts).
What about triggers?
HTTP (with your own custom domain and TLS), Schedule (cron syntax), Queue (ours or external via webhook), S3 events, and WebSocket. All of them — per-second billing with 100ms rounding.
What about package size and memory limits?
By default: package up to 50 MB, memory 128 MB → 4 GB (chosen per function), timeout up to 15 min. If you need more — ping support, we raise it within an hour.
Can you hold state between invocations?
Inside the function itself — no (as it should be). But with h3llo KV (in the same regional edge), Postgres, Redis — the connection comes back instantly thanks to connection pooling in the platform.
How much does it cost?
Per-invocation 0.18 ₽ per 1,000 calls + 0.42 ₽/GB-second of compute. Free tier — 1M invocations and 400,000 GB-seconds per month. Exact prices and the calculator live in /price.

FaaS without surprises — just a handler and a deploy

Standard HTTP handler, per-second billing, cold start 38 ms, 1M invocations free. No vendor lock-in — grab the handler file and deploy it anywhere.