Deploy from a repository.
Database included, on your servers.
Services that scale to zero, jobs that run to completion, and stacks that bring their database, cache, bucket and model route with them, wired without a copied secret. One question at the first deploy, Kubernetes or serverless, and one plan to apply.
$ frazer serverless deploy notes-api --source . --with postgres,valkey --dry-run
Detected Next.js · Prisma (Postgres) · ioredis (Valkey)
Plan + stack notes · service notes-api · scale 0–5 · sandbox
+ Postgres notes-db · small · PITR 7 days · binding DATABASE_URL
+ Valkey notes-cache · Basic · binding VALKEY_URL
+ notes-api-p7k2.frazer.run · TLS
Cost $0 while idle · on your servers
? Apply? yes ✓ revision notes-api-00001 ready# frazer.stack.yaml (frazer serverless stacks create notes --from frazer.stack.yaml --dry-run)
apiVersion: frazer.ai/v1
kind: Stack
name: notes
services:
notes-api:
source: {repo: acme/notes, branch: main}
scaling: {min: 0, max: 5, concurrency: 80}
runtime: sandbox
access: public
bind: {DATABASE_URL: postgres/notes-db, VALKEY_URL: memory/notes-cache}
postgres: {notes-db: {version: "18", tier: small, pitr: 7d}}
memory: {notes-cache: {engine: valkey, mode: basic}}From a push to a URL.
Every step a revision you can roll back.
Asked once, with a reason.
Move either way later.
Serverless
Recommended for this repoA stateless HTTP or gRPC service up to 8 vCPU and 32 GiB, or a project with no cluster yet.
- Scale to zero, pay while an instance exists
- Revisions, traffic splits and tagged URLs
- Frazer runs the runtime cluster for you
Kubernetes
StatefulSets, operators, raw TCP or UDP, host networking, or an app already in an environment repository.
- Your project’s cluster, GitOps from your Git
- Any workload Kubernetes runs
frazer serverless move notes-api --to kubernetesopens the PR
An app and its data,
created together.
The deploy dialog reads your code and proposes the database, cache, bucket and model route it uses. A stack creates them in one plan, wires them with bindings, shows one cost line, and deletes together with final backups.
- notes-apiservice · revision 00042 · 2 instancesnotes-api-p7k2.frazer.run
- notes-dbPostgres 18 · small · PITR 7 daysDATABASE_URL
- notes-cacheValkey · BasicVALKEY_URL
- notes-uploadsbucket · lifecycle 30 daysS3_BUCKET
- llm:balancedLLM gateway route · budget $20/dayFRAZER_LLM_BASE_URL
- notes-digestjob · daily 07:00from notes-api
The parts you expect.
None you have to assemble.
Revisions and traffic
Immutable revisions, splits for canaries, rollback in one plan.
Tagged URLs
Every tag gets its own URL for review.
Scale to zero, or not
Min and max instances, hard concurrency, warm minimums for latency.
Jobs
Run to completion, on a schedule or from a service.
Domains and TLS
Your hostname, certificates included.
Logs and metrics
In Frazer Monitoring, per revision.
Previews per pull request
A stack per PR with seeded data.
Worker pools and functions
Queue consumers, and services built from a function source.
No serverless premium.
No request fee.
You pay for vCPU and memory while an instance exists, at the same rate as a VM. On your own servers it is part of the server fee.
See every priceServerless, answered.
Is this a functions product?
No. Serverless runs containers: services that scale with requests, jobs that run to completion, and stacks that bring their data. A function is a service built from a function source, with no per-invocation runtime.
Where does my code run?
In a serverless runtime cluster that Frazer runs for your organization at each site, on your own servers or on the Frazer fleet. You never manage that cluster, and your code runs in a sandbox with a user-space kernel.
Can I move a service to Kubernetes later?
Yes. Move to Kubernetes writes the service into an environment repository you choose as a Git pull request, then shifts traffic at the gateway and retires the service. Moving the other way works too. Both are plans with a cutover step, and the data stays where it is.
How are database passwords handled?
A binding creates a database role for the service, keeps its password in the secrets store and injects DATABASE_URL over a private endpoint. People see names, sources and versions, never values. A new password rolls out as a new revision.