Builder pattern before multi-stage in Docker - Time & Space Complexity

Time Complexity: Builder pattern before multi-stage

O(n)

Understanding Time Complexity

We want to understand how the time to build a Docker image grows when using the builder pattern before multi-stage builds.

Specifically, how the build steps affect the total build time as the project size increases.

Scenario Under Consideration

Analyze the time complexity of the following Dockerfile snippet.

FROM node:18 AS builder
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

This Dockerfile uses a builder stage to install dependencies and build the app, then copies the build output to a smaller image.

Identify Repeating Operations

Look for repeated or costly steps in the build process.

• Primary operation: Running npm install and npm run build which process all project files.
• How many times: Each command runs once per build, but their cost depends on project size.

How Execution Grows With Input

As the project size (number of files and dependencies) grows, the install and build steps take longer.

Input Size (n)	Approx. Operations
10 files	Small install and build time
100 files	Much longer install and build time
1000 files	Significantly longer install and build time

Pattern observation: Build time grows roughly proportional to project size because install and build process all files.

Final Time Complexity

Time Complexity: O(n)

This means the build time grows roughly in direct proportion to the size of the project files and dependencies.

Common Mistake

[X] Wrong: "The build time stays the same no matter how big the project is."

[OK] Correct: The install and build commands process all files and dependencies, so more files mean more work and longer build time.

Interview Connect

Understanding how build steps scale with project size helps you explain Docker build performance and optimization in real projects.

Self-Check

What if we split the build into multiple smaller stages? How would that affect the time complexity?