Marcos Vinicius Thibes Kemer’s Post

CI/CD shouldn’t be this annoying. Yet somehow, every time I start a new repo, I end up: • rewriting the same GitHub Actions workflows • copying YAML from old projects (and hoping it still works) • debugging pipelines that fail for non-obvious reasons • dealing with slightly different setups across repos • spending more time maintaining pipelines than shipping code None of these are hard problems — just repetitive ones that add up. So I started putting together NERV-Actions. The goal isn’t to reinvent CI/CD. It’s to remove the friction: a small, reusable set of actions that makes pipelines more consistent, easier to plug in, and less painful to maintain. Still a work in progress, but it’s already reducing a lot of the “why is this pipeline different again?” moments. If this sounds familiar, you can check it out here: 👉 https://lnkd.in/gXJJNxTr Curious if others are feeling the same pain with GitHub Actions. #GitHubActions #CICD #DevOps #SoftwareEngineering

🚀 Built an End-to-End CI/CD Pipeline using Jenkins & Docker I recently completed a project where I designed and implemented a fully automated CI/CD pipeline from scratch. 🔧 Tech Stack: - Git & GitHub   - Jenkins   - Docker   - Node.js   - ngrok (for webhook tunneling)   - Postman (API testing) ⚙️ What the pipeline does: Every time I push code to GitHub: ➡️ Jenkins is triggered automatically via webhook   ➡️ Latest code is pulled   ➡️ Docker image is built   ➡️ Old container is stopped   ➡️ New container is deployed  🌐 Result: The application updates automatically on localhost without any manual deployment. 💡 Key Learnings: - Practical understanding of CI/CD pipelines   - Docker containerization & deployment   - Jenkins automation workflows   - Debugging real-world DevOps issues  🔗 GitHub Repository: https://lnkd.in/gJdnMAYT This project helped me understand how real-world DevOps pipelines work in production environments. Would love feedback and suggestions! #DevOps #CICD #Docker #Jenkins #GitHub #Automation #CloudComp

#100DaysOfDevOps - Day Forty - Eight Up until now, I had been tagging my Docker images in GitHub Actions using the workflow run number. It worked, but I wanted something more meaningful and more traceable. So today I moved toward using the Git commit hash as the image tag. What I worked on today: ✅ revisited why image tagging strategy matters ✅ moved from using the workflow run number to using github.sha ✅ explored GitHub Actions contexts and built-in variables ✅ checked commit hashes from both GitHub and git log ✅ learned why the full commit hash is too long to use directly ✅ extracted only the first few characters of the hash ✅ stored that shortened value as a workflow variable ✅ reused that variable across the image build, scan, and push stages ✅ observed how GitHub Actions automatically cleans up the runner after execution A better CI pipeline is not only about making it run but also about making its outputs easier to understand, track, and roll back when needed. I did hit another issue near the end around the backend image reference format, so there is still a bit of troubleshooting to finish. But overall, this was a strong step toward making the workflow more production-friendly. YouTube Video Link: https://lnkd.in/eM458884 #DevOps #100DaysOfDevOps #GitHubActions #Docker #ImageTagging #CICD #ContinuousIntegration #GitHub #Automation #CloudEngineering #LearningInPublic #TechdotSam

#100DaysOfDevOps - Day Forty - Six Today I continued working on the GitHub Actions version of my CI pipeline. The focus was on moving from the workflow skeleton into actual execution, one stage at a time, while testing and troubleshooting along the way. What I worked on today: ✅ created the .github/workflows/ci.yaml file ✅ pushed it to GitHub and confirmed the workflow was triggered ✅ verified that the checkout stage worked ✅ observed how GitHub Actions provisions a runner automatically ✅ added the backend test stage ✅ set up Python on the runner ✅ installed pip ✅ confirmed the backend test/lint stage ran successfully After that, I moved into the image build stage and started setting up: Docker-related steps GitHub secrets for Docker authentication environment variables for image names and tags That part came with multiple errors, including: wrong field names wrong action version invalid Docker tag formatting mismatched secret references And honestly, I’m glad it happened that way. Because one thing this journey keeps reinforcing is: CI/CD is not learned by only watching clean demos. It is learned by writing, testing, failing, correcting, and understanding why the workflow failed. So even though the image build stage is still being resolved, today still felt like strong progress because the earlier stages are now working, and the workflow is taking shape properly. Big takeaway: The deeper skill is not avoiding errors, it is learning how to read them and move forward with clarity. YouTube Video Link: https://lnkd.in/eDVKJz8d #DevOps #100DaysOfDevOps #GitHubActions #CICD #ContinuousIntegration #Docker #Automation #GitHub #YAML #PlatformEngineering #CloudEngineering #LearningInPublic #TechdotSam

We cut our deployment time from 47 minutes to 9 minutes using GitHub Actions. Here is what actually moved the needle. Not the flashy stuff. The boring stuff. 1. We stopped running the full test suite on every commit. Using pytest -k with changed-file detection, we ran only relevant tests. Saved ~11 minutes immediately. 2. We parallelised Docker layer caching properly. We were using cache, but pulls were still sequential in our workflow. Fixing that shaved off another 6–7 minutes. 3. We removed a manual approval gate that had been sitting in our pipeline since a production incident in 2022. No one on the team of 5 engineers could explain why it still existed. 4. We built a shared base image for our microservices instead of each service installing the same ~350MB of dependencies separately. The bottleneck in your pipeline is almost never where you think it is. Profile it first. Then fix it. What is the biggest time sink in your current pipeline? #CICD #DevOps #PlatformEngineering #GitHubActions #Docker

Day 39 of #90DaysOfDevOps 🚀 Today I focused on understanding CI/CD before building pipelines. Here’s a simple pipeline I designed: 🔹 Code pushed to GitHub 🔹 Build → Install dependencies & compile 🔹 Test → Unit & integration testing 🔹 Dockerize → Build & push image 🔹 Deploy → Run container on staging server 💡 Key takeaway: “It works on my machine” is not enough — CI/CD ensures consistency across environments. Next step → Implementing this using GitHub Actions ⚡ #DevOps #TrainWithShubham #CICD #GitHubActions #LearningInPublic

🚀 Recently explored GitHub Actions and built my first real CI pipeline. Earlier, I used to push code and manually test things. Now every push goes through an automated pipeline. 💡 What I understood about GitHub Actions: • Event-driven CI/CD (runs on push, PR, etc.) • Workflows defined using simple YAML files • Jobs run on isolated machines (runners) • Supports caching, secrets, artifacts, parallel execution • Acts as an automated quality gate 🛠️ What I built: • CI pipeline triggered on every push • Automated dependency install (npm ci) • Lint + build validation • Playwright E2E testing ✅ Covered real flows: • Login authentication • Ticket creation • Ticket details (Get One page) Also added failure debugging with screenshots & videos. 🏢 Why this matters in teams: In large projects with multiple developers: • Prevents broken code from reaching main • Enforces quality before merging PRs • Keeps environments consistent • Helps teams scale safely 📌 Biggest takeaway: Writing code is one thing. Making sure it works reliably for everyone — that’s where CI matters. #GitHubActions #CI #Automation #Playwright #Testing #SoftwareEngineering

Day 23 of learning and practicing DevOps 🔁 Explored some more concepts in Git — branching Worked on: • Creating and switching branches (feature-1, feature-2) • Making isolated commits without affecting main • Understanding git switch vs git checkout • Connecting local repo to GitHub and pushing branches • Learning git pull vs git fetch • Understanding clone vs fork and real workflows Important part: Git doesn’t just track files, it tracks versions across timelines. Learning today --> branching = safe development Here are my notes: https://lnkd.in/gxDM974h 📍 #DevOps #Git #VersionControl #GitHub #LearningInPublic #90DaysOfDevOps #TrainWithShubham 🚀

GitHub Actions: Build Your First CI/CD Pipeline for Code Testing Setting up automated testing with GitHub Actions doesn't have to be complicated. This guide shows you how to create a simple CI/CD pipeline that runs tests every time you push code to your repository. Read the full how-to guide: https://lnkd.in/dR74ZgeM #CICD #OpenSource #GitHub #Productivity #DevOps #ITTips #TechTips #Automation #SoftwareDevelopment #Testing

I learned something new today!! This diagram helped me understand how modern applications actually move from code → production using tools like Jenkins and Docker. Here’s the flow in simple terms: ▪️ 1. Pull Code Jenkins fetches code from GitHub ▪️ 2. Verify Basic checks to ensure everything is correct ▪️ 3. Build Images Docker builds application images ▪️ 4. Push to DockerHub Images are stored in a central registry ▪️ 5. Deploy Containers are started using Docker Compose ▪️ 6. Cleanup Unused images are removed to save space What I realized: CI/CD is not just automation — it’s about making deployments fast, consistent, and reliable. This is where development meets real-world production systems If you're learning backend or full stack, understanding pipelines like this is a game changer. What part of CI/CD do you find most confusing? 🤔 #DevOps #Jenkins #Docker #CICD #BackendDevelopment #FullStack #SoftwareEngineering #CodingJourney