Serverless platform features for AI agents, APIs, cron jobs, and webhooks
Build public APIs and webhook handlers, scheduled cron jobs, async background jobs, and multi-step pipelines — with full-stack observability across all of it. Under the hood: serverless functions in Node.js, Python, and Go, a built-in API gateway, pipelines and schedules, secrets and environment variables, and hot containers when repeat traffic needs steadier tail latency.
Connect capabilities to common workloads
For cron jobs & schedules
For webhook processors
Serverless API Gateway
Ship public HTTP APIs and webhooks on serverless functions with route-level auth, path parameters, CORS, and rate limits — no separate ingress layer to deploy or maintain.
- Path parameters
- Rate limiting
- CORS configuration
Serverless pipelines, cron jobs, and background work
Run cron jobs, webhook-triggered workflows, and multi-step background jobs as serverless pipelines — staged work, retries, and fan-out built on the same functions that serve your live HTTP API.
- DAG execution
- Webhook triggers
- Cron scheduling
Serverless functions and runtimes
Run isolated serverless functions in real containers with the same event model, layers, and hot container pools across Node.js, Python, and Go — no need to split services across runtimes.
- Node.js 22
- Python 3.12
- Go 1.22
Serverless observability
Debug route handlers, scheduled runs, and async jobs in one place — logs, traces, execution history, and latency views shared across every serverless entry point.
- Execution traces
- Live streaming
- Latency percentiles
Secrets and environment variables for serverless functions
Set per-function environment variables from the test panel (Config → Environment) or the API — values are injected into the container at runtime, and common secret-shaped strings are redacted from logs and traces. Built for function configuration, not as a standalone enterprise secrets manager.
- Per-function env vars
- Runtime injection
- Log and trace redaction
Also included
Advanced serverless delivery features
Warm pools, per-function containers, branded domains, multi-tenant ingress, and browser-first deploys — the delivery features you reach for when HTTP APIs, webhooks, cron jobs, and background jobs go to production.
Hot containers for steadier latency
Keep a warm pool ready for steady traffic so repeat invocations skip most of the cold-start cost — a natural fit for APIs, agents, and webhook handlers that see bursts.
- Warm pools
- Tail latency
- Production tuning
Container runtime isolation
Every function runs in its own container image, so dependencies never clash — closer to Lambda-style isolation than a shared multi-tenant interpreter.
- POSIX-friendly filesystem
- Polyglot stacks
- Smaller blast radius
Custom domains for APIs and webhooks
Serve public APIs and provider webhooks from branded hostnames with TLS, aligned with the same gateway routes you already run.
- Customer-facing APIs
- Webhooks
- DNS cutovers
Multi-tenant routing for B2B APIs
Route tenants by host or by path and offer white-label ingress without a giant conditional router — every surface gets its own auth policy at the gateway.
- Host or path tenants
- Auth per surface
- Tenant boundaries
Browser deploy and one-click fixes
Ship or patch straight from the console when local toolchain friction slows the team down — new engineers onboard faster, and everyone sees the same screen during incidents.
- Fast fixes
- Onboarding
- Shared visibility