Everything your application needs to run and grow.
Deploy your code, connect a database over a private network, follow logs and resource metrics, and add replicas as your project grows. Use serverless Lambdas for webhooks and pipelines for scheduled runs or work with multiple steps.
Connect capabilities to common workloads
For pipeline schedules
For webhook processors
Lambdas
Run code on demand for HTTP requests, webhooks and background jobs. Deploy Node.js, Python or Go with logs and invocation history.
- Node.js, Python and Go
- HTTP requests and events
- Invocation logs and history
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
Pipelines for scheduled runs and background work
Run pipelines on a schedule, from a webhook or for background processing. Connect the same functions that serve your HTTP API into steps with retries, branching and fan-out.
- DAG execution
- HTTP triggers
- Pipeline schedules
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
Observability for applications and Lambdas
Monitor application CPU/RAM, read container logs and configure alerts. Inspect Lambda traces, execution history and latency for API routes and pipelines, including scheduled runs, in the same platform.
- 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 — delivery features for HTTP APIs, webhooks, scheduled pipelines and background jobs in production.
CLI: npm install to production
One npm package, one login, and inquir deploy ships a function or any Dockerfile — with ECS-style releases, health gates, and rollbacks handled by the platform.
- Two-command setup
- Functions and containers
- Scriptable in CI
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