https://devopsdive.com/project https://img.youtube.com/vi/PV7em_7fTnw/hqdefault.jpg Wanted Jira for My Team. Budget: Zero. So I Built My Own in React and Firebase. I wanted Jira. Could not afford Jira. Budget: zero dollars. So I did what any stubborn developer would do - I built my own. React, Firebase, a kanban board that actually worked the way I needed it to. React for the UI, Firebase for real-time data and authentication, drag-and-drop kanban columns - To Do, In Progress, Done. Task creation with priorities and deadlines. Real-time sync so multiple people can use it simultaneously. Firebase authentication with role-based access. The drag-and-drop that actually updates state correctly was harder than it sounds. Was it Jira? No. Was it mine? Absolutely. Every feature I built taught me something Jira never would have - React state management in practice, real-time databases, authentication flows, drag-and-drop UX. There is something different about building a tool you depend on. Every bug is annoying in a personal way. Every missing feature is something you genuinely notice. That urgency makes you a better builder. And when you show it in a portfolio interview, you can talk about the real decisions - not the tutorial decisions. You built it because you needed it. That story reads completely differently than a tutorial clone. Cannot afford the tool? Build it. That is how engineers are made. 0:00 Zero Dollar Tool Budget 0:13 React + Firebase Kanban Stack 0:31 What I Built: Tasks, Drag-Drop, Real-Time Sync 0:50 Build What You Cannot Afford Zero budget, one weekend, a tool that stuck. Subscribe for the scrappy builds. devopsdive.com #DevOps #React #Firebase #ProjectManagement #DevOpsDive https://www.youtube.com/embed/PV7em_7fTnw https://www.youtube.com/watch?v=PV7em_7fTnw 77 2026-07-17T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/Q6lyrn0E3GY/hqdefault.jpg Chess Game in React. En Passant Nearly Broke Me. Checkmate Broke Me Twice. Chess in React. Nobody asked me to build this. It wasn't on any job description. I needed to prove - to myself - that I could handle complex state management. Sixty-four squares. Thirty-two pieces. Infinite possible game states. React for the board and piece rendering. TypeScript for type-safe game logic - because when you are validating chess moves, a runtime error is not just a bug, it is an illegal move nobody catches. Rendering a board? Easy. Making the game actually follow the rules? That's where it got brutal. Check detection after every single move. Castling requires four conditions to all be true simultaneously. En passant - the most confusing rule in chess - is even more confusing in code. And the difference between stalemate and checkmate? One letter in English. Entirely different logic in TypeScript. Chess taught me more about state management than any Redux tutorial. More about TypeScript than any documentation page. The point was never to build the next Chess.com. The point was to pick something complex and finish it. That kind of thinking - modeling a system with interlocking rules where one wrong state corrupts everything downstream - transfers directly to distributed infrastructure, CI/CD logic, and anything where correctness actually matters. If your side projects are easy, you are staying comfortable. Pick something that scares you a little. Build it anyway. That is how you grow. 0:00 Chess in React: 64 Squares of Logic 0:15 React + TypeScript Stack 0:37 The Hard Part: Rules in Code 0:59 What Chess Taught Me 1:10 Build Something That Scares You Chess logic in TypeScript. Subscribe if side projects teach you more than docs. devopsdive.com #DevOps #React #TypeScript #StateManagement #DevOpsDive https://www.youtube.com/embed/Q6lyrn0E3GY https://www.youtube.com/watch?v=Q6lyrn0E3GY 82 2026-07-17T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/bIzMrjbBoZk/hqdefault.jpg A Calculator Broke My Brain. Then It Fixed How I Think About Engineering. A calculator. The project every developer has built. The one interviewers roll their eyes at on your portfolio. But mine taught me something nobody expected. Including me. JavaScript for the logic, HTML for the button grid, CSS Grid for the layout - my first time using it. No libraries, no calculator API. Just me, the DOM, and a lot of console.log statements trying to figure out why division by zero was not doing what I expected. Math was the surface. Underneath, I was learning state management before I even knew the term. What happens when someone presses equals twice? What about chaining operations? What if they type a decimal point after another decimal point? Every edge case forced me to think like an engineer, not just a coder. That calculator taught me event handling, state management, edge case thinking, and the discipline of finishing something. Those same skills I use every single day managing cloud infrastructure. User input is unpredictable. State management matters even in small apps. Edge cases are where real engineering lives. The lesson followed me from a simple calculator into every complex system I have touched since. Everyone wants to build the next big thing. Nobody wants to build a calculator. But the simplest project can teach the deepest lesson. If you let it. 0:00 The Calculator Nobody Respects 0:11 HTML, CSS, JavaScript - No Frameworks 0:29 The Real Lesson: State Management 0:49 Simple Projects, Deep Lessons A calculator broke my brain. Then it fixed how I think. Subscribe. devopsdive.com #DevOps #JavaScript #WebDev #VanillaJS #DevOpsDive https://www.youtube.com/embed/bIzMrjbBoZk https://www.youtube.com/watch?v=bIzMrjbBoZk 72 2026-07-16T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/ALgOJndKKH0/hqdefault.jpg Pharmacists Tracked Patients in Excel. I Built Them a Real CRM System. Pharmacists tracking patients in Excel. Hundreds of rows. Clinical research data. Filter, scroll, copy, paste. Every single day. I looked at that spreadsheet and said - I can fix this. Vue.js for the frontend, Firebase for the backend and real-time database. A full CRM built specifically for clinical research workflows - patient records, treatment tracking, follow-up scheduling, everything that Excel was never designed to do. Gone: the endless scrolling, the accidental overwrites of someone else's data. Real-time sync across the whole team. Processing time dropped 40 percent. Zero lost records. The workflow went 100 percent digital. Not because the pharmacists got faster - because the system stopped slowing them down. A tool built for humans, not for accountants. Vue and Firebase were just tools. The actual work started when I sat down with pharmacists, watched them work, understood their actual pain, and built something that made their day better. Just genuinely better. Talk to the users before writing a single line. Replace the process, not just the tool. Measure impact in human time saved. That is the difference between a developer and an engineer. Somewhere right now, someone is tracking mission-critical data in a spreadsheet. And they hate it. If you can find that person and build that tool - you are not just writing code. You are changing how people work. 0:00 Pharmacists in Excel: Hundreds of Rows Daily 0:14 The Build: Vue.js + Firebase Healthcare CRM 0:31 The Impact: 40% Faster, Zero Lost Records 0:50 The Real Lesson: Talk to Your Users 1:08 From Excel to Engineering Excel to real CRM. Subscribe for the builds that actually help people. devopsdive.com #DevOps #Vue #Firebase #ClinicalResearch #DevOpsDive https://www.youtube.com/embed/ALgOJndKKH0 https://www.youtube.com/watch?v=ALgOJndKKH0 86 2026-07-14T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/xHV4ga2dwyo/hqdefault.jpg 10 Minutes to Find One Log. Five Portals. I Built a Search Bar in a Weekend. Ten minutes. That is how long it took to find one error log. Click through Azure portal. Find the right resource. Filter by time. Scroll. Scroll more. Copy. Paste. Ten minutes. Every. Single. Time. eShop client. Support team drowning. Every bug report meant the same ritual - open five portals, cross-reference timestamps, pray you find the right log. Developers could not access logs themselves, so they filed tickets. And waited. I did not ask permission. I just built it. One weekend: Python web app, Elasticsearch under the hood for full-text search, Docker containers so it deploys anywhere. One search bar. Type the error. Hit enter. Thirty seconds. Done. Before: ten minutes, five portals, only ops had access. After: thirty seconds, one search bar, anyone on the team. I showed it Monday morning. They went crazy. The support lead actually hugged me. Not joking. Support tickets dropped significantly because developers could finally find their own errors. One weekend project. Months of saved time. Zero permission asked. The best projects are the ones nobody asked for. If you see your team struggling with something every single day - do not file a feature request. Build the fix. Show the result. That is how you become the engineer everyone wants on their team. 0:00 10 Minutes to Find One Error Log 0:14 Support Team Drowning in Clicks 0:30 Weekend Build with Elasticsearch + Python 0:47 Before and After the Fix 1:02 Fewer Tickets, Happier Team 1:16 Build the Fix Nobody Asked For Weekend build that the whole team uses. Subscribe for internal tooling stories. devopsdive.com #DevOps #Elasticsearch #Observability #LogSearch #DevOpsDive https://www.youtube.com/embed/xHV4ga2dwyo https://www.youtube.com/watch?v=xHV4ga2dwyo 96 2026-07-12T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/tqzDokTfUiU/hqdefault.jpg One Token Expired. Three Pipelines Broke for a Day. Cross-Platform Registry Fix. One expired token. Three broken pipelines. NuGet packages living in Azure DevOps, CI/CD running in GitLab. The gap between them was killing deployment speed. Every build meant reaching across platforms, hoping credentials still worked. Nobody trusted anything: PAT tokens expiring mid-sprint, CI/CD variables scattered across projects with zero documentation, and developers too scared to touch the NuGet config because last time someone did, three pipelines broke for a full day. The fix was moving everything to GitLab Package Registry - same platform for code, packages, and pipelines - and replacing every personal access token with CI_JOB_TOKEN, which is built-in, scoped, and needs zero rotation. Migrating packages was only half the job. The CI/CD variables were a graveyard: old Azure DevOps PATs nobody remembered creating, duplicate NuGet source URLs with slightly different names, variables nobody could explain. Audited every one, killed the dead ones, consolidated what remained. After that the pipeline flow became dead simple: dotnet restore from GitLab Registry, build and pack, push back. All authenticated with the job token automatically. Credential rotation calendar and mid-sprint surprises became a thing of the past. If your packages live in a different world than your pipelines, you are paying a tax on every single deploy. Authentication overhead, configuration drift, tribal knowledge about which token goes where. Consolidate. Let the platform do the heavy lifting. 0:00 Packages in Azure, Pipelines in GitLab 0:17 Zero Trust (Not the Good Kind) 0:35 The Migration Plan 0:53 Variable Cleanup 1:15 Pipeline Integration 1:37 One Platform, Zero Friction One expired token. Three broken pipelines. Subscribe before your next token expires. devopsdive.com #DevOps #NuGet #PackageRegistry #GitLabCI #DevOpsDive https://www.youtube.com/embed/tqzDokTfUiU https://www.youtube.com/watch?v=tqzDokTfUiU 117 2026-07-09T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/xbZnwoJaVNo/hqdefault.jpg 2 Hours of SSH Typos. One Wrong Rule = Network Down. Terraform Fixed It. Network configuration. Two hours of SSH sessions and typos. Logging into every router, copy-pasting firewall rules, hoping you did not miss a semicolon. Now twenty minutes of code. The old way was gambling: SSH into each MikroTik one by one, copy-paste rules between devices, miss one character and the network goes down, no version control, no rollback, no audit trail. If something broke you were figuring out what changed by memory. The solution is a Terraform provider talking directly to the MikroTik RouterOS API, with firewall rules, NAT, DHCP, and VLANs all defined in HCL. Python scripts handle bulk operations and pre-apply validation so errors get caught before they ever reach the router. And every change goes through a pull request - someone reviews it before the network feels it. Before: 2-3 hours per change, typos caused outages, zero audit trail, no rollback capability. After: 15-20 minutes per change, instant rollback via git revert, validation before apply, full change history for every router, every time. Network operations went from stressful to boring. And in networking, boring is exactly what you want. MikroTik, Cisco, Juniper - the principle is the same. Define it in code. Version it. Review it. Apply it safely. If your network configuration is not in Git, it does not exist - it is just tribal knowledge waiting to be lost. 0:00 2 Hours of SSH Down to 20 Minutes 0:18 The SSH-and-Pray Chaos 0:41 Terraform + Python + MikroTik API 1:07 Firewalls, VLANs, DNS - All in Code 1:32 Before and After Results 1:55 Network Config Belongs in Git Network config in Git. Not in someone's head. Subscribe — network-as-code content every week. devopsdive.com #DevOps #MikroTik #NetworkAsCode #RouterOS #DevOpsDive https://www.youtube.com/embed/xbZnwoJaVNo https://www.youtube.com/watch?v=xbZnwoJaVNo 136 2026-07-06T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/XQJJmsaXLY0/hqdefault.jpg A GitHub Search App Showed Me What I Actually Want to Build. React + API. I built a GitHub search app. React frontend, GitHub API. Search users, browse repositories, see stats. Pretty standard portfolio project. But halfway through building it, I realized something. I was building tools for developers. That was the moment. The app was straightforward: type a username, hit the GitHub API, display their profile. Repositories listed with stars, forks, and language breakdowns. Debounced search so I was not hammering the rate limit on every keystroke. Pagination for users with hundreds of repos. Clean, functional, useful. But what I noticed while building it was that I did not care about making a pretty consumer app. I cared about search efficiency, API rate limiting, data presentation for technical people. That pull - toward developer tooling, toward infrastructure, toward making other engineers more productive - is what eventually led me to DevOps. I did not sit down and decide to become a DevOps engineer. My side projects decided for me. Every time I had a free weekend, I was gravitating toward tooling, APIs, automation. That pattern meant something I had not said out loud yet. DevOps is developer tooling at infrastructure scale - and that realization started here, building a search bar for people who read commit counts. Your side projects are not just practice. They are a compass. Pay attention to what you build when nobody is telling you what to build. 0:00 GitHub Search App: The Moment It Clicked 0:16 React + GitHub API Build 0:33 The Realization: I Build for Developers 0:58 Your Side Projects Are a Career Compass The projects that tell you what you actually want. Subscribe for the journey. devopsdive.com #DevOps #GitHubAPI #React #PortfolioProject #DevOpsDive https://www.youtube.com/embed/XQJJmsaXLY0 https://www.youtube.com/watch?v=XQJJmsaXLY0 87 2026-07-05T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/l9BO3ULJNzk/hqdefault.jpg 99.5% Uptime. Not AWS. Not Azure. Proxmox in My Home Lab. Built From Scratch. Ninety-nine point five percent uptime. No AWS, no Azure, no managed cloud with a billion-dollar SLA. Proxmox. In my home lab. Built from scratch. The full architecture: a Proxmox VE cluster with high-availability across multiple nodes, shared storage via Ceph and NFS for live VM migration between hosts, network infrastructure with VLANs, bonding, and redundancy baked in - and everything managed through Terraform for provisioning and Ansible for configuration. No clicking in a web UI. Nothing done manually twice. Then the HA test that actually matters: pulled the power on a live node. Watched VMs automatically migrate to healthy hosts. Fencing isolated the failed node. Services back in minutes, not hours. Zero data loss. The biggest lesson from building this: the gap between "it works" and "it works reliably" is enormous. Monitoring everything with Prometheus and Grafana, testing backup restores rather than just configuring them, and writing documentation as if someone else will maintain it at 3 AM - that mindset is what separates a hobby from real engineering. And it translates directly to enterprise work. You do not learn data center operations from tutorials. Real hardware, real networking, real consequences when something breaks with no support team to call. The cloud is someone else's computer. Sometimes the best teacher is your own. 0:00 99.5% Uptime from a Home Lab 0:16 Why Build a Home Lab? 0:33 The Architecture 0:55 High Availability in Action 1:13 Lessons Learned 1:36 Build Your Own Home lab. 99.5% uptime. Subscribe if you're building your own infrastructure too. devopsdive.com #DevOps #Proxmox #HomeLab #Homelab #DevOpsDive https://www.youtube.com/embed/l9BO3ULJNzk https://www.youtube.com/watch?v=l9BO3ULJNzk 117 2026-07-02T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/nOMt_R1AUBw/hqdefault.jpg Every Monday Someone Forgot the Import. Data Team Angry. So I Automated It. Every Monday morning. Someone forgot to trigger the import. Again. The data team is waiting. The product team is angry. And the person responsible? On vacation. A critical data import job triggered manually by one person, credentials stored who-knows-where, no monitoring - failures discovered hours later when someone downstream finally complained. The automation replaced all of it: Azure scheduled triggers firing every Monday at 6 AM before anyone is awake, Bash scripts that orchestrate the import, validate the data, and retry on failure, and credentials stored in Key Vault instead of someone's notebook. If retries exhaust, the team gets a Slack alert instantly - so they know before standup, not after. Every single run is logged and tracked. The thing about manual processes like this is that they feel fine until they are not. One person holds all the context. They go on leave, change jobs, or just have a bad Monday - and suddenly the whole pipeline is down with nobody knowing why. That is not a people problem. That is an engineering gap. Since automation went live: zero missed imports. Not one. Data ready before standup. Nobody needs to remember, nobody needs to be awake. And that one person who used to be the single point of failure? They finally took a real vacation. Your team deserves better than being a cron job with legs. 0:00 Monday Morning Import Missed Again 0:11 The Manual Trigger Pattern 0:26 Azure + Bash + CI/CD Automation 0:44 Alerts, Retries, and Audit Logs 1:01 Zero Missed Imports Since Launch 1:19 Automate the Monday Dread Manual Monday imports — automated forever. Subscribe and stop being a human cron job. devopsdive.com #DevOps #Automation #Azure #AzureLogicApps #DevOpsDive https://www.youtube.com/embed/nOMt_R1AUBw https://www.youtube.com/watch?v=nOMt_R1AUBw 92 2026-06-30T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/K6NSI4MzLcs/hqdefault.jpg GitLab and Bitbucket. Nobody Would Switch. So I Built a Real-Time Mirror. A real-time Git mirror between two platforms. Two teams. One codebase. Nobody wants to switch. Developers on GitLab, ops on Bitbucket, and management asking why nothing lines up. Everyone said pick one platform and force the switch. But real engineering is not about forcing people. So I built a bidirectional Git mirror instead - GitLab CI triggers on every push event, conflict-aware sync with branch mapping filtered by naming convention, and a retry mechanism with alerting because production sync failures at 2 AM are not optional to fix. The parts nobody warns you about: force pushes that shatter the mirror state, auth tokens expiring mid-sync on a Friday evening, webhook storms during release day flooding the pipeline queue, and two developers pushing the same file to both platforms at the exact same moment. Every single one of these happened. Every single one needed its own fix. The hard problem was not the sync itself - it was all the ways sync can silently fail without anyone noticing for days. End result: sync latency under 30 seconds, zero drift between platforms, and the cross-team blame game completely gone. Both sides kept their preferred tool, the codebase stayed unified, and the reliable sync uptime held over months of operation - not because the system is perfect, but because the error handling is. Sometimes the best migration is no migration at all - just a really good mirror. 0:00 Two Platforms. One Codebase. Nobody Wants to Switch. 0:12 The Real Problem: Not a Tool War, a People War 0:30 The Mirror Architecture: Bidirectional Sync via GitLab CI 0:51 The Hard Parts Nobody Warns You About 1:15 The Results: Zero Drift, 30-Second Sync 1:35 Two Platforms, One Truth GitLab and Bitbucket synced live. Subscribe — platform engineering gets creative here. devopsdive.com #DevOps #GitMirror #GitLab #Bitbucket #DevOpsDive https://www.youtube.com/embed/K6NSI4MzLcs https://www.youtube.com/watch?v=K6NSI4MzLcs 118 2026-06-28T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/EdWIuXwV2iw/hqdefault.jpg MACH Architecture Almost Killed Our Deployment. Beautiful on Paper. Brutal Live. MACH architecture. Microservices, API-first, Cloud-native, Headless. Sounds beautiful on a whiteboard. But deploying it? That is where most teams fall apart. Multiple microservices with their own deployment scripts. No standards. Manual configuration. Rollback strategy: redeploy and pray. So I built the MACH Composer platform that ties it all together. Before MACH Composer the situation was exactly what you would expect: every microservice deployed differently, no shared pipeline standards, environment configuration done manually for each service, and the rollback strategy was literally "redeploy the previous version and pray." Nobody had visibility into what was deployed where. The composer platform sits on top of GitHub Actions and treats all services as one coherent deployment unit. One config file defines every microservice, its version, its dependencies, and its infrastructure requirements. Push to main, the composer figures out the correct deployment order, handles environment config, and rolls back automatically if health checks fail after deployment. The architecture layers properly underneath: microservices stay independent and individually versioned and testable, API gateway provides a unified entry point, service mesh handles inter-service communication with retries and circuit breakers, and the entire infrastructure layer is Terraform-managed so code changes drive infrastructure changes automatically. The real-time dashboard shows exactly which version of which service is running in which environment - no more mystery about what is actually live. MACH is beautiful in theory. Without a deployment platform holding it together, it is just a collection of independently failing services. 0:00 MACH: Four Letters, One Platform 0:15 The Deployment Chaos Before 0:33 MACH Composer to the Rescue 0:55 Architecture: Mesh, IaC, Zero-Downtime 1:16 Before and After Results 1:35 MACH Is a Deployment Mindset MACH architecture in production. Subscribe — the gap between slides and reality is huge. devopsdive.c… https://www.youtube.com/embed/EdWIuXwV2iw https://www.youtube.com/watch?v=EdWIuXwV2iw 112 2026-06-25T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/PuKJlgTGOwI/hqdefault.jpg I Built a Real Store. React, Node, MongoDB. Not a Tutorial. A Real Store. Full stack e-commerce. React, Node, MongoDB. The MERN stack. Not a tutorial follow-along. My graduation project into real engineering - the one where everything finally came together. React for the storefront, Redux for state management across cart and user sessions and product filtering, Node.js with Express for the REST API, MongoDB for the product catalog and order history. Real features: product catalog with search and filtering, shopping cart with quantity management, full checkout flow, JWT authentication, admin panel for managing products. Every layer talking to the next. Every layer something new to learn. Not a demo where someone holds your hand - a real store, real bugs, real problems to solve. Before this project, I understood pieces. React here. An API there. A database somewhere. After building this store end to end, I understood systems - how the frontend talks to the backend, how the backend talks to the database, how authentication flows through every layer. That full-stack thinking is what eventually made me a better DevOps engineer. Infrastructure is just another layer, and once you have built them all yourself, you understand why each one matters and where each one can break. Building full stack changes how you think. It is worth doing at least once. 0:00 Full Stack E-Commerce: My Graduation Project 0:14 The Stack: React, Redux, Node.js, MongoDB 0:29 Real Features: Cart, Checkout, Auth, Admin 0:51 Full Stack Thinking: Understanding Every Layer 1:08 Full Stack Changes Everything Built a real store. Understood real systems. Subscribe — more build stories coming. devopsdive.com #DevOps #MERN #React #MongoDB #DevOpsDive https://www.youtube.com/embed/PuKJlgTGOwI https://www.youtube.com/watch?v=PuKJlgTGOwI 79 2026-06-24T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/3bdO20D0aJQ/hqdefault.jpg 62 Azure Subscriptions. Zero Cost Alerts. Nobody Watched the Bill. I Fixed It. 62 Azure subscriptions. Different teams. Different budgets. And not a single automated cost anomaly alert across any of them. Nobody was watching the bill. A forgotten VM running three months. A test environment burning premium storage. A misconfigured autoscaler spinning up 50 instances while everyone was asleep. All discoverable. All preventable. Automating cost anomaly detection across all 62 subscriptions with one Azure Automation Runbook. Budget alerts are reactive - they fire after you have already spent the money. Anomaly detection is different: it uses ML to build a baseline of your normal spend patterns, then alerts when spend deviates from that baseline. The difference between catching something on day 2 versus finding it on the invoice 30 days later is real money. The Automation Runbook authenticates via Managed Identity so there are zero stored credentials, iterates all 62 subscriptions, checks if an anomaly alert already exists, creates one where missing and updates any that have drifted, with expiration set to 2030 so nobody has to babysit it. One execution, 62 subscriptions configured, consistent and repeatable. The first catch after deployment: a test environment that had been running forgotten for 11 days. The alert fired on day 2. The previous approach would have surfaced it on the invoice 30 days later. Before: monthly invoice review, finger-pointing, post-mortem, promise to keep an eye on it. After: anomaly detected in real time, right team notified, investigation while it is still small. 62 subscriptions. One runbook. Zero blind spots. That is FinOps at scale. 0:00 62 Subscriptions. Zero Cost Visibility. 0:30 The Money Fires: Real Cloud Disasters 1:00 Why Native Budget Alerts Fail 1:29 The Automation Runbook: 62 Subscriptions, One Script 2:00 What Changed: Monthly Surprise to Same-Day Catch 2:28 Your Worst Cloud Bill - Drop It in the Comments 62 subscriptions, zero cost alerts. Subscribe — I build FinOps tools live. devopsdive.com #DevOps #FinOps #CostOptimization #AzureBilling #DevOpsDive https://www.youtube.com/embed/3bdO20D0aJQ https://www.youtube.com/watch?v=3bdO20D0aJQ 210 2026-06-21T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/F6gwStfzzGU/hqdefault.jpg No Backup Strategy. Millions in E-Commerce Transactions. One Question Fixed It. No backup strategy. E-commerce platform. Millions in daily transactions. The team was sleeping fine until I asked one question: what happens if we lose the product catalog tomorrow? Commercetools is SaaS. But your data is your problem. An automated backup system with Azure Logic Apps - daily exports, validation, restore dry-runs, and a disaster recovery simulation that changed minds. Commercetools has no built-in backup scheduler and no point-in-time recovery. Products, categories, prices, customers - all mutable, all fragile. One bad import script can overwrite thousands of product records in seconds. Without a backup you are rebuilding manually for weeks, and that is if you even know what the clean state looked like. The solution uses Azure Logic Apps to export all critical data types on a schedule into Azure Blob Storage with proper retention. What separates a real backup from a checkbox backup is validation: record count checks after every export, schema integrity verification, and automated restore dry-runs every week. Slack alerts fire immediately on any validation failure. Then came the DR simulation that changed everyone's mind. We simulated a corrupted product catalog - thousands of products with prices, categories, and custom attributes wiped. Without the backup system, the team estimated weeks of manual reconstruction. With it: full recovery in under one hour. The room went silent. Budget was approved permanently before the meeting ended. SaaS does not mean safe. Your data is your responsibility - build the backup before you need it, not after. 0:00 No Backup Strategy. Millions in Transactions. 0:15 The Uncomfortable Truth About SaaS Data 0:33 Azure Logic Apps: Automated Daily Exports 0:55 Trust but Verify: Backup Validation 1:16 The Recovery Test: Full Restore in Under an Hour 1:42 Backup Is Not Optional No backup strategy in production. Subscribe before you learn this lesson the hard way. devopsdive.com #DevOps #DisasterRecovery #Commercetools #DataProtection #DevOpsDive https://www.youtube.com/embed/F6gwStfzzGU https://www.youtube.com/watch?v=F6gwStfzzGU 119 2026-06-16T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/XYi-OZT5nSA/hqdefault.jpg One Command. Entire Azure Monitoring Stack Deployed. 7 Bicep Modules. Done. Seven Bicep modules. The entire monitoring stack. Deployed with one command. Click-ops monitoring dies the moment someone asks: can we reproduce this in another environment? Building a complete Azure monitoring stack in Bicep - from Log Analytics to 31 KQL-based alert rules, 8 action groups, and two-stage deployment. The inheritance situation was familiar: someone had clicked through Azure Portal, created alert rules one by one, documented the process as "I know how it works," then left the team. Monitoring became a black box nobody dared touch. Why Bicep over Terraform for this? Bicep speaks Azure's language natively with no translation layer, gets new features on day one, and handles DCR quirks without edge cases. The 7 composable modules are: Resource Group with environment-aware naming, Log Analytics Workspace, DCR for VM Insights, DCR for Logs split by server type, Custom Tables for SQL and app-specific data, 31 KQL-based Alert Rules, and 8 Action Groups mapped to team channels. Deployment is two-stage because dependencies matter: Stage 1 handles the infrastructure layer - resource group, workspace, DCRs, custom tables. Stage 2 deploys the alerting layer - the 31 rules and 8 action groups that reference Stage 1 resources. Clear checkpoint between them. The ultimate test of IaC is whether you can tear it down and rebuild from scratch identically. Stage 1, Stage 2, done. Try that with click-ops monitoring. 0:00 7 modules, complete monitoring, one command 0:15 The inheritance problem 0:50 Why Bicep over Terraform for Azure 1:30 The 7 modules breakdown 2:30 Two-stage deployment 3:15 Tear it down, rebuild identical One command. Full monitoring stack. Subscribe — Bicep content you can deploy today. devopsdive.com #DevOps #Bicep #AzureMonitoring #InfrastructureAsCode #DevOpsDive https://www.youtube.com/embed/XYi-OZT5nSA https://www.youtube.com/watch?v=XYi-OZT5nSA 116 2026-06-14T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/i9PESI2uqKI/hqdefault.jpg Disk Full at 2 AM? My Autonomous System Catches It at 6 AM. 100+ Disks. Every morning at six. Before anyone wakes up. Before the first coffee. A Logic App runs KQL across over one hundred production disks. Windows. Linux. By the time the team opens their laptops, the report is sitting in their inbox. Building an autonomous disk monitoring system - from reactive alerts to proactive daily reports with trending data and smart routing. The old pattern: disk fills up at 2 AM, alert fires, someone wakes up, scrambles to free space, resolves the ticket, goes back to sleep, repeat next week. No trending, no forecasting, just reactive firefighting. And in a mixed estate with Windows and Linux machines plus NFS mounts throwing false positives, figuring out what is real is half the battle. The new architecture flips the whole thing: Logic App triggers at 6 AM, KQL queries run against Log Analytics with Windows and Linux on separate paths, NFS mounts filtered out automatically so they do not pollute results. Two routing lanes based on thresholds: above 90% sends an immediate alert to on-call with a high-priority ticket and escalation chain, above 75% lands in the daily trending report so the team can plan and fix it before it ever becomes an incident. This is not a cron job on a VM that breaks when someone patches it. Serverless, pay per execution, self-healing retries on transient failures, running months without a single manual intervention. 100 plus production disks. Zero surprises at 2 AM. The best incident is the one that never happens. 0:00 Every Morning at 6 AM: Autonomous Disk Reporting 0:20 The Problem: Reactive Alerts at 2 AM 0:44 The Architecture: Logic App + KQL + Smart Routing 1:01 Critical vs. Proactive: Two Alert Lanes 1:24 Fully Autonomous: No Cron Jobs, No Babysitting 1:44 100+ Disks. Zero Surprises. No more 2 AM disk alerts. Subscribe for the automation that lets you sleep. devopsdive.com #DevOps #DiskMonitoring #Azure #KQL #DevOpsDive https://www.youtube.com/embed/i9PESI2uqKI https://www.youtube.com/watch?v=i9PESI2uqKI 124 2026-06-11T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/vCIvuO-zmjM/hqdefault.jpg 12 GB Git Repo. Passwords in Commit History. Stale Branches. We Fixed It Live. Massively bloated. That is the only way to describe this Git repository. Clone time? Forget about it. Build time? Eternity. Binary artifacts committed to Git. Thousands of stale branches. Passwords buried in old commits. The full cleanup: BFG Repo Cleaner, pipeline optimization, and the guardrails that prevent it from ever happening again. When I started digging into this 12 GB repo the picture got worse fast: JARs, ZIPs, even Docker images committed directly to Git, thousands of stale branches dead for years, and actual passwords and API keys sitting in old commit history. The repo was not just bloated - it was a security risk that had been quietly sitting there the whole time. The cleanup was surgery: BFG Repo Cleaner to strip binaries from history, every large file migrated to a proper artifact registry, secrets rotated and then scrubbed from every commit. Then the CI pipeline itself got restructured - sequential stages split into parallel, Docker layer caching added, selective testing so only affected modules run. The guardrails that prevent it from growing back: pre-commit hooks blocking files over 5MB, branch lifecycle policy with auto-delete 7 days after merge, secret scanning built into the CI pipeline, and repo size monitoring with alerts. Cleanup without guardrails is just a temporary fix. Your Git repository is the foundation of your entire delivery pipeline - when it is clean, everything flows. 0:00 Bloated Git Repo: Clone Time in Eternities 0:16 The Archaeology: Binaries, Dead Branches, Secrets 0:40 The Cleanup: BFG, Artifact Registry, Secret Scrubbing 1:06 Pipeline Optimization: Parallel, Cached, Selective 1:33 Guardrails: So It Never Happens Again 1:58 From Bloated to Lean 12 GB to clean Git. Subscribe before your repo becomes the next rescue mission. devopsdive.com #DevOps #Git #PipelineOptimization #GitSecurity #DevOpsDive https://www.youtube.com/embed/vCIvuO-zmjM https://www.youtube.com/watch?v=vCIvuO-zmjM 146 2026-06-10T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/c6hQQ4w1dAY/hqdefault.jpg 8 GCP Projects. 99 Service Accounts. One Chance to Migrate Without Breaking. Eight GCP projects. Ninety-nine service accounts. Two organizational tenants. And one requirement - move everything to a secure, policy-compliant environment without breaking a single deployment. The phased migration of a global enterprise platform from a legacy GCP tenant to a governed one - IAM hardening, CI/CD standardization, network dependencies, and cost governance. What we inherited: 99 service accounts most of which had never been audited, many carrying owner-level access from years back that nobody had touched. No naming conventions, no org policies, projects scattered across folders with no clear ownership. The dev team loved the autonomy. Leadership needed governance. The job was to deliver both. The phased approach: dev project first to validate the migration path, then five production workloads with complex cross-domain access requirements, then the analytics and dashboards data layer, and finally onboarding everything into the secure tenant with strict policies, naming standards, and full compliance. The most nerve-wracking piece was surgical IAM hardening - cleaning up 99 service accounts without breaking production. The CI/CD pipeline design had to give developers autonomy while enforcing security guardrails, because the team deployed multiple times a day and you cannot slow them down. MySQL tunnels and cross-project network dependencies all had to survive the move. Eight projects migrated, zero downtime, deployment frequency unchanged. Governance without friction - that is the only kind that actually works at global scale. 0:00 The migration challenge 0:18 What we inherited 0:38 The phased approach 1:02 Where it got painful: IAM, CI/CD, and network 1:28 The outcome 1:52 Governance without friction 99 service accounts. One migration window. Subscribe — GCP gets real here. devopsdive.com #DevOps #GCP #CloudMigration #ServiceAccounts #DevOpsDive https://www.youtube.com/embed/c6hQQ4w1dAY https://www.youtube.com/watch?v=c6hQQ4w1dAY 134 2026-06-09T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/kGZSQl6_dYg/hqdefault.jpg 3 Hours of Clicking Proxmox Wizards. Or 15 Minutes of Terraform. I Snapped. VM provisioning. Three hours of clicking through wizards, copying IP addresses, configuring networking by hand. Now fifteen minutes of Terraform. Same result. Ten times faster. Zero human error. Automating Proxmox VM provisioning with Terraform, Ansible, and Python - from manual clicking to fully automated, consistent, Git-tracked infrastructure. Before automation, every VM meant clicking through the Proxmox UI, manually setting up networking and storage, tracking IP addresses in a spreadsheet if you were lucky - and because it was all manual, no two VMs ever ended up identical. The stack that replaced it: Terraform talks directly to the Proxmox API for provisioning and networking, Ansible runs post-provisioning configuration and security hardening automatically, and Python scripts handle template management and orchestration. The workflow is define your VM specs in a YAML file, run terraform plan to review exactly what will be created, apply, and Ansible does the rest hands-off. From 2-3 hours down to 10-15 minutes per VM. Every VM identical - no snowflakes. IP management automated, no more spreadsheets. And everything lives in Git, so a new engineer can read the code and understand how everything works on day one. No tribal knowledge, no documentation that is six months out of date. If you provision a VM by hand more than twice, you are wasting your life. 0:00 VM Provisioning: 3 Hours to 15 Minutes 0:16 The Pain of Manual Everything 0:42 The Solution: Terraform + Ansible + Python 1:03 The Workflow 1:28 The Impact 1:49 Automate the Pain Away 3 hours of clicking to 15 minutes of code. Subscribe if you're still provisioning by hand. devopsdive.com #DevOps #Proxmox #Terraform #InfrastructureAsCode #DevOpsDive https://www.youtube.com/embed/kGZSQl6_dYg https://www.youtube.com/watch?v=kGZSQl6_dYg 131 2026-06-08T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/09hAQjjwFf0/hqdefault.jpg No API Gateway. Microservices Talking Directly. Pure Chaos. I Built the Fix. Every microservice talking to every other microservice. No gateway. No rate limiting. No visibility. Just a web of direct calls that nobody can trace, nobody can throttle, and nobody can secure. Implementing Azure API Management - from spaghetti architecture to a single, Terraform-managed gateway with OAuth, rate limiting, full observability, and multi-region HA. The classic enterprise spaghetti: Service A calls Service B directly with no auth between them, one misbehaving service floods another and takes down the entire chain, and debugging means reading raw logs to figure out which service called which endpoint at what time. Every API call now goes through APIM instead - OAuth, JWT validation, and mutual TLS enforced at the gateway layer. Rate limiting per client, per subscription, per product. Full request tracing from entry point to backend and back. The entire setup is Terraform-managed: the APIM instance, API definitions imported from OpenAPI specs, XML policy templates version-controlled and peer-reviewed, and promotion from dev to staging to production through one pipeline with zero drift. Multi-region active-active deployment with blue-green updates means the gateway itself never becomes the single point of failure. If your microservices are talking to each other without a gateway, you do not have an architecture. You have a time bomb. 0:00 No gateway, no visibility - microservice chaos 0:14 The spaghetti: direct calls, no auth, no rate limits 0:36 Azure API Management: one gateway to rule them all 0:59 Everything Terraform-managed: policies as code 1:20 High availability: multi-region, active-active 1:36 Build it right, build it in code, sleep at night API chaos to API gateway. Subscribe — the architecture transformation took three months. devopsdive.com #DevOps #APIM #AzureAPIManagement #APIGateway #DevOpsDive https://www.youtube.com/embed/09hAQjjwFf0 https://www.youtube.com/watch?v=09hAQjjwFf0 116 2026-06-07T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/_RRyyNkVJnQ/hqdefault.jpg 22 of 246 VMs Reporting to Azure. The Rest Were Silent. No Logs. Nothing. Twenty-two VMs reporting. Out of two hundred forty-six in production. The other two hundred twenty-four? Silent. No metrics. No logs. No heartbeat. A migration incident broke the Data Collection Rule associations. VM Insights just silently stopped reporting. Not a single error or alert fired. The monitoring system itself was unmonitored. The recovery: Azure Policy remediation at scale, immutable rules, and the question every team should answer - who monitors your monitoring? DEV was even worse - 30 of 115 VMs still reporting, the rest gone dark. The root cause was a routine migration that severed DCR associations across the board without triggering a single alert anywhere. The remediation path: Azure Policy Remediation to reassociate every VM with the correct Data Collection Rule at scale, not manually one by one. 246/246 PROD VMs back to full reporting. 115/115 DEV VMs recovered. The real architectural fix was the immutable rule that came after: if a VM exists, it reports. No exceptions. Azure Policy now enforces DCR association on every VM automatically - new VMs get monitoring at creation time, and a compliance dashboard shows any gaps in real time. The scariest gap is the one you do not know about. If you manage cloud environments at scale, find out whether your monitoring has its own monitoring before a migration incident answers that question for you. 0:00 22 of 246 VMs Reporting 0:16 The Discovery: DCR Associations Broken 0:34 The Recovery at Scale 0:57 The Immutable Rule 1:21 Monitor Your Monitoring 246 VMs. 22 reporting. Subscribe before you check your own dashboard. devopsdive.com #DevOps #VMInsights #Azure #AzureMonitoring #DevOpsDive https://www.youtube.com/embed/_RRyyNkVJnQ https://www.youtube.com/watch?v=_RRyyNkVJnQ 107 2026-06-06T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/_v5yetgu6L0/hqdefault.jpg Release Day Was 3 Hours of Manual Pain. I Automated It Down to 15 Minutes. Manual release branches. Copy-paste version bumps. Three hours every sprint. Somebody always forgot a step. Somebody always merged to the wrong branch. Every two weeks, the same story: create the release branch, bump versions across five files, update changelogs, merge to staging, tag, pray. Wrong branch merged meant a hotfix got lost. Version bump forgotten meant the build failed in QA. And when the release manager was on vacation? Chaos. Nobody knew all the steps because the steps lived in someone's head, not in code. The fix is a Bash tool that talks to the Bitbucket API. One command creates the release branch from develop, bumps versions across all config files, opens pull requests with the right reviewers already assigned, tags the release, and updates the changelog. Before: 3 hours, 5 people, errors every sprint. After: 15 minutes, one command, zero mistakes. Any developer on the team can run it. No tribal knowledge required. The release process is in the code now, not in someone's memory. Three principles that guided the work: if you do something more than twice, script it. If it requires tribal knowledge, put that knowledge in code. If the process scares people, make it so boring that anyone can do it. Release management is not glamorous. Nobody posts about it. But when the team stops dreading sprint endings and starts shipping with confidence - that is quiet, boring, beautiful impact. 0:00 Manual Releases: 3 Hours Every Sprint 0:14 The Pain of Human Error 0:33 Bitbucket API + Bash Solution 0:47 Before vs After 1:05 Automate the Boring Stuff 1:22 Processes Belong in Code Release automation before and after. Subscribe — more time-saving wins every week. devopsdive.com #DevOps #ReleaseManagement #CICD #Automation #DevOpsDive https://www.youtube.com/embed/_v5yetgu6L0 https://www.youtube.com/watch?v=_v5yetgu6L0 102 2026-06-05T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/E2nyy7q61x4/hqdefault.jpg 389 Monitoring Alerts at a Bank. We Ignored 350. Then I Audited All 389. Three hundred eighty-nine alerts. Legacy SolarWinds. Nobody knew which ones still mattered. Some had not fired in two years. Others fired every hour and everyone ignored them. That is not monitoring. That is noise. The environment: 500+ virtual machines across Windows and Linux, 62 Azure subscriptions, 98 application monitors baked into SolarWinds, and banking compliance on top of everything - CAB approvals, change tickets, zero room for mistakes. Alert fatigue here was not a theory. On-call engineers had learned to tune out the alerts. Which means the ones that actually mattered were getting tuned out too. Every single one of the 389 alerts reviewed manually - cross-referenced against actual incidents, checked last-fired timestamps, mapped every rule to a real business impact. Most had none. The output: 98 app monitors consolidated into 31 optimized alert rules. The new architecture uses Azure Monitor as the single platform, 5 data collection rule types covering every workload pattern, 8 action groups for smart routing between critical, warning, and informational, and everything defined in Bicep so it is repeatable and auditable, not clicked together in a portal. In a bank you do not flip a switch. Every change through CAB. Full rollback procedures documented before touching anything. Phased migration with a non-negotiable rule: zero monitoring gaps during cutover. At no point were those 500+ VMs unmonitored. Not for a second. From 389 alerts nobody trusted to 31 rules everyone acts on. 0:00 389 SolarWinds Alerts, Total Chaos 0:18 500 VMs, 62 Subscriptions, Banking Compliance 0:33 Auditing All 389 Alerts Manually 0:56 New Architecture: DCRs and Action Groups 1:17 CAB Approvals with Zero Monitoring Gaps 1:38 From 389 Alerts to 31 That Matter 389 alerts down to 31. Subscribe to see how I trim the noise. devopsdive.com #DevOps #Monitoring #Observability #AlertFatigue #DevOpsDive https://www.youtube.com/embed/E2nyy7q61x4 https://www.youtube.com/watch?v=E2nyy7q61x4 118 2026-06-04T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/xoyjdBUGWFs/hqdefault.jpg 500 VMs. Only 22 Were Actually Monitored. Azure Arc Hybrid Cloud Fixed It. Five hundred VMs. Azure native. VMware. On-premises. Three different worlds and someone had to connect them all under one control plane. That someone was me. VM Insights was supposed to cover production. Twenty-two out of two hundred forty-six machines were actually reporting. Dev was even worse - thirty out of one hundred fifteen. Three teams using three different portals with zero shared visibility. That is not monitoring. That is a false sense of security. The strategy was Azure Arc - not rip and replace, not a five-year migration plan. Connect what exists. Azure native resources were already there. VMware workloads came through Azure VMware Services. On-premises servers got Arc agents that brought them into the same control plane. One portal. One policy engine. One monitoring stack. VM Insights recovery was the first win: policy-driven agent deployment means if a VM exists, it gets monitored. No exceptions and no manual installs -- Azure Policy handles remediation automatically. Production went from 22 of 246 reporting to all 246. Dev went from 30 of 115 to full 115. Then compliance. A VM drifts from the baseline? Remediation kicks in automatically. No ticket. No meeting. No blame. The infrastructure enforces its own rules. That is what immutable infrastructure actually means in a hybrid world. The final state: 100% VM Insights coverage across prod and dev, three environments managed from a single control plane, policy remediation on autopilot, 500+ VMs fully visible and compliant. 0:00 500+ VMs Across Three Worlds 0:17 The Starting Point: Blind Spots Everywhere 0:36 Azure Arc Strategy 1:04 VM Insights Recovery 1:21 Policy and Immutable Infrastructure 1:45 The Results 1:59 Hybrid Is an Architecture to Master 500 VMs finally visible. Subscribe — hybrid cloud gets messier from here. devopsdive.com #DevOps #AzureArc #HybridCloud #HybridMonitoring #DevOpsDive https://www.youtube.com/embed/xoyjdBUGWFs https://www.youtube.com/watch?v=xoyjdBUGWFs 137 2026-06-03T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/4c606lTvO_w/hqdefault.jpg My First 200 OK. I Stared at JSON Like It Was Magic. Everything Changed. 200 OK. My first API response. And suddenly everything I'd been learning about how the web works - clicked. The project: connect to the FakeStore API, fetch products, render them in React. Category filtering. Product details page. Shopping cart state. On paper it sounds basic. In practice it was the first time the client-server relationship became real - not from a textbook, but from actual code talking to an actual API. That JSON response on screen, dynamically, for the first time - that is when the web stopped being magic and started being engineering. What this project really taught: the network is not reliable, so you need loading states and error handling. Async code is a completely different way of thinking - promises, then chains, async/await. And APIs are contracts - read the documentation, trust the schema, do not assume the data shape. These are not frontend lessons. They are engineering lessons that scale from a fake store all the way up to Terraform providers, Azure REST calls, and Kubernetes webhooks. Every modern application talks to an API. The browser talks to a backend. The backend talks to a database. Microservices talk to each other. Understanding that flow - request, response, status codes, error handling - is the foundation of everything that came after. Every senior DevOps engineer, every cloud architect, every SRE had a first 200 OK. This was mine. 0:00 200 OK - the moment the web clicked 0:14 FakeStore API + React: products rendered in real time 0:35 What APIs really teach you about engineering 0:58 APIs are everywhere - once you get it, you never go back First API call to production systems. The full journey starts here. Subscribe. devopsdive.com #DevOps #React #JavaScript #FirstProject #DevOpsDive https://www.youtube.com/embed/4c606lTvO_w https://www.youtube.com/watch?v=4c606lTvO_w 84 2026-06-02T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/HHO0ouKPfxE/hqdefault.jpg 26 App Services. Zero Health Checks. In a Bank. Processing Transactions. Twenty-six Azure App Services. Not one had a health check endpoint configured. In a bank. Processing transactions. Serving customers. The platform just assumed everything was healthy. Hope is not a strategy. Without health checks you get zombie instances. The process is running, the instance is up, but the application inside is dead. The load balancer keeps sending traffic to it. Users get errors. Nobody knows why until someone manually checks. In a banking environment where every failed request could be a failed transaction. The rollout was done in 5 rounds - not a big bang. Round 1 covered non-critical, low-traffic services to validate the pattern. Then internal APIs, mid-tier services, customer-facing applications, and finally the critical banking workloads. Every round through CAB with full rollback documented before touching anything. The implementation: Azure Policy to enforce health check configuration. Actual policy -- not a best practice document nobody reads. If you deploy an App Service without a health check, the deployment gets flagged. Automatic unhealthy instance replacement kicks in the moment a probe fails. The team finds out from the system, not from a customer complaint. The full rollout covered all 26 services across 5 rounds with zero downtime and zero incidents. The lasting result is a repeatable pattern. Every new App Service now gets a health check from day one - not because someone remembers to configure it, but because the policy enforces it automatically. 0:00 26 App Services, Zero Health Checks 0:22 The Problem with Zombie Instances 0:43 The 5-Round Phased Approach 1:08 Policy Enforcement Implementation 1:34 Results: 26 Services, Zero Downtime 1:51 Health Checks Are Non-Negotiable 26 services fixed without breaking one. Subscribe for the phased rollout playbook. devopsdive.com #DevOps #HealthChecks #Azure #AzurePolicy #DevOpsDive https://www.youtube.com/embed/HHO0ouKPfxE https://www.youtube.com/watch?v=HHO0ouKPfxE 131 2026-06-01T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/f6gvUz7Tlqg/hqdefault.jpg 4 Teams Hated Each Other. I Made Them Ship Together. Alignment Over Code. Four teams. Zero alignment. When you are the DevOps point of contact across multiple enterprise engagements, your job is not just pipelines and infrastructure. It is connecting people, aligning timelines, and making sure those teams row in the same direction. Product wants features shipped yesterday. Security blocks every deployment that has not been reviewed. Cloud engineering has their own migration roadmap. TechOps needs stability above all else. Everyone has valid priorities. Without someone connecting the dots, these teams create bottlenecks for each other. The first thing to build is not infrastructure - it is a coordination framework. Step one: define ownership boundaries. Step two: shared timelines with dependencies explicitly mapped. Step three: clear escalation paths so nobody gets surprised. Step four: weekly cross-team syncs with a decision log. No meeting without outcomes. Every decision documented and shared. The real superpower is unblocking dependencies before they become blockers. When security needs a policy review, pre-schedule it before the migration window. When cloud engineering changes an API, notify the product team the same day. When TechOps raises a stability concern, bring it to architecture review before it becomes a production incident. Without a DevOps point of contact, teams are blocked waiting on each other. With one, workstreams run in parallel and decisions happen fast. These principles work across every domain. In FinTech: coordinate PCI DSS compliance reviews with delivery timelines. In AdTech: align a multi-tenant GCP migration across 8 projects with multiple stakeholder groups. In manufacturing: bridge global commerce teams and cloud infrastructure across different timezones. The technical stack changes. The human challenge stays the same. 0:00 DevOps is not a team, it's a bridge 0:18 The coordination challenge: 4 teams, competing priorities 0:38 Building the coordination framework 1:04 Unblocking dependencies before they become blockers 1:30 FinTech, AdTech, Manufactur… https://www.youtube.com/embed/f6gvUz7Tlqg https://www.youtube.com/watch?v=f6gvUz7Tlqg 129 2026-05-31T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/Hl2AFAw7GCc/hqdefault.jpg Kubernetes Is Not the Answer. It's the Beginning of 1,000 New Questions. Kubernetes is not the answer. It's the beginning of a thousand new questions. Networking, storage, secrets, scaling, service mesh - solve one thing, three more pop up. The starting point was a monolithic application where one bad deploy could take down everything. Manual deployments. Zero auto-scaling, zero self-healing. Downtime was not a bug - it was just accepted as normal. The migration to GKE: containerize the monolith first without rewriting it, build a minimal deployment and iterate, decompose into microservices each independently deployable, add a service mesh for traffic control and mutual TLS between services. No big-bang rewrite. Just steady, validated steps. Here is the part nobody warns you about. Kubernetes networking is its own universe - ingress controllers, DNS resolution, load balancing across services. Config management becomes critical: secrets rotation, ConfigMaps, Helm charts for everything. Resource tuning is an art - set limits too low and pods get killed, too high and you waste money. And without proper logging, metrics, and tracing, debugging in Kubernetes is like finding a needle in a haystack made of other needles. The result: zero-downtime deployments with rolling updates, auto-scaling based on actual traffic via HPA, self-healing where failed pods restart automatically, and a standardized build pipeline from code commit straight to the cluster. What used to be SSH-and-pray became a git push. When the first pod crashed and the cluster just replaced it with no pager and no phone call - that is when it clicked. 0:00 Kubernetes Is Not the Answer. It's the Beginning. 0:15 The Starting Point: Monolith, Manual Deploys, Downtime 0:33 The Architecture: GKE, Microservices, Service Mesh 0:56 The Hard Parts: Networking, Secrets, Debugging 1:26 The Results: Zero-Downtime, Auto-Scaling, Self-Healing 1:46 K8s Is a Journey, Not a Destination Kubernetes honest talk. Subscribe — I run it in production and tell you what actually happens. devopsdive.com #DevOps #Kubernetes #GKE #CloudNative #… https://www.youtube.com/embed/Hl2AFAw7GCc https://www.youtube.com/watch?v=Hl2AFAw7GCc 126 2026-05-30T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/wl3q-cVk0W0/hqdefault.jpg Zombie API Clients. Old Credentials. Still Active. Find and Kill Them. Zombie API clients. Credentials nobody remembers creating. Still active. Still dangerous. Every enterprise has them. Most teams pretend they don't exist. Opened the Commercetools admin panel and found dozens of API clients staring back. Created during sprints two years ago. Nobody knows which are still in use. Some have full admin scopes. Zero rotation, zero audit trail. Just vibes and prayers. The first real audit: 34 clients total. 12 active with legitimate documented usage. 18 zombies with no activity in 90+ days. And 4 with full admin scope that had not been touched in six months. Four open doors to production data that nobody even knew existed. The tool is Python, Dockerized, runs anywhere with no setup. It connects to the Commercetools API, pulls every client, cross-references usage logs, and tells you exactly which ones are alive and which ones are dead weight. Then it goes further: automated weekly scans in the CI/CD pipeline, Slack alerts when any client sits idle for 30 days, scope validation against actual API call patterns, and rotation recommendations when anything is over-permissioned. The deeper problem is not technical. Credentials accumulate because nobody owns the cleanup. Every sprint creates new API clients. Nobody decommissions old ones. The invisible problem stays invisible until someone exploits it. Making it visible - and keeping it visible automatically - is the actual fix. 0:00 Zombie API clients: still active, still dangerous 0:11 Dozens of forgotten clients with full admin scopes 0:28 The tool: Python, Dockerized, automated discovery 0:44 First audit results: 18 zombies and 4 open doors to prod 1:05 Security by design: weekly scans and Slack alerts 1:24 Go audit your API clients Zombie credentials lurking in your production. Subscribe before the next audit. devopsdive.com #DevOps #APISecurity #ZeroTrust #CredentialRotation #DevOpsDive https://www.youtube.com/embed/wl3q-cVk0W0 https://www.youtube.com/watch?v=wl3q-cVk0W0 101 2026-05-28T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/1LGBUAyYLf4/hqdefault.jpg 1,500 Users Migrated. Zero Downtime. One Weekend. Nobody Noticed a Thing. 1,500 users. On-prem to Azure hybrid. One weekend. Zero downtime. Nobody noticed. The starting point was a mess. Active Directory held together with prayers and undocumented group policies. No infrastructure as code. Everything manual. And the one person who knew how it all worked had left two months before I joined. Classic. The plan was Terraform for all new Azure infrastructure, PowerShell scripts to automate the AD sync and user migration, and keep on-prem running in parallel so nothing breaks. Simple on paper. Terrifying in practice. Technically, the migration was solvable. What almost killed us: legacy apps nobody documented, security policies written in 2014 that nobody dared update, and teams who feared change more than they feared outages. I had to earn trust before migrating a single user. Friday night: migration starts, PowerShell running, Terraform applying, AD sync cutting over. Then at 3 AM DNS propagation decided to be creative - some endpoints resolving to old servers, some to new. Fixed it. Verified every endpoint one by one. Watched the logs until sunrise. Sunday morning: done. 1,500 users opened their laptops Monday, everything worked, not a single support ticket. The best infrastructure migrations are the ones nobody notices. Silence is the best possible outcome. 0:00 1,500 users migrated in one weekend with zero downtime 0:09 The starting point: legacy chaos, no docs, one person left 0:25 The plan: Terraform, PowerShell, keep on-prem in parallel 0:43 People problems, not tech problems 1:00 The weekend: Friday night to Sunday morning 1:15 Monday silence - the best possible outcome 1,500 users. Zero tickets. Subscribe — the next migration story is even wilder. devopsdive.com #DevOps #Azure #HybridCloud #ActiveDirectory #DevOpsDive https://www.youtube.com/embed/1LGBUAyYLf4 https://www.youtube.com/watch?v=1LGBUAyYLf4 98 2026-05-26T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/icmXHJE30uc/hqdefault.jpg HTTP to HTTPS Migration. Sounds Simple. It Broke Everything. SSL the Hard Way. HTTP to HTTPS. Should take 2 minutes. Then you meet certificate chains, redirect loops, HSTS headers, and mixed content warnings. Suddenly a 2-minute task is a 2-day rabbit hole. Nginx as a reverse proxy. SSL termination at the edge. Certificate management with Let's Encrypt. Security headers: HSTS, Content Security Policy, X-Frame-Options. Every single one of those has a gotcha hiding behind it. Mixed content warnings appear because one image was still loading over HTTP. Redirect loops that made the browser spin forever. A certificate that expired at 3 AM on a Saturday. And HSTS preload - once you submit your domain, there is no going back. If you mess something up with HTTPS after that, your site is not "shows a warning" unreachable. It's actually unreachable. The result when done right: A+ on SSL Labs, 100% HTTPS coverage, zero mixed content warnings, zero browser security errors. The auto-renewal piece is where most production outages happen - not the initial setup, but the second or third renewal months later when the cron job silently fails and nobody checks. HTTPS is not a feature. It is the absolute bare minimum. And it separates someone who builds websites from someone who builds infrastructure. 0:00 HTTPS Is Not as Simple as You Think 0:11 Nginx, SSL, and Security Headers 0:24 The Gotchas (Mixed Content, Loops, Expired Certs) 0:48 A+ Rating on SSL Labs 1:04 HTTPS Is the Bare Minimum HTTP to HTTPS and everything that breaks along the way. Subscribe. devopsdive.com #DevOps #Nginx #SSL #LetsEncrypt #DevOpsDive https://www.youtube.com/embed/icmXHJE30uc https://www.youtube.com/watch?v=icmXHJE30uc 85 2026-05-24T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/_3RT4Oyr-b4/hqdefault.jpg $30/Day Wasted on Logs Nobody Read. 200 Servers. One Rule. Zero Filtering. $30 a day in wasted log ingestion. Information-level logs from 200+ servers pouring into Log Analytics. All billed. None actionable. Pure waste that went unquestioned for months. The root cause was one monolithic Data Collection Rule collecting everything from every Windows server in the fleet. Active Directory logs, DNS logs, DFS replication - all of it from over 200 machines. But only 6 of those machines were actual Domain Controllers. The rest were generating noise. Information-level event logs are the noisiest, most expensive, and least useful data in your entire stack. That means roughly 97% of that collection was paying for events that would never trigger an alert or answer a question anyone was asking. The fix was splitting the monolithic DCR into two specialized rules: Domain Controller logs collected from the 6 actual DCs only, and information-level logs eliminated entirely. Same monitoring coverage. A fraction of the cost. $30 a day is over $900 a month. And this is just one project at one company. Every organization running Azure Monitor with default Data Collection Rules is probably doing the same thing. Check your log ingestion costs right now. Filter by table. Look at the volume. You will find waste. 0:00 $30/Day Wasted on Logs Nobody Read 0:14 The Problem: One Monolithic Data Collection Rule 0:41 The Fix: Split DCR, Kill the Noise 0:58 Check Your Log Costs Today Azure cost wins you can copy today. Subscribe — more FinOps content dropping. devopsdive.com #DevOps #Azure #CostOptimization #LogAnalytics #DevOpsDive https://www.youtube.com/embed/_3RT4Oyr-b4 https://www.youtube.com/watch?v=_3RT4Oyr-b4 82 2026-05-22T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/NGh6zwR8uqI/hqdefault.jpg Azure From Scratch. Empty Subscription. Tight Deadline. A Real War Story. Empty subscription. Tight deadline. A team that had never touched Azure before. That was day zero. The requirements were non-negotiable: multi-region HA across availability zones, zero trust as an actual network design (not a buzzword), 100% Terraform with no portal clicking, and a hub-spoke topology because flat networks in enterprise are a security incident waiting to happen. The foundation was Terraform modules for every resource type - reusable, versioned, tested. Landing zones with subscription vending so new teams get a secure environment in hours, not weeks. Azure Policy as guardrails. And a CI/CD pipeline for infrastructure itself: plan, review, apply. Nobody runs Terraform from a laptop. Security was not an afterthought. Private endpoints on everything - no public-facing resources in the backend. NSG rules version-controlled and audited. Key Vault for every secret, no exceptions. RBAC with least privilege, reviewed monthly. We spent 3 days on network design before writing a single line of Terraform. That decision saved 3 weeks of rework. The mistakes that bit hardest: underestimating DNS complexity in hub-spoke (it's always DNS), assuming Azure defaults are secure (they absolutely are not), and not planning governance from day one. If your Azure infrastructure cannot be rebuilt from code in under an hour, you don't have infrastructure as code. You have infrastructure as hope. 0:00 Azure From Scratch: Day Zero 0:19 The Requirements 0:33 The Foundation: Terraform Modules and Landing Zones 1:17 Security Architecture 1:36 The Outcome 2:03 Cloud Is Engineering Azure from scratch. Real stakes. Subscribe — the architecture decisions are just starting. devopsdive.com #DevOps #Azure #Terraform #HubSpoke #DevOpsDive https://www.youtube.com/embed/NGh6zwR8uqI https://www.youtube.com/watch?v=NGh6zwR8uqI 141 2026-05-20T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/vI5_IR5IdM8/hqdefault.jpg VMs to Kubernetes. The Team Said No. I Did It Anyway. They Run It Now. Multiple services running on virtual machines. Each one a snowflake, manually configured, impossible to reproduce. The team said "it works." I said "it works until it doesn't. And then what?" The deployment process was SSH in, pull the latest code, restart the process, cross your fingers. Hours per full deployment cycle. No horizontal scaling - just over-provisioned VMs burning money around the clock. And when a VM died? Rebuild from scratch, from someone's memory of how it was set up months ago. Step one was not Kubernetes. Step one was containerization. Multi-stage Dockerfiles, minimal base images, images versioned and stored in Google Artifact Registry. Environment parity between dev, staging, and prod was the whole point. The GKE setup had node pools segmented by workload type - compute-heavy services separated from I/O-bound ones. Horizontal pod autoscaling based on actual application metrics, not just CPU. Network policies for service-to-service isolation. The result: deployment time from hours to minutes, infrastructure costs right-sized through autoscaling, and zero snowflake servers. Every service reproducible from a Dockerfile and a Helm chart. When a node dies, Kubernetes reschedules the pods. The 3 AM panic calls and rebuilding from memory? Gone. Containers are not cool technology. They are a contract that says this application will run the same everywhere. 0:00 VMs to Kubernetes: The Migration Nobody Wanted 0:17 The State of Things: Snowflake VMs, Manual Everything 0:44 Containerization First: Dockerfiles Before Kubernetes 1:10 GKE Architecture: Not Just Deploy and Hope 1:38 The Transformation: Hours to Minutes, Zero Snowflakes 2:03 Kubernetes Is Not the Goal. Reliability Is. VMs to Kubernetes. Subscribe — the container journey has more surprises than you think. devopsdive.com #DevOps #Kubernetes #GKE #ContainerMigration #DevOpsDive https://www.youtube.com/embed/vI5_IR5IdM8 https://www.youtube.com/watch?v=vI5_IR5IdM8 151 2026-05-18T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/fmrAXXJB0Ss/hqdefault.jpg 12 Passwords in Plaintext. In Production. For 14 Months. Nobody Checked. 55 CI/CD pipeline variables. 30 unused. 12 stored in plaintext. Zero rotation policies. That's what I found when I actually looked. I migrated everything to Key Vault, automated the rotation, and built security gates into every pipeline. Every commit scanned. Every deployment validated. No more quarterly spreadsheets that are outdated before they're done. These were live pipelines running for months with credentials nobody was managing. The kind of thing that stays invisible until someone exploits it and you're in a meeting explaining how a database password with zero rotations in 14 months ended up in a build log. Manual security audits - someone logging into the console, checking IAM policies by hand, reviewing security groups one by one - produce a spreadsheet that's already outdated by the time it's finished. New resources spun up, old ones modified, the audit is a snapshot of the past. The replacement: Terraform compliance checks that run before anything deploys, catching misconfigurations at the source. AWS Security Hub centralizing findings across accounts. Custom Python-based scanners for specific compliance requirements. Everything wired into the CI/CD pipeline as hard gates - not warnings, actual blockers that stop the build. The 30 unused variables removed entirely, the 12 plaintext secrets encrypted and moved behind RBAC with managed identity auth, automatic rotation configured. Open security groups, overly permissive IAM, unencrypted storage, public S3 buckets, missing logging - all caught automatically, in minutes, not days. If your security audit lives in a spreadsheet, you're already behind. Attackers don't wait for your quarterly review. 0:00 Manual vs Automated Audit 0:19 The Problem with Manual Audits 0:46 The Automated Pipeline 1:08 What It Catches 1:30 DevSecOps Culture 1:53 Automate Security 12 plaintext passwords. 14 months. Subscribe before your next security audit. devopsdive.com #DevOps #DevSecOps #Security #KeyVault #DevOpsDive https://www.youtube.com/embed/fmrAXXJB0Ss https://www.youtube.com/watch?v=fmrAXXJB0Ss 131 2026-05-16T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/qRYIJ_hLqgE/hqdefault.jpg 50 Lambda Functions. Python 3.8. End of Life. Nobody Cared Until I Looked. 50+ Lambda functions running Python 3.8. AWS about to stop patching security vulnerabilities. Nobody had touched these functions in over a year because "they work, don't touch them." Famous last words. The audit uncovered hardcoded credentials, deprecated libraries, zero tests. Here's the systematic approach to upgrading everything without breaking a single production workflow. Inside those functions: hardcoded credentials - not even environment variables, raw strings. Deprecated libraries with known CVEs. Not a single test across 50+ functions. IAM roles with wildcard permissions, Action star, Resource star. Functions talking to RDS over the open internet with no VPC isolation. The documentation was the function name. That was it. The migration strategy was one function at a time, not a big bang. Runtime updated 3.8 to 3.11, every dependency pinned and audited, shared libraries moved into Lambda layers so updates happen in one place. Canary deployments with traffic shifting - 5%, then 25%, then full rollover - automatic rollback if anything broke. Security hardening ran in parallel: IAM roles rewritten from scratch to least privilege, hardcoded credentials replaced with Secrets Manager, database-connected functions moved into VPC with private subnets. Results: all functions migrated, zero downtime, zero wildcard IAM policies remaining, zero hardcoded secrets. Cold starts actually improved because Python 3.11 is faster. "Don't touch it" is technical debt spoken in the language of fear. Every day you ignore a runtime at end of life, the interest compounds. 0:00 50+ Lambda Functions, End of Life 0:18 The Audit 0:38 The Migration Strategy 1:06 Security Hardening 1:30 The Results 1:51 "Don't Touch It" Is Not a Strategy Legacy Lambda cleanups. Subscribe if you've inherited someone else's serverless mess. devopsdive.com #DevOps #AWS #Lambda #Serverless #DevOpsDive https://www.youtube.com/embed/qRYIJ_hLqgE https://www.youtube.com/watch?v=qRYIJ_hLqgE 135 2026-05-14T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/eC2FLWdlbK4/hqdefault.jpg 8 Services. 2 Tenants. Zero Downtime Migration. Q4 Peak. No Room for Error. Eight services. Two Azure tenants. 500+ users. Q4 peak traffic. Revenue on the line. Zero tolerance for downtime. 241 Terraform modules managed through Terragrunt. OIDC authentication. Workload Identity Federation. Phased traffic shifting with automated validation gates. Migrating a revenue-critical enterprise application between Azure tenants without anyone noticing - during the busiest quarter of the year. The core application is a revenue-critical enterprise platform - budgets, client data, operational workflows - with 500+ active users and Q4 as peak traffic. Every minute of downtime is real money lost. The migration order mattered: data layer first, identity services second, business logic third, core application last. You cannot lift and shift when dependencies run eight layers deep. The IaC backbone: 241 Terraform modules through Terragrunt, OIDC and Workload Identity Federation replacing every service principal secret, zero credentials stored anywhere. Execution ran in parallel environments with continuous data sync, then traffic shifted in controlled increments - 10%, 25%, 50%, 100% - with automated validation gates at every stage. Any check failed? Traffic rolled back automatically. Automatically -- no human panicking at 2 AM required. Four months. Eight services. 241 modules. Zero incidents. If your migration plan is "do it over the weekend and hope for the best" - that's not a plan. That's a wish. And wishes don't have rollback strategies. 0:00 8 Services, 2 Tenants, Zero Downtime 0:16 The Stakes 0:32 The Service Map 0:55 241 Terraform Modules 1:18 The Execution Plan 1:39 Results Zero downtime, maximum pressure. Subscribe before your next migration window. devopsdive.com #DevOps #Azure #Terraform #AzureMigration #DevOpsDive https://www.youtube.com/embed/eC2FLWdlbK4 https://www.youtube.com/watch?v=eC2FLWdlbK4 123 2026-05-12T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/8b_4XTI1z9M/hqdefault.jpg I Built My First Landing Page. Ugly CSS. Broken JavaScript. And I Loved It. Every developer remembers their first landing page. Mine was ugly. Colors clashed. Spacing was wrong. The JavaScript did things no JavaScript should do. And I loved every pixel. Zero frameworks, zero libraries. Just raw HTML, CSS, and JavaScript. The moment the browser rendered something I built from nothing - that feeling never goes away. This is where it all started. A hero section with a background image that was way too large. A nav bar that broke on mobile. A first-ever media query that worked on exactly one screen size - mine. CSS specificity wars I didn't understand, inline styles everywhere, and JavaScript behavior I couldn't fully explain but wasn't about to delete. No React, no Tailwind, no component libraries. Just raw HTML in a text editor and the stubbornness to make it render. That landing page taught me three things that no framework tutorial could: the DOM is real, learn it before you abstract it away; CSS is powerful when you stop fighting it and start understanding it; and shipping something ugly beats shipping nothing at all. The foundation you build here matters later - not just for web dev, but for understanding how tools like Terraform and Kubernetes manage state and structure in their own ways. If you're waiting until your first project is good enough to show - stop. Ship it ugly. That's how careers start. 0:00 My First Landing Page 0:12 HTML, CSS & JavaScript 0:34 What It Taught Me 0:51 Start Ugly. Ship Anyway. Everyone's first project was ugly. Subscribe — the growth is the interesting part. devopsdive.com #DevOps #HTML #CSS #JavaScript #DevOpsDive https://www.youtube.com/embed/8b_4XTI1z9M https://www.youtube.com/watch?v=8b_4XTI1z9M 76 2026-05-11T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/-8w57whHLXo/hqdefault.jpg My First Jenkins Pipeline Failed 17 Times. Red Circles on Repeat. Best Lesson. Seventeen failed builds. One pipeline. Red circles spinning over and over again. That was my introduction to CI/CD - and the most important lesson of my engineering career. Jenkins installed in Docker, a Jenkinsfile, and absolutely no idea what I was doing. The failures came in every flavor: wrong Docker image with missing build tools, environment variables not passed to the container, permission errors on the build agent, Jenkinsfile syntax that looked right until Jenkins told me it wasn't. Every mistake a beginner can make, I made all of them in one afternoon. In one session. Back to back. By failure 12, I stopped just googling and started documenting every error. By 15, I was fixing issues before the build even ran. Build 18 was green. That moment - push code, pipeline runs, artifacts built automatically, no more "it works on my machine" - changed how I thought about software delivery permanently. Seventeen failures taught me more than any certification or course, because they taught me to think rather than follow steps. The tool doesn't matter - Jenkins, GitLab, GitHub Actions, whatever. The mindset matters: automate everything, trust the pipeline, let the machine do the boring work. Every senior engineer you look up to has a graveyard of failed builds behind them. They just don't talk about it. 0:00 17 Failed Builds 0:11 The Setup: Jenkins + Docker 0:30 The Failures 0:51 Build #18: Finally Green 1:09 The Mindset That Changed Everything First Jenkins pipeline to enterprise-grade. Subscribe — the full journey is just starting. devopsdive.com #DevOps #Jenkins #CICD #JenkinsPipeline #DevOpsDive https://www.youtube.com/embed/-8w57whHLXo https://www.youtube.com/watch?v=-8w57whHLXo 93 2026-05-09T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/um61VJgOKWI/hqdefault.jpg We Migrated 200 CI/CD Pipelines. Zero Developers Complained. Zero Downtime. 200 CI/CD pipelines. Legacy platform to modern stack. Zero downtime. Zero developer disruption. Nobody even noticed the migration happened. That's not a failure of communication. That's the definition of success. The starting point: 22+ repositories, each with its own Jenkinsfile, its own quirks, its own tribal knowledge. Bitbucket pipelines that only the person who wrote them could debug - and that person had left six months ago. Every service a special snowflake. Every deployment a prayer. The goal was to replace all of that with a single 634-line universal pipeline template on GitLab CI. One file every service references. Change the template - every service gets the update. And a hard gate: 75% test coverage. Not optional, not negotiable. The migration strategy is what made it work. Eight services migrated in a specific sequence - dependencies first, consumers last. New pipelines ran alongside old ones for weeks before anyone was asked to switch. Automated parity checks compared outputs from old and new. If anything differed even slightly, investigation happened before migrating more. Any team could roll back with a single flag change. The timeline was "migrate when ready," not "migrate by Thursday or else." 350+ commits to get the template right. Every edge case, every environment variable, every secret rotation - handled. Zero downtime across the entire migration, not one service dropped a request. The psychological key: never asked teams to "trust the new system." Showed them the new system running their actual builds correctly for two weeks before asking them to switch. By the time the last pipeline flipped, nobody noticed. Because it had already been running their code for weeks. 0:00 634 Lines. One Template. Every Service. 0:16 The Jenkins Problem 0:32 The Universal Template 0:54 8 Services Migrated in Sequence 1:24 Why It Works 1:37 634 Lines. 8 Services. 0 Downtime. 200 pipelines migrated. Zero complaints. Subscribe before your next platform switch. devopsdive.c… https://www.youtube.com/embed/um61VJgOKWI https://www.youtube.com/watch?v=um61VJgOKWI 118 2026-05-06T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/2s5GMjFcE8c/hqdefault.jpg Our Monitoring Was a Lie. Green Dashboards, Real Failures. I Rebuilt It All. Green dashboards everywhere. "All systems operational." Meanwhile, users were reporting errors that never showed up in our metrics. Our monitoring wasn't monitoring. It was a decoration. A green badge that made everyone feel good while the application quietly fell apart. Prometheus and Grafana - everyone installs them, almost nobody sets them up right. The typical mess: Prometheus scraping everything but alerting on nothing useful. Grafana dashboards built during setup week and never opened again. No retention policy, so disk fills up and monitoring dies silently. And the classic single Prometheus instance that goes down with the very application it's supposed to monitor. We had 47 dashboards and 200+ alerts. Nobody looked at the dashboards. Nobody responded to the alerts - there were too many and too little context. The rebuild changed the philosophy. High-availability Prometheus with federation - not one instance hoping for the best, replicated with clear ownership per service team. Grafana with provisioned dashboards defined in code, not hand-crafted masterpieces that vanish when someone accidentally deletes them. Alerting tiers: critical means someone is losing money right now, warning means something will break by morning, info goes to a dashboard and never pages anyone. Every single alert has a linked runbook - waking someone at 3am without telling them what to do is just cruelty. The hardest conversation was telling leadership: "Our 99.9% uptime metric is technically accurate and completely misleading." The server was up. The application was broken. Two very different things. If you measure everything, you measure nothing. Measure what matters. 0:00 Prometheus & Grafana Done Right 0:13 The Typical Monitoring Mess 0:45 The New Architecture 1:11 Alerting That Actually Works 1:33 Performance at Scale 1:49 Monitoring Is a Product Your dashboards might be lying. Subscribe to learn what real monitoring looks like. devopsdive.com #DevOps #Monitoring #Observability #Grafana #DevO… https://www.youtube.com/embed/2s5GMjFcE8c https://www.youtube.com/watch?v=2s5GMjFcE8c 136 2026-05-02T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/S_2Bxs6vmuc/hqdefault.jpg Terraform Apply. 500 Students Watching Live. No Safety Net. One Typo Away. 500 students. Live conference demo. Terraform apply with no safety net. One typo and the entire infrastructure crumbles in front of an audience. This is the story of the live infrastructure demo that went sideways - and the lessons I learned about teaching, preparation, and why "Terraform apply" should never be your scariest command. The architecture being deployed live: virtual networks with proper subnet isolation, network security groups enforcing zero-trust rules, private DNS zones so nothing is exposed to the public internet, automated VM provisioning, MySQL behind private endpoints with encryption at rest. Twenty-three resources. All codified. All reproducible. The whole point was to show 500 students that real infrastructure isn't slides with diagrams - it's Terraform, Azure, and deployments you can actually replicate. Then the first apply failed. Network policy conflict. 500 pairs of eyes watching. Two options: pivot to slides and pretend the demo was "supplementary," or debug live with zero guarantee of fixing it. Chose option two. Found the CIDR conflict in 90 seconds. Fixed it. Re-applied. All 23 resources came up green. The applause was louder than it would have been if nothing had gone wrong. The security-first mindset I taught alongside the syntax matters as much as the demo: no public IPs unless absolutely necessary, NSG rules that deny by default, state files stored remotely with locking. If you teach bad habits, you create bad engineers. And if "Terraform apply" is your scariest command - that's a pipeline problem, not a Terraform problem. 0:00 500 Students. Live Demo. No Safety Net. 0:15 The IT Marathon Context 0:30 The Architecture 0:51 Security-First Thinking 1:13 The Live Demo (Terraform apply) 1:33 Teach by Doing Terraform live, real stakes, real mistakes. Subscribe to learn from mine. devopsdive.com #DevOps #Terraform #InfrastructureAsCode #LiveCoding #DevOpsDive https://www.youtube.com/embed/S_2Bxs6vmuc https://www.youtube.com/watch?v=S_2Bxs6vmuc 112 2026-04-30T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/GxdMQQIYncg/hqdefault.jpg I Tried to Do Everything Myself. Then I Burned Out. Leadership Fixed It. Leading a team means your job stops being "know everything" and starts being "make everyone around you better." I learned this the hard way - by trying to do everything myself first. Reviewing every PR. Jumping on every incident. Being the single point of failure for an entire platform. The trap looked like value: I was the only one who understood the CI/CD pipelines. Every incident escalated to me. Documentation lived entirely in my head. Vacation was a concept, not a reality. I thought being indispensable made me valuable. It didn't. It made me the worst thing you can be in DevOps: a single point of failure. And then the burnout hit - not the "I'm so passionate" kind, but the kind where you stare at a screen and nothing is happening behind your eyes. The shift that changed everything: from fixing everything myself to teaching others how to fix. Knowledge moved from my head into runbooks. PR reviews became review guidelines. Incident heroics became documented response procedures anyone could follow. The team went from waiting for my approval to proposing solutions before I even knew there was a problem. Pair debugging sessions replaced lectures. Code reviews became teaching moments, not criticism. The result was the opposite of what I feared: the engineers I thought I was protecting by doing everything - I was holding them back. The best thing I did for the team was make myself less necessary to daily operations. The best leaders don't make themselves indispensable. They make themselves replaceable. 0:00 Leadership Is Not Knowing Everything 0:17 The Solo Trap 0:35 The Shift: From Doing to Enabling 1:01 Mentoring in Practice 1:33 Building DevOps Culture 1:49 Multiply Yourself Burned out trying to do everything myself. Subscribe — the leadership path is different. devopsdive.com #DevOps #Leadership #TechLeadership #BurnoutRecovery #DevOpsDive https://www.youtube.com/embed/GxdMQQIYncg https://www.youtube.com/watch?v=GxdMQQIYncg 134 2026-04-29T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/k65uicHzjoU/hqdefault.jpg Docker Compose in Production. Everyone Said No. It Works. Real Users. Real Load. Everyone told me Docker Compose isn't "production-ready." That I needed Kubernetes. That Compose is for local development only. So I put Docker Compose in production. For a real application. With real users. And it just... Worked. My first docker-compose.yml was WordPress and MySQL. It took me three days - three days of debugging port conflicts, wondering why the database refused to connect, not understanding the difference between a container and an image. Port 3306 already in use because MySQL was running locally and I didn't even know it. Today, the same setup takes three minutes. But those three days changed how I think about infrastructure forever. The full setup for production: a web service with database, cache, and background workers running on a single VM behind Nginx. Blue-green deployments handled by a simple bash script. Prometheus + Grafana for monitoring. Automated backups. Total cost: $40/month. The Kubernetes equivalent would have run $200-400/month for managed K8s plus nodes. Uptime over 6 months: 99.9%. The lesson from that first compose file still applies today: infrastructure can be defined as code, environments should be reproducible, and services should be isolated and composable. A 500-user application doesn't need container orchestration - it needs the right tool for its actual problem size. Over-engineering is still engineering failure. 0:00 My First docker-compose.yml 0:19 The Struggle (ports, images, networking) 0:45 The Breakthrough 1:11 What I Learned 1:38 The Evolution 2:00 Start Small Boring tech in production. Subscribe if simplicity wins in your stack too. devopsdive.com #DevOps #Docker #DockerCompose #SelfHosted #DevOpsDive https://www.youtube.com/embed/k65uicHzjoU https://www.youtube.com/watch?v=k65uicHzjoU 143 2026-04-27T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/WmUtg1EdPt0/hqdefault.jpg GPT-4 in a Production Pipeline. Real Customers. Real Money. Not a Weekend Demo. I put GPT-4 inside a DevOps pipeline. Full production -- beyond proof of concept, beyond weekend hackathon. Enterprise e-commerce. Real customers. Real money. How we integrated Azure OpenAI into the deployment pipeline - from intelligent code review to automated incident classification to natural language infrastructure queries. The technical details: how we handled rate limits, cost control, hallucination risks, and the one time the AI confidently suggested deleting a production database (we didn't). The pipeline handled four things: versioned prompt templates (you don't just push a prompt change to production), API gateway deployment with rate limiting and authentication, integration tests that validated response quality not just HTTP status codes, and canary releases with automatic rollback if the AI started giving wrong answers. KQL dashboards tracked token usage, response latency, error rates, and cost per request in real time. The result was a 60% reduction in AI deployment time - from manual, nerve-wracking releases to automated, observable, repeatable pipelines. Hard lessons from production: prompt changes are deployment changes - version them, test them, review them like code. AI costs can explode overnight without hard token limits set on day one. Latency budgets matter more than with regular APIs because GPT-4 is not fast. And rollback strategy is not optional - when the AI starts giving wrong answers to customers spending real money, you need to revert in seconds, not hours. Human-in-the-loop isn't a nice-to-have. It's the whole architecture. Everyone is rushing to add AI. Very few are thinking about how to deploy it safely. AI without DevOps is a science experiment. AI with DevOps is a product. Build the pipeline first - the model is the easy part. 0:00 GPT-4 in Production. Not a Demo. 0:13 The Project: Enterprise E-Commerce Meets AI 0:30 The Pipeline: AI Deployment End to End 0:54 KQL Monitoring: 60% Faster AI Deploys 1:19 Hard Lessons: What Nobody Tells You About AI in Prod 1:4… https://www.youtube.com/embed/WmUtg1EdPt0 https://www.youtube.com/watch?v=WmUtg1EdPt0 124 2026-04-26T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/uQietBqxeXQ/hqdefault.jpg Burning 25% of Our Cloud Budget. Three Clouds. Zero Visibility. I Built the Fix. Three clouds. AWS, Azure, GCP. Each team managing their own billing. Nobody had a unified view. Money bleeding out quietly - 25% overspend that nobody noticed until I built a dashboard that made everyone uncomfortable. Building a FinOps platform from scratch - unified cost visibility, anomaly detection, automated rightsizing recommendations, and the conversation with leadership that started with "we need to talk about your cloud bill." What I found first: zombie resources running for months - instances nobody used but nobody dared turn off. Over-provisioned VMs burning money around the clock. Dev environments running on the same tier as production. And the worst part: no one was accountable. Cloud spend was everyone's problem and nobody's responsibility. When a team can see their own spend in isolation, "reasonable" is whatever they've normalized to. The platform: a multi-cloud cost aggregator pulling billing data from AWS, Azure, and GCP into a single dashboard. Machine learning anomaly detection catching unexpected spend spikes before they become budget disasters. Automated right-sizing based on actual utilization data, not what someone guessed six months ago. Team-level dashboards so every team sees what they actually spend. The quick wins were per-cloud: AWS reserved instances and spot for non-critical workloads, Azure VM right-sizing on instances running at 10% utilization, GCP committed use discounts that were never claimed, and automated shutdown of dev environments outside business hours. The ML anomaly detection caught three unexpected cost spikes in the first month alone, before they snowballed. The 25% reduction didn't come from cutting services - it came from visibility. When teams can see their own numbers, behavior changes overnight. 0:00 25% Overspending. Three Clouds. Nobody Noticed. 0:18 The Mess: Zombies, Oversized VMs, No Accountability 0:42 The Platform: Unified Cost Tracking + ML Anomaly Detection 1:14 Quick Wins: AWS, Azure, GCP Savings 1:35 The Resul… https://www.youtube.com/embed/uQietBqxeXQ https://www.youtube.com/watch?v=uQietBqxeXQ 133 2026-04-25T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/d0lz7MXUg9Q/hqdefault.jpg Security Gate That Doesn't Slow You Down. Scans in Parallel. I Built One. Every team I've worked with says the same thing: security OR speed, pick one. I picked both. SonarQube, dependency checks, IaC scanning - running in parallel with builds instead of blocking them. Security as code, not security as bureaucracy. The typical setup is broken from day one: security review happens maybe right before release. Container images nobody has scanned - ever. RBAC policies copy-pasted from Stack Overflow three years ago. And everyone just hopes nothing bad happens. When a scan finally does run after the build, developers wait 45 minutes, one finding blocks the entire pipeline, and the team starts working around the process. The "fix" is almost always to just disable the gate. The secret is parallel execution. SonarQube runs on every pull request - code quality and vulnerability detection before a human reviewer even opens the PR. Trivy scans every container image at build time, not after deployment. Terraform plans get validated against security policies before they touch infrastructure. Jenkins orchestrates the whole flow. If all gates pass - auto-approve and deploy. If something fails - the developer gets feedback in their pull request, not in an email three weeks later. Zero critical vulnerabilities reaching production, caught at the PR stage instead of in a post-mortem. Deploy speed unchanged because scans run alongside the build, not after it. Security became invisible - and that's exactly the point. Security is not a blocker. It's a feature of your pipeline. 0:00 Secure AND Fast: Sounds Impossible 0:12 The Usual Mess: Security as an Afterthought 0:26 Shift Left, Stay Fast: SonarQube, Trivy, Terraform 0:47 The Pipeline: Jenkins + Parallel Execution 1:05 The Results: Zero Critical Vulns in Production 1:23 Security Is Not a Blocker Security gate, zero slowdown. Subscribe — I'll show you how it's built. devopsdive.com #DevOps #DevSecOps #CICD #SecurityGate #DevOpsDive https://www.youtube.com/embed/d0lz7MXUg9Q https://www.youtube.com/watch?v=d0lz7MXUg9Q 101 2026-04-23T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/4h9N6fmxvvY/hqdefault.jpg I Built Infrastructure That Thinks. AI-Powered DevOps Platform. Not Clickbait. What if your infrastructure could make its own decisions? Beyond conference demos and robots on slides -- a real AI-powered DevOps platform that detects anomalies, predicts failures, and acts on them - in production. The architecture of an AI DevOps platform built with Python, Terraform, and Azure OpenAI. From reactive firefighting to predictive self-healing infrastructure. DevOps in 2026 stopped being about writing YAML. It became about teaching systems to think. Traditional infrastructure management: Terraform plans reviewed by tired eyes at 5pm on Friday, cost bills checked at end of month and everyone panics, alerts fire and humans react. The new model: AI handles pattern recognition, cost analysis, and scaling decisions - humans approve or override. The key design principle is trust but verify. Low-risk actions like tagging or auto-scheduling execute automatically. Critical changes to production networking or scaling go through a human approval gate. Every decision is logged and auditable. The cost optimization layer was the first killer feature. The AI found idle VMs running 24/7 for no reason. Oversized instances that could be downgraded without anyone noticing. Workloads that only needed to run during business hours. Humans miss this because we get used to the status quo. AI doesn't have that bias. ML models train on your specific infrastructure patterns - not generic benchmarks from a whitepaper. The demo that convinced stakeholders: I showed it detecting a memory leak pattern that took the team 4 hours to diagnose the previous quarter. The AI found it in 11 seconds and proposed the exact fix we'd eventually applied. The best infrastructure isn't the one with the most tools. It's the one that improves itself. 0:00 Infrastructure That Makes Decisions 0:13 The Vision: From Reactive to Predictive 0:33 The Stack: Azure OpenAI + Terraform + Python 1:01 Cost Optimization: AI Finds What Humans Miss 1:25 Automated Decisions: Trust but Verify 1:51 Infrastructure That Learns AI-powered infra f… https://www.youtube.com/embed/4h9N6fmxvvY https://www.youtube.com/watch?v=4h9N6fmxvvY 132 2026-04-19T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/project https://img.youtube.com/vi/NFAOFKUTyBI/hqdefault.jpg Enterprise CI/CD Was So Slow Devs Made Coffee. Jenkins to GitHub Actions Fix. Enterprise e-commerce platform. Jenkins pipelines so slow that developers would start a build and go make coffee. Multiply that by every pull request, every feature branch, every hotfix. The migration from legacy Jenkins monolith pipelines to parallelized GitHub Actions - with caching, matrix builds, and actual feedback loops. Builds that used to take an hour now run in minutes. Enterprise environment, enterprise constraints — and fixes that actually shipped. The Jenkins setup was textbook legacy pain: everything sequential, no build caching so every run was a full rebuild, shared runners that queued 20 minutes before a build even started, and flaky tests nobody dared touch. The only fix was to re-run and hope for green. Before writing a line of new config, I mapped all 47 active pipelines. No documentation existed - I mapped the ones actually running. Some hadn't been touched in three years but were still running daily. The new architecture was modular. Shared workflows reusable across every repo in the organization. Matrix builds running tests in parallel across multiple Node versions. Build analytics tracking pipeline performance per pull request so you could see if your change made the build slower. Health-check gated deployments with automatic rollback. No more crossing fingers on deploys. A slow pipeline is not a minor inconvenience. It's a tax on every developer, every single day. It kills momentum, kills morale. Your CI/CD pipeline is a product - measure it, optimize it, make your developers love shipping code again. 0:00 Enterprise CI/CD: Painfully Slow Builds 0:16 The Legacy Pain: Monolith Pipelines, No Caching 0:36 The Transformation: Jenkins to GitHub Actions 1:00 Pipeline Architecture: Modular and Reusable 1:24 The Results: From Chaos to Confidence 1:51 Your Pipeline Is Your Product Enterprise CI/CD transformed. Subscribe before your next pipeline migration. devopsdive.com #DevOps #CICD #Jenkins #GitHubActions #DevOpsDive https://www.youtube.com/embed/NFAOFKUTyBI https://www.youtube.com/watch?v=NFAOFKUTyBI 130 2026-04-18T00:00:00+00:00 yes no Oleksii Koshelenko