Serverless platform features for AI agents, APIs, cron jobs, and webhooks
Use these features for public APIs and webhook handlers, scheduled cron jobs, async jobs and pipelines, and full-stack observability. Under the hood: serverless functions on Node.js, Python, and Go; API gateway; pipelines and schedules; secrets and env vars; hot containers when repeat traffic needs steadier tail latency.
Connect capabilities to common workloads
features.indexIntent.rowAgents
features.indexIntent.rowCron
features.indexIntent.rowWebhooks
Serverless API Gateway
For public HTTP APIs and webhooks on serverless functions—route-level auth, path parameters, CORS, rate limits, and instant routing without a separate ingress layer.
- Path parameters
- Rate limiting
- CORS configuration
Serverless pipelines, cron jobs, and background work
Model serverless pipelines for cron jobs, webhook-triggered workflows, and multi-step background jobs—staged work, retries, and fan-out while reusing the same functions as your live HTTP API.
- DAG execution
- Webhook triggers
- Cron scheduling
Serverless functions and runtimes
Run isolated serverless functions in real containers—same event model, layers, and hot pools across languages without splitting services across runtimes.
- Node.js 22
- Python 3.12
- Go 1.22
Serverless observability
Debug route handlers, scheduled runs, and async jobs with shared logs, traces, execution history, and latency views across serverless entry points.
- Execution traces
- Live streaming
- Latency percentiles
Secrets and environment variables for serverless functions
Per-function environment variables from the test panel (Config → Environment) or the API—runtime injection into the container, plus log and trace redaction for common secret-shaped strings. 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 deploy paths when you ship HTTP APIs, webhooks, cron jobs, and background jobs to production.
Hot containers for steadier latency
Keep warm pools for steady serverless traffic so repeat invocations skip most cold-start cost—ideal for APIs, agents, and webhooks with bursts.
- Warm pools
- Tail latency
- Production tuning
Container runtime isolation
Each serverless function runs in its own container image so dependencies never clash—closer to Lambda-style isolation than a shared multitenant interpreter.
- POSIX-friendly filesystem
- Polyglot stacks
- Smaller blast radius
Custom domains for APIs and webhooks
Branded hostnames and TLS aligned with your gateway routes for public APIs and provider webhooks.
- Customer-facing APIs
- Webhooks
- DNS cutovers
Multi-tenant routing for B2B APIs
Host-based tenants, path-based tenants, and white-label ingress without giant conditional routers—per-surface auth at the gateway.
- Host or path tenants
- Auth per surface
- Tenant boundaries
Browser deploy and one-click fixes
Ship or patch from the console when local toolchain friction slows the team—fast onboarding and shared visibility during incidents.
- Fast fixes
- Onboarding
- Shared visibility