DEV Community: Sneha Tomar

Learning Jenkins by Building a CI/CD Pipeline for a Docker Compose Application

Sneha Tomar — Thu, 15 Jan 2026 16:39:15 +0000

After containerizing a three-tier MERN stack application using Docker Compose, the next natural step in my DevOps learning journey was to automate the build and deployment process.

In Week 4, I focused on learning Jenkins and CI/CD fundamentals and applying them to an already Dockerized application instead of creating something new from scratch. This helped me understand how CI/CD is actually introduced in real-world projects.

Why Jenkins?

Manually running Docker commands works when learning containers, but it doesn’t scale.
Real systems rely on automation, consistency, and repeatability.
Jenkins acts as the bridge between:
Source code changes
Automated builds
Deployment workflows
This week was about understanding how Jenkins fits into DevOps pipelines, not just how to click buttons in the UI.

What I Learned

During this week, I explored Jenkins from fundamentals to more advanced concepts:
Jenkins architecture and CI/CD concepts
Jenkins setup and installation
Jenkins UI, jobs, and freestyle projects
Declarative pipelines and Webhooks
Jenkins agents and multi-node architecture
Shared libraries and their real-world use cases
Role-based user management in Jenkins
Email notifications on pipeline success and failure
Rather than memorizing features, I focused on why each component exists and when it is used.

Project Overview
To apply these concepts, I integrated Jenkins with my existing three-tier MERN stack application, which is managed using Docker Compose.
The goal was simple:

Automate build and deployment without changing application code.

CI/CD Flow Implemented

The pipeline follows this workflow:
GitHub → Jenkins Pipeline → Docker Compose → Deployment → Verification
Jenkins Pipeline Stages
Checkout Source Code
Jenkins pulls the latest code from GitHub.
Deploy Using Docker Compose
Stops running containers (if any)
Builds Docker images
Starts services using Docker Compose
Verify Deployment
Displays running containers to ensure successful deployment.
Email Notifications
Sends email alerts on pipeline success or failure.
All stages are defined using a Declarative Jenkinsfile, making the pipeline version-controlled and reproducible.

Key Takeaways

CI/CD is more about process and reliability than tools
Jenkins pipelines scale far better than manual jobs
Declarative pipelines improve readability and maintainability
CI/CD can be integrated into existing systems without modifying application code
Automation reduces human error and speeds up deployments
This project helped me move from “running commands manually” to “thinking in pipelines”.

Tech Stack Used

Jenkins
Docker
Docker Compose
GitHub
Linux

Repository
GitHub: https://github.com/snehatomar1205/DevOps

What’s Next?
My next focus will be on:
YAML fundamentals
Ansible for configuration management and automation
This will help me move further toward infrastructure automation and scalable deployments.

Learning Docker by Building a Three-Tier MERN Application

Sneha Tomar — Thu, 08 Jan 2026 04:22:43 +0000

This week, I focused on learning Docker fundamentals as part of my DevOps learning journey.

Instead of only memorizing commands or following tutorials blindly, I wanted to understand how Docker is actually used in real projects. So I decided to build something small, practical, and close to real-world architecture.

Why Docker?

Before Docker, running an application meant:
Installing dependencies manually
Dealing with environment mismatches
Hearing the classic “it works on my machine” problem

Docker solves this by packaging applications and their dependencies into containers, making them portable, consistent, and repeatable.

What I Built
To apply what I learned, I built a three-tier MERN stack application using Docker.

The application is structured as:

Frontend: React-style frontend served via Nginx
Backend: Node.js + Express API
Database: MongoDB

Each component runs in its own Docker container, and all services communicate through a shared Docker network.

The entire application can be started using a single command:
- docker compose up --build

Docker Concepts I Practiced
While building this project, I worked with the following Docker concepts:

1. Docker Images & Containers
I learned how images are built from Dockerfiles and how containers are created from those images.

2. Dockerfiles
I wrote Dockerfiles for both frontend and backend services to define how each application should be built and run.

3. Multi-Stage Docker Builds
To optimize image size, I used multi-stage builds so that build-time dependencies don’t end up in the final production image.
This helped me understand how production-ready Docker images are created.

4. Docker Networking
All services run on a custom Docker network, allowing containers to communicate with each other using service names instead of IP addresses.

5. Docker Volumes
MongoDB uses a Docker volume to persist data, ensuring the database data is not lost when containers restart.

6. Docker Compose
Docker Compose ties everything together by defining all services, networks, and volumes in a single file.

What I Learned
Some key takeaways from this project:

Docker becomes much clearer when you build something end-to-end
Multi-container applications are easier to manage with Docker Compose
Volumes are critical for data that should survive container restarts
Docker is less about commands and more about reproducible environments

Why This Project Matters
This project is not meant to be production-scale or overly complex.
Its purpose is to serve as a proof of work — showing that I understand Docker fundamentals by applying them in a realistic setup.

Repository
GitHub Repository:https://github.com/snehatomar1205/DevOps

Learning Shell Scripting Through Real Automation Projects

Sneha Tomar — Thu, 01 Jan 2026 05:02:46 +0000

This week, I focused on learning Bash shell scripting by building real Linux automation scripts instead of just studying commands.

What I covered:

Linux shell & shebang
Variables, arrays, strings
User input & arithmetic
Conditionals, loops, functions
Arguments & redirection
Error handling and logging
Automation using At & cron

Mini Projects Built:

RAM Monitoring Script – checks free memory with threshold alerts
Disk Usage Monitoring – monitors disk space with alert logic
Log Archiving Script – compresses and archives system logs
User Management Script – create, delete, and list users

GitHub: https://github.com/snehatomar1205/DevOps

This hands-on approach helped me understand how shell scripting is used in system administration and automation.

What I Learned in My First Week of Linux (DevOps Journey)

Sneha Tomar — Thu, 25 Dec 2025 03:26:28 +0000

Linux is often recommended as a foundational skill for DevOps, but its real value becomes clear only through hands-on practice. This week, I focused on building a strong understanding of Linux fundamentals by working directly in the terminal rather than passively consuming tutorials.

During this week, I practiced and explored the following core Linux concepts:

File and directory management
User, group, and permission handling
Disk usage analysis and process monitoring
Networking fundamentals
File compression, backups, and transfers
Text processing using tools such as grep, sed, and awk

Working with these commands helped me understand how Linux systems behave in real environments and how administrators interact with servers on a daily basis.

Linux is not about memorizing commands. It is about understanding system behavior, permissions, and processes, and being comfortable navigating and troubleshooting through the terminal.

I documented all commands and concepts I practiced in a structured GitHub repository to ensure reproducibility and accountability.
GitHub:(https://github.com/snehatomar1205/DevOps)

What’s Next
In the coming week, I will move into shell scripting and begin combining these fundamentals into small automation workflows.