● serverless functionscold start 38 ms

FaaS thatdoesn't stallon cold start

(translation pending)

Node · Python · Bun · Go · Rust · per-second billing · 1M invocations free
api-handler · v17 · msk-1
warm
h3 fn deploy
$

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

Standard HTTP handler. Deploy with a single command.

No more event.requestContext.authorizer. Standard Request/Response — like everywhere else. Deploy via CLI, Terraform or a GitHub Action.

h3 fn deploy · CLI11 seconds
# 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 · TypeScriptnode22
// 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 });
};
● runtimesreal cold start

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.

RuntimeVersionCold startWarm latencyPackage size
Bunbest · cold start1.x25 ms5 msup to 50 MB
Node.js22 / 2038 ms8 msup to 50 MB
Deno2.x42 ms9 msup to 50 MB
Python3.12 / 3.1160 ms12 msup to 50 MB
Go1.2318 ms4 msup to 50 MB (binary)
Ruststable12 ms3 msup to 50 MB (binary)
Custom · DockerOCI120 ms8 msup to 250 MB

Binary runtimes (Go, Rust) start faster but take a bit more work to deploy — you need a properly built binary for Linux/amd64.

● 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× refund
  • Isolated compute
● materialsfree

Guides and case studies on serverless

Real practices, benchmarks, migrations. No fluff and no marketing — grab the PDF, apply it Monday.

All materials →
● quickstart

From install to first invocation — 60 seconds

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

Let's go →
1

Install the CLI

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

Write a handler

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

Deploy with one command

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

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.
● 11 seconds from git push to live

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.

Deploy your first function →Documentation