How curiosity led me from coding to containers—and back again
It all started with a simple request from our Senior Software Engineer:
“Can you learn Docker and set up our local development environment?”
At the time, I didn’t realize that would be the spark that pulled me into the world of DevOps. I was handed access to an AWS account, and from that moment on, my learning curve grew like a domino effect.
From Manual Installs to Reproducible Environments
My first task was to containerize our setup. Previously, everyone on the team had to manually install Angular, Slim Microframework, and MySQL—a tedious and error-prone process.
So I built a Docker Compose file that automated everything. Suddenly, onboarding new developers became a breeze, and we were all running the exact same environment. No more “it works on my machine” moments.
Enter the Cloud
Next, I dove into AWS EC2. Spinning up cloud instances felt like unlocking a superpower. I realized how much more cost-effective and flexible the cloud was compared to maintaining on-premise servers. You only pay for what you use, and scaling up or down was as easy as clicking a button.
With my new Docker and EC2 skills, I deployed our first Development Server—a centralized environment where we integrated and tested new changes.
Learning the Networking Side
Of course, deployment isn’t complete without understanding IP addresses, ports, domains, and SSL certificates.
At first, our EC2 instance had a dynamic public IP—one day it was 203.0.113.10, the next it changed to 198.51.100.42. That’s when I discovered Elastic IPs, static addresses you can permanently assign to an AWS account.
But IPs aren’t exactly human-friendly, so we mapped a custom domain to our Elastic IP. We skipped AWS Route 53 since the company already owned a domain, and just like that, our site became easy to access and remember.
For SSL, we went with the free and reliable Let’s Encrypt certificates. I installed them on both Nginx and Apache, ensuring our traffic was secure. The only catch? You have to renew them periodically—but it was a small price to pay for encrypted connections.
Building a CI/CD Pipeline
Once deployment was smooth, I turned my attention to automation. Using Jenkins, I set up a CI/CD pipeline that pulled code from GitHub, built and tested it, then deployed it automatically to our server—all while sending Slack notifications to the team.
It was magical… until Jenkins started running out of space. Builds accumulated over time, filling up the EC2 storage and halting new jobs.
After some research, I found a Jenkins plugin that could automatically spin up temporary EC2 instances for each build—and destroy them afterward. Problem solved.
To further optimize, I implemented Jenkins master-slave architecture, separating build execution (slaves) from management (master). This isolation stopped resource conflicts and made the system more stable.
Discovering Orchestration
For deploying containers, I used Docker Swarm, a simple yet powerful orchestration tool. I loved how it handled the heavy lifting behind the scenes—automatic load balancing, container health checks, and self-healing.
That’s when I first understood the concepts of High Availability and Scalability—how systems stay resilient even when parts fail.
Going Deeper into AWS
I continued exploring AWS and discovered S3 Buckets for file storage—like Google Drive, but more technical and customizable.
Then came VPCs (Virtual Private Clouds), which taught me how to control network traffic, enforce security, and isolate environments. It felt like I was not just writing software anymore, but designing infrastructure.
Fine-Tuning Performance
As I spent more time with Nginx, I learned small tweaks that made a big difference—like enabling Gzip compression to make responses faster.
I also optimized build times by skipping unnecessary dev packages and using npm ci instead of npm install for consistency. Each improvement made the development process a little smoother, a little faster.
Falling in Love with DevOps (and Knowing When to Refocus)
By this point, I was hooked. I started exploring Kubernetes, Ansible, and Terraform—fascinated by the endless possibilities of automation and scalability.
But then I took a step back. I realized that while DevOps thrilled me, my heart was still in building features—solving user problems, crafting interfaces, and shipping products. I loved understanding infrastructure, but I loved creating experiences even more.
So, I refocused my energy back to Frontend Development. Yet, my time in DevOps changed me forever. It gave me a deep appreciation for how software truly comes to life—from code to container, from server to screen.
Even now, those lessons continue to guide me. Because once you’ve walked the DevOps path, you never really stop thinking about how all the pieces fit together.
