What does output: standalone do?

Next.js traces the files the server needs and writes a minimal server.js plus those files to .next/standalone. The runtime image does not need a full node_modules install. You still copy public and .next/static yourself.

The dependency and build stages can hold the compiler and the package cache. Docker ships only the last stage, so the production image stays smaller.

Should I use alpine or slim?

Slim is the safer default. It uses glibc, which matches sharp and most Prisma engines. Alpine is smaller and uses musl. On Alpine, set Prisma binaryTargets to a linux-musl target or the query engine will be missing.

How do NEXT_PUBLIC_ env vars work in Docker?

Next.js inlines NEXT_PUBLIC_ values at build time, so pass them as build args. Server-only secrets are read at runtime. Do not put those secrets in ARG.

A non-root user limits the damage if the app is compromised. The image creates a nextjs user and gives that user ownership of the app files so the runtime cache can be written.

Does it work with Coolify, Railway, or Fly?

Yes. Any Docker host can run the image. Expose port 3000, pass runtime env on the platform, and pass NEXT_PUBLIC_ values at build time.

Next.js Dockerfile generator

Generate a production multi-stage Dockerfile for Next.js, plus .dockerignore and compose.

Runs in browser

Use via MCP

Options

Package manager

Node

Base

Standalone output

Prisma

prisma migrate deploy

Healthcheck

Disable telemetry

BuildKit cache mounts

Monorepo note

Port

Health path

Build-time NEXT_PUBLIC_ names

Comma-separated. They become ARG lines. Server secrets stay runtime env.

Files

Dockerfiledockerfile

1FROM node:22-alpine AS deps

2WORKDIR /app

3RUN apk add --no-cache libc6-compat

4RUN corepack enable

5ENV NEXT_TELEMETRY_DISABLED=1

6COPY package.json pnpm-lock.yaml* package-lock.json* yarn.lock* bun.lock* ./

7RUN --mount=type=cache,target=/pnpm/store pnpm install --frozen-lockfile

9FROM node:22-alpine AS builder

10WORKDIR /app

11RUN corepack enable

12ENV NEXT_TELEMETRY_DISABLED=1

13COPY --from=deps /app/node_modules ./node_modules

14COPY . .

16RUN pnpm build

18FROM node:22-alpine AS runner

19WORKDIR /app

20ENV NODE_ENV=production

21ENV NEXT_TELEMETRY_DISABLED=1

22ENV PORT=3000

23ENV HOSTNAME=0.0.0.0

24RUN addgroup --system --gid 1001 nodejs && adduser --system --uid 1001 nextjs

25COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./

26COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

27COPY --from=builder --chown=nextjs:nodejs /app/public ./public

28HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \

29 CMD node -e "fetch('http://127.0.0.1:3000/api/health').then((res) => process.exit(res.ok ? 0 : 1)).catch(() => process.exit(1))"

30USER nextjs

31EXPOSE 3000

32CMD ["node", "server.js"]

docker build -t app docker run --rm -p 3000:3000 app

pnpm · Node 22 · alpine · standalone · 3 stages · 5 filesNon-root userThe runner stage adds user nextjs.Standalone outputThe runtime copies .next/standalone.Healthchecknode fetch /api/healthTelemetryNEXT_TELEMETRY_DISABLED=1

about 150–200 MBEstimated image size

A static estimate, not a measurement.

Use from your agent

Streamable HTTP at https://benchline.fabwaseem.com/mcp. No key. The tool name is build_nextjs_dockerfile.

mcp.jsonjson

2 "mcpServers": {

3 "benchline": {

4 "url": "https://benchline.fabwaseem.com/mcp"

5 }

6 }

tools/calljson

2 "jsonrpc": "2.0",

3 "id": 1,

4 "method": "tools/call",

5 "params": {

6 "name": "build_nextjs_dockerfile",

7 "arguments": {

8 "packageManager": "pnpm",

9 "node": "22",

10 "base": "slim",

11 "standalone": true,

12 "prisma": false,

13 "migrate": false,

14 "healthcheck": true,

15 "healthPath": "/api/health",

16 "port": 3000,

17 "publicEnvs": [],

18 "telemetryDisabled": true,

19 "cacheMounts": true,

20 "turbo": false

21 }

22 }

23}

Related tools

How it works

Free Next.js Dockerfile generator. Pick your package manager, Node version, standalone output, Prisma, and healthcheck, and get a small multi-stage Dockerfile with .dockerignore, docker-compose.yml, and next.config settings.

01
Pick a package manager and Node version
Choose npm, pnpm, yarn, or bun, then Node 20, 22, or 24 on Alpine or Debian slim.
02
Toggle standalone, Prisma, and the healthcheck
Standalone is on by default. Prisma adds prisma generate. The healthcheck calls a route with node fetch, so the image does not need curl.
03
Copy the files and run docker build
Download the Dockerfile, ignore file, and compose file, set output standalone in next.config, then build and run.