Deploy Node.js Background Workers on AWS ECS with Springwinter

Springwinter workers run long-lived container processes without a public URL. They fit Node.js queue consumers, event processors, schedulers, and asynchronous jobs that continuously pull work. Updated October 9, 2026. A reliable worker acknowledges a job only after success and stops fetching new work during shutdown.

Design the processing loop

The queue is the source of truth. Keep concurrency bounded, make handlers idempotent, and distinguish retryable failures from permanent failures.

let stopping = false;

async function run() {
  while (!stopping) {
    const messages = await queue.receive({ waitSeconds: 20, max: 5 });
    await Promise.all(messages.map(async (message) => {
      await processIdempotently(message);
      await queue.acknowledge(message);
    }));
  }
}

process.on("SIGTERM", () => { stopping = true; });
process.on("SIGINT", () => { stopping = true; });

await run();

Real code should set a maximum drain period. If processing can exceed that period, extend queue visibility while the job runs and allow retries after interruption.

Package the worker

Use a multi-stage Dockerfile and run Node directly. The worker does not need EXPOSE or an HTTP server.

FROM node:24-bookworm-slim AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build && npm prune --omit=dev

FROM node:24-bookworm-slim
ENV NODE_ENV=production
WORKDIR /app
COPY --from=build --chown=node:node /app ./
USER node
CMD ["node", "dist/worker.js"]

Deploy on Springwinter

Create a Worker resource

In your project, click Add resource and select Worker.

Select the code

Choose the GitHub repository and production branch. Set the start command only when the image does not already define one.

Set compute and configuration

Choose CPU and memory, then add queue URLs, concurrency, timeouts, and service credentials as environment variables.

Verify processing

Deploy a test message. Confirm one successful side effect, one acknowledgement, and useful structured logs.

Reliability rules

Use a durable queue rather than in-memory job state.
Include an idempotency key in each message.
Acknowledge only after the durable side effect succeeds.
Configure dead-letter handling for repeatedly failing jobs.
Keep concurrency below downstream database and API limits.
Emit job duration, success, retry, and failure counters.
Test container replacement while jobs are running.

Scaling and cost

Increase task size when each job needs more CPU or memory. Increase worker replicas when jobs are independent and queue depth rises. Current Springwinter workers are continuously running services, so they are not a scale-to-zero substitute for one-off ECS tasks or AWS Batch.

Frequently asked questions

Should a Node.js worker expose a health endpoint?

A Springwinter Worker does not expose a public HTTP port. Use process liveness, queue metrics, job completion metrics, and logs to determine whether it is making progress.

Can one worker process several jobs concurrently?

Yes, but bound concurrency explicitly. Unlimited promises can exhaust memory, database connections, queue visibility windows, or third-party rate limits.

How should deployments handle in-flight jobs?

Stop polling after SIGTERM, finish work within the drain window, then exit. Jobs that cannot finish safely must become visible again and be idempotent when retried.

Cloud networking

Delivery and observability

Architecture and cost

Platform teams and agents

Object storage internals

Compute and API internals

Load balancing internals

Virtualization and images

Platform comparisons

Deployment guides

How to Deploy a Node.js Background Worker on Springwinter

Design the processing loop

Package the worker

Deploy on Springwinter

Reliability rules

Scaling and cost

Frequently asked questions

Sources and further reading

​Design the processing loop

​Package the worker

​Deploy on Springwinter

​Reliability rules

​Scaling and cost

​Frequently asked questions

​Sources and further reading

Design the processing loop

Package the worker

Deploy on Springwinter

Reliability rules

Scaling and cost

Frequently asked questions

Sources and further reading