Host mcp server with NestJS: worker execution and job state · Ample Computer
Host mcp server with NestJS: worker execution and job state
Deploy an MCP server built with NestJS as a public web service plus a dedicated worker process on Ample. ample plan --write discovers both services and their shared database and writes ample.toml; ample up reconciles the topology: a managed PostgreSQL 16 database, a public web microVM and a private worker microVM (kind worker, no public URL), both reading DATABASE_URL. Verified on NestJS: a separately deployed worker service (kind worker, no public URL) sharing a declared managed PostgreSQL database with the web service, consuming a jobs table with row locks and marking jobs done once (worker=done attempts=1). The MCP server-specific behavior (your job payloads, retry policy and scheduling) is your application code on that verified basis.
Verified November 6, 2026
What it runs on
Computeverified
Apps run in isolated x86_64 Firecracker microVMs; sizes are the priced VM sizes.Postgresverified
Managed PostgreSQL 16 with pgvector runs in its own microVM and is auto-provisioned when an app needs a database and no DATABASE_URL is supplied.
You need
A repository with the web app and the worker as separate service directories (the fixture uses apps/web and apps/worker), each building and starting with the documented commands (npm install, nest build (TypeScript) then node dist/main.js on the node-22 template; the worker starts with node worker (its own package.json start script) and binds no port)
Both services read DATABASE_URL at runtime and share one jobs table; the worker claims rows with SELECT ... FOR UPDATE SKIP LOCKED and marks them done once
An Ample account token with servers:write and databases:write (ample up creates the database)
Exact tested configuration
- build
npm run build --if-present - install
npm install - runtime
node - sizes
1vcpu-1gb - start
npm run start - template
node-22
Steps
Plan the topology. Run the planner once. It discovers the web and worker services, infers kind = "worker" for the process without a port, declares the database each service needs, and writes ample.toml. Exit 2 means it left questions in the manifest; answer them with --answer or by editing the file.
$ ample plan --write .Share one database. Keep a single
[databases.main]with engine = "postgres", drop any per-service database the planner added, and set DATABASE_URL = { database = "main" } under both[services.web.env]and[services.worker.env].$ ample plan --offline .Apply. Reconcile the whole manifest in dependency order: the database first, then both services. It is idempotent and never destructive; exit 0 means everything applied, 2 needs input, 1 a failed resource (independent siblings still proceed and re-running resumes).
$ ample up .Verify. Fetch the web service URL and its worker status route (/p/worker-queue/status in the example) and confirm the worker processed the enqueued job; on failure read the worker service's runtime logs.
$ ample logs <deployment_id> --kind runtime
How it was checked
✓ web service responds on its public URL · http get/ → “ample canary nestjs patterns”
✓ worker consumed the enqueued job · http get/p/worker-queue/status → “worker=done attempts=1 result=processed-by-worker”
Evidence
November 6, 2026 · canary run
NestJS web service plus a separate NestJS worker process deployed on Ample with
ample plan --writethenample up(npm install, nest build (TypeScript) then node dist/main.js on the node-22 template); the web service enqueued a job that the private worker service consumed from the shared managed PostgreSQL database. Pattern proof: a separately deployed worker service (kind worker, no public URL) sharing a declared managed PostgreSQL database with the web service, consuming a jobs table with row locks and marking jobs done once (worker=done attempts=1).
Tested examples
- NestJS web + worker fixture. A NestJS web app (apps/web) and a worker process (apps/worker) sharing one managed PostgreSQL database; the queue module is under tests/deploy-canaries/_pattern-modules.
What it doesn’t cover
- Verified on the node-22 template at s-1vcpu-1gb for both services with the example fixture.
- The worker-queue check verified the platform side; the MCP server itself (your job payloads, retry policy and scheduling) is your application code.
- The worker is a long-running process supervised in its own microVM and wakes with the web service that feeds it; for scheduled work add an
ample job([jobs.<name>]in ample.toml). - The worker service is private: it has no public URL and takes its jobs from the shared database; both services are placed with their database.
- Managed PostgreSQL 16 with pgvector; apps and their databases are placed together.