I didn’t care about the image size… until I tried pushing it.

It was huge (~1GB) and took forever to build and upload. That’s when it hit me—this is not how production systems should behave.

So I spent some time figuring out how to reduce Docker image size, and honestly, a few small changes made a big difference.

In this blog, I’ll share what actually worked for me.

Why Image Size Even Matters

At first, I thought:

“Storage is cheap, why does size matter?”

But in real scenarios, it affects:

• Build time (slower CI/CD)

• Push/pull speed (painful on deployments)

• Cloud costs (ECR, Docker Hub, etc.)

• Overall developer experience

Smaller images just make everything smoother.

1. Switching to Alpine (Biggest Easy Win)

Initially, I was using:

FROM node:latest

Then I switched to:

FROM node:18-alpine

And that alone reduced a lot of unnecessary weight.

Alpine is a minimal Linux distro, so you’re not carrying around stuff you don’t need.

2. Multi-Stage Builds (Game Changer)

This was probably the most impactful change.

Earlier, everything—build files, dev dependencies—was going into the final image.

Then I tried multi-stage builds:

# Build stage
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm install --only=production
CMD ["node", "dist/index.js"]

Now the final image only contains what’s actually needed to run the app.

No extra baggage.

3. .dockerignore (I Completely Missed This Initially)

I was unknowingly sending everything to Docker during build.

Including:

• node_modules

• .git

• .env

• logs

Adding a .dockerignore fixed that:

node_modules
.git
.env
logs
tests

This made builds faster and cleaner.

4. Cleaning Up Layers

I also learned that every RUN creates a new layer.

Earlier, I had:

RUN apt-get update
RUN apt-get install -y curl

Now I combine them:

RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

Less layers = smaller image.

5. Installing Only What’s Needed

I didn’t realize how much space dev dependencies take.

Switching to:

RUN npm ci --omit=dev

helped keep things lean.

6. Actually Checking the Image

One mistake I made was not checking image layers at all.

These commands helped:

docker images
docker history <image_name>

You can literally see what’s bloating your image.

What Changed After Optimization

After applying these changes:

• Image size: ~1GB → ~150MB

• Build time: noticeably faster

• Deployment: much smoother

Honestly, I didn’t expect this much improvement.

Final Thoughts

If you’re working with Docker (especially in MERN or backend projects), don’t ignore image size like I did initially.

You don’t need advanced optimizations—just:

• Use a lightweight base image

• Try multi-stage builds

• Avoid unnecessary files

• Keep dependencies minimal

These small things add up quickly.

If you’re already Dockerizing your projects, try these out—you’ll definitely notice the difference.

And if you’ve found other tricks, I’d love to know too 🙂