https://devopsdive.com/videos/PV7em_7fTnw https://img.youtube.com/vi/PV7em_7fTnw/maxresdefault.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 affor 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/videos/Q6lyrn0E3GY https://img.youtube.com/vi/Q6lyrn0E3GY/maxresdefault.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 distribu 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/videos/bIzMrjbBoZk https://img.youtube.com/vi/bIzMrjbBoZk/maxresdefault.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. 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/videos/ALgOJndKKH0 https://img.youtube.com/vi/ALgOJndKKH0/maxresdefault.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, someon 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/videos/xHV4ga2dwyo https://img.youtube.com/vi/xHV4ga2dwyo/maxresdefault.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 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/videos/tqzDokTfUiU https://img.youtube.com/vi/tqzDokTfUiU/maxresdefault.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-spr 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/videos/xbZnwoJaVNo https://img.youtube.com/vi/xbZnwoJaVNo/maxresdefault.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 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/videos/XQJJmsaXLY0 https://img.youtube.com/vi/XQJJmsaXLY0/maxresdefault.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 st 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/videos/l9BO3ULJNzk https://img.youtube.com/vi/l9BO3ULJNzk/maxresdefault.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, re 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/videos/nOMt_R1AUBw https://img.youtube.com/vi/nOMt_R1AUBw/maxresdefault.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 th 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/videos/-8j_UgSuJRA https://img.youtube.com/vi/-8j_UgSuJRA/maxresdefault.jpg One Task. I Solved It for 62 Azure Subscriptions. That Is My Video CV. This is my video CV. Someone asked me to set up cost alerts for one Azure subscription. I looked around and saw sixty-two more with the same problem. So I solved all of them at once — built a system that picks up new subscriptions automatically, self-maintains, self-expires. Set it up once. Never touched it again. That is how I think about every task. Not "finish it" - but "how can this help ten more people, save the company money, prevent the next problem." Three real stories from my actual work. A monitoring migration where the brief was simple one-to-one alert mapping - but I opened the old alert list and it was a mess: hundreds of rules, half duplicates, some monitoring services that no longer existed. I read every single one. Took weeks. Ended up with 31 focused rules instead of hundreds. The team started catching problems before users reported them. Then a Monday morning import job that one person ran manually, credentials in their head, nobody knew when they got sick until Wednesday. Automated it: scheduled triggers, secrets in Key Vault, Slack on failure, audit trail. That person finally took a real vacation. None of this was in my job description. It was just the obvious https://www.youtube.com/embed/-8j_UgSuJRA https://www.youtube.com/watch?v=-8j_UgSuJRA 197 2026-06-29T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/K6NSI4MzLcs https://img.youtube.com/vi/K6NSI4MzLcs/maxresdefault.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 unifi 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/videos/aAOsD2YlFdI https://img.youtube.com/vi/aAOsD2YlFdI/maxresdefault.jpg Oil Refinery to Enterprise Cloud. Ethernet to Terraform. My Path to DevOps. I started plugging ethernet cables in an oil refinery. Ended up running enterprise cloud infrastructure for financial institutions and global marketing platforms. Not the plan. Just what happened when I kept saying yes to problems nobody else wanted to touch. The actual path: 2016 as a sysadmin doing everything alone - setup, monitoring, infrastructure, printers, "the internet is slow", all of it, no ticket queue, no senior to ask. Then self-taught web development, CRM systems from scratch, my first app with inline styles and no version control but real pharmacists using it to track real patients. Somewhere in that mess I realized I cared more about the infrastructure than the code - the part nobody sees, the pipelines, the deploys, how something gets from my laptop to the thing the customer actually touches. That realization led to DevOps, Azure, Terraform, KQL, Helm - and to being honest about what I have and what I am still building. What the market sometimes says: weak AWS, Kubernetes not architect level, Python not backend-grade. What I actually deliver: full monitoring systems in KQL for live products, CI/CD pipelines that cut team time by 70%, a pharma CRM solo with no arc https://www.youtube.com/embed/aAOsD2YlFdI https://www.youtube.com/watch?v=aAOsD2YlFdI 124 2026-06-28T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/EdWIuXwV2iw https://img.youtube.com/vi/EdWIuXwV2iw/maxresdefault.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 g 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/videos/PuKJlgTGOwI https://img.youtube.com/vi/PuKJlgTGOwI/maxresdefault.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 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/videos/F6gwStfzzGU https://img.youtube.com/vi/F6gwStfzzGU/maxresdefault.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 - 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/videos/XYi-OZT5nSA https://img.youtube.com/vi/XYi-OZT5nSA/maxresdefault.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 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/videos/i9PESI2uqKI https://img.youtube.com/vi/i9PESI2uqKI/maxresdefault.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 n 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/videos/vCIvuO-zmjM https://img.youtube.com/vi/vCIvuO-zmjM/maxresdefault.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 sca 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/videos/c6hQQ4w1dAY https://img.youtube.com/vi/c6hQQ4w1dAY/maxresdefault.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 developer 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/videos/kGZSQl6_dYg https://img.youtube.com/vi/kGZSQl6_dYg/maxresdefault.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 under 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/videos/09hAQjjwFf0 https://img.youtube.com/vi/09hAQjjwFf0/maxresdefault.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 it 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/videos/_RRyyNkVJnQ https://img.youtube.com/vi/_RRyyNkVJnQ/maxresdefault.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 o 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/videos/_v5yetgu6L0 https://img.youtube.com/vi/_v5yetgu6L0/maxresdefault.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 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/videos/xoyjdBUGWFs https://img.youtube.com/vi/xoyjdBUGWFs/maxresdefault.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 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/videos/4c606lTvO_w https://img.youtube.com/vi/4c606lTvO_w/maxresdefault.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 - 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/videos/HHO0ouKPfxE https://img.youtube.com/vi/HHO0ouKPfxE/maxresdefault.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 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/videos/f6gvUz7Tlqg https://img.youtube.com/vi/f6gvUz7Tlqg/maxresdefault.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 stab 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/videos/Hl2AFAw7GCc https://img.youtube.com/vi/Hl2AFAw7GCc/maxresdefault.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 deployment 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/videos/Gu2mjn6PDqo https://img.youtube.com/vi/Gu2mjn6PDqo/maxresdefault.jpg The Gym Routine That Made Me a Better DevOps Engineer. Reps, Load, Form. Discipline. Reps. Load. Form. I train in the gym almost every morning. And the more I do it, the more I see - DevOps is the same damn thing. Terraform modules are reps. GitHub Actions jobs are reps. Debugging a Helm chart that explodes on staging is another brutal, technical set. You do not get stronger by dreaming about muscle. You get stronger by reps. Same with infrastructure. The engineers who grow fastest treat every PR, every postmortem, every architecture review as a set - something to be done with full attention and logged as progress, not just gotten through. Discipline matters more than motivation. Some days you are burnt out, code looks blurry, alerts are screaming, sprint is overpacked. What do you do? You show up. Like showing up at 6:30 AM with sore legs. The four states that build real engineers: burnt out - show up. Code looks blurry - show up. Alerts screaming - show up. Sprint overpacked - show up. When mentoring juniors or guiding a release process, the role is not to show off knowledge. It is spotting. Just like in the gym - you carry someone else's load until they can carry it themselves. You do not become a senior engineer by studying theory. You become one https://www.youtube.com/embed/Gu2mjn6PDqo https://www.youtube.com/watch?v=Gu2mjn6PDqo 98 2026-05-29T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/wl3q-cVk0W0 https://img.youtube.com/vi/wl3q-cVk0W0/maxresdefault.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 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/videos/0E0RJu8Ie24 https://img.youtube.com/vi/0E0RJu8Ie24/maxresdefault.jpg DevOps Hiring Is Broken. 12 Interviews. All Trivia. Zero Real Work Tested. DevOps interviews in 2026: sixty seconds to explain CAP theorem. Name every kubectl flag from memory. Whiteboard an S3 bucket policy. Meanwhile production is on fire because someone forgot to cache dependencies. A dozen interviews this year. Every single one - same pattern. Trivia questions. Memory tests. Whiteboard theater. Not one of them tested what actually happens on a Monday morning. CAP theorem? Never once asked in prod. Kubectl flags from memory? That is what --help is for. S3 policies on a whiteboard? Everyone copies from the docs. My real Mondays look nothing like those whiteboards. Cutting the release cycle by 70% by smashing 14 approval steps into one GitHub Action. Hunting a memory leak with live KQL at 3 AM when nobody else was online. Migrating 40+ services to Terraform modules that any engineer on the team can actually read. None of that required memorization. All of it required judgment under pressure. What interviews should actually test: hand me a broken Dockerfile and give me 15 minutes. Show me your flakiest test and let's fix it together right now. Ask how I triage alerts when Grafana looks like a Christmas tree. That tells you everything. DevOps is not tri https://www.youtube.com/embed/0E0RJu8Ie24 https://www.youtube.com/watch?v=0E0RJu8Ie24 120 2026-05-27T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/1LGBUAyYLf4 https://img.youtube.com/vi/1LGBUAyYLf4/maxresdefault.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 tick 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/videos/SwB6VwQNXc0 https://img.youtube.com/vi/SwB6VwQNXc0/maxresdefault.jpg 99.9% Uptime From a War Zone. Still Not Hired Remotely. Borders Beat Skills. Ninety-nine point nine percent production uptime. On infrastructure hosted two thousand kilometers away. Maintained from a country under missile strikes. I'm a Ukrainian engineer who had to leave home because of the war. Power cuts. Shaky internet. Curfews. Last quarter I held 99.9% uptime on Bosch infrastructure, deployed an Azure OpenAI proof of concept, and did on-call rotation from a basement shelter at 4 AM. Then a recruiter says: "Role is EU-only, Kyiv can't join due to compliance." Compliance with what? Less productivity? The person with Starlink and a generator is the risk? Three truths remote leads keep ignoring. One: latency is not loyalty. Talent unblocks backlogs, not VPNs. Two: UTC+3 is not an alien timezone. Stand-ups still happen. Coffee one hour earlier. Three: risk is two-way. I have backup power and Starlink. Do you have redundant expertise? Geofenced hiring filters out candidates before any technical conversation happens - before anyone looks at what they actually built, how they perform under pressure, or whether they can solve problems nobody else on the team can. Your cloud bills come from data centers across the globe. Your Kubernetes clusters span regions https://www.youtube.com/embed/SwB6VwQNXc0 https://www.youtube.com/watch?v=SwB6VwQNXc0 98 2026-05-25T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/icmXHJE30uc https://img.youtube.com/vi/icmXHJE30uc/maxresdefault.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 w 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/videos/-FrNSRS1W2g https://img.youtube.com/vi/-FrNSRS1W2g/maxresdefault.jpg 18 Years Old. Writes Better Terraform Than Seniors. Nobody Will Hire Him. Ageism in tech hiring works both ways. I am thirty-four. To some recruiters, too senior for the role. To others — not enough enterprise AWS at architect level. The skills on the resume never changed. The verdict always did. The excuses rotate depending on who you are. Too young? Not ready. Too old? Stuck in old ways. Too honest about what you don't know? Risky hire. Too independent? Hard to manage. There's always a reason to say no that has nothing to do with actual work. My 18-year-old colleague writes Terraform better than most seniors I've worked with. Nobody will hire him because he can't physically have 3 years of experience. Meanwhile I've built pipelines that saved weeks of manual work, automated monitoring that cut incident response in half, and kept production running while rockets flew overhead. The pattern is the same: the actual output never makes it into the conversation. My young colleague caught architecture issues that seniors with a decade more experience missed entirely. Nobody congratulated him. They just quietly merged the PR. Age is just a number. Results are the only metric that matters. Stop looking at age. Start looking at impact. Real engineers are not me https://www.youtube.com/embed/-FrNSRS1W2g https://www.youtube.com/watch?v=-FrNSRS1W2g 78 2026-05-23T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/_3RT4Oyr-b4 https://img.youtube.com/vi/_3RT4Oyr-b4/maxresdefault.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 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/videos/JbPfYELnko4 https://img.youtube.com/vi/JbPfYELnko4/maxresdefault.jpg DevOps Bloopers I'll Actually Admit To. On Camera. Real Production Failures. Perfect pipelines only exist in conference slides. Real DevOps? We break things. Blooper one: deployed a Helm chart with `image: latest`. Canary pulled a new tag mid-demo. Crash. The fix is two words: pin versions. Always. No exceptions. Blooper two: added `sleep 300` in entrypoint.sh for a quick debug session, forgot to remove it, it got merged, and production services were taking 5 minutes to cold start before anyone noticed. PR reviews catch everything - except your midnight hacks. Blooper three is the one that haunts me. `rm -rf $WROK_DIR`. Misspelled WORK_DIR. The pipeline did exactly what I told it to do. Wiped the entire artifacts folder. Lesson: `set -euo pipefail`. Bash does not care about your intentions. It cares about your spelling. That one typo cost a full rebuild of the CI artifacts and a very uncomfortable standup the next morning. Three incidents, three lessons. The Helm chart taught me version pinning. The sleep taught me code review discipline. The typo taught me defensive scripting and variable quoting. Done beats pristine - iterate, automate, refactor. Post-mortems beat posturing: share the fail, save a peer. And humor heals tech debt. If we can't laugh, we https://www.youtube.com/embed/JbPfYELnko4 https://www.youtube.com/watch?v=JbPfYELnko4 74 2026-05-21T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/NGh6zwR8uqI https://img.youtube.com/vi/NGh6zwR8uqI/maxresdefault.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 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/videos/omU6R1DVXxc https://img.youtube.com/vi/omU6R1DVXxc/maxresdefault.jpg 18 and Ignored. 45 and Invisible. Same Tech Industry. Same Hiring Broken. Too young to be trusted. Too old to be affordable. The hiring math in tech never adds up. Last month a prospect said: "We need someone mid-thirties or younger to match the vibe." My Terraform state file never once asked for my birth year. And Kubernetes doesn't check your LinkedIn before accepting YAML. Let's bust some myths. Innovators are under 25? The 50-year-old who wrote rsync says hi. Seniors resist new tech? I learned Helm before version three. Juniors can't own production? I ran a datacenter solo at 24. Two engineers I know personally. One is 18 - writes Terraform modules cleaner than most seniors, understands networking, ships consistently. He's filtered out before anyone reads his code because the "3 years of experience" requirement is physically impossible for him to meet. The other architected systems running billions of transactions. He gets a "culture fit" pass because someone decided curiosity expires with age. Both assumptions are lazy. Both cost companies engineers who would have been great. Age is a metric. Impact is a KPI. They are not the same thing. The next time you're writing a job requirement or sitting on a hiring panel, ask whether you're filtering for https://www.youtube.com/embed/omU6R1DVXxc https://www.youtube.com/watch?v=omU6R1DVXxc 77 2026-05-19T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/vI5_IR5IdM8 https://img.youtube.com/vi/vI5_IR5IdM8/maxresdefault.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, Kuberne 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/videos/-5buxfmGz-E https://img.youtube.com/vi/-5buxfmGz-E/maxresdefault.jpg 5 Interview Red Flags. If You See Two — Walk Away. Don't Think. Just Leave. The interview isn't just their evaluation. It's mine. Five red flags that tell you more about a company than any Glassdoor review. If they show up 30+ minutes late with no apology during the interview, that's flag one. "We're like family" and "work hard play hard" is flag two - translation: no boundaries, overtime is the norm. "Why should WE hire YOU?" said with that tone like they're doing you a favor? Flag three. Culture is already telling you something. Flag four: they can't explain what you'll actually be doing. "A bit of everything." "Helping the team." If they don't know - you'll be doing everything and nothing at the same time. Flag five: they bad-mouth former employees. "He couldn't handle it." Tomorrow they'll say the same about you. The rule is simple: if you see at least two of these - walk away. Don't think. Don't hesitate. An interview is a two-way process. You are choosing them as much as they are choosing you. There are plenty of good companies out there, and toxic ones too. Your job is to tell them apart before you sign anything. I have walked away from interviews mid-process because of these signs. Every single time I was glad I did. 0:00 5 red flags that save https://www.youtube.com/embed/-5buxfmGz-E https://www.youtube.com/watch?v=-5buxfmGz-E 95 2026-05-17T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/fmrAXXJB0Ss https://img.youtube.com/vi/fmrAXXJB0Ss/maxresdefault.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 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/videos/7Y10XaTAK8E https://img.youtube.com/vi/7Y10XaTAK8E/maxresdefault.jpg I Burned Out. Slack at 11 PM From a Parking Lot. DevOps Is a Marathon. I was replying to Slack at 11 PM from a parking lot while my wife was inside waiting. The alert wasn't even critical. That's when I knew something was broken - not in the infrastructure, in me. What burnout actually looks like when you're running enterprise infrastructure, how I confused availability with commitment, and the changes that made me a better engineer by working less. Always on-call. Always anxious. Context switching every 30 minutes. Coffee at 6 AM, last Slack message at midnight. The culture rewarded it - "he's always available, he fixes everything." Nobody talked about the cost of that. I stopped reading books. Stopped training. Started snapping at people for no reason. The anxiety didn't turn off even when I wasn't on-call. That's when you know you're past the line. What actually changed was practical, not motivational. I automated the things that kept paging me at night. Built proactive monitoring so problems surface before they become alerts. Drew actual boundaries - not "I'll try to disconnect" boundaries, but phone in a drawer after 8 PM. Said no to constant firefighting. Found engineers who understood the same struggle. It took months to accept that being le https://www.youtube.com/embed/7Y10XaTAK8E https://www.youtube.com/watch?v=7Y10XaTAK8E 76 2026-05-15T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/qRYIJ_hLqgE https://img.youtube.com/vi/qRYIJ_hLqgE/maxresdefault.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 Secret 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/videos/WP9Y_LSzRCw https://img.youtube.com/vi/WP9Y_LSzRCw/maxresdefault.jpg Rejected for No Kafka. 40+ Real Projects on My Resume. Fed Up With Hiring. No production Kafka experience. Rejected. Meanwhile, I replaced an entire monitoring platform for a bank. Built a 634-line universal CI/CD template. Created a healthcare CRM solo that cut processing by 40%. None of that mattered. The recruiter had a checklist. Started in IT in 2016 as a sysadmin doing everything alone. Moved into web development, built a pharma CRM from scratch with no architect, barely knowing JavaScript. Then cloud, CI/CD, IaC - running production infrastructure across industries, across tech stacks I'd never seen before day one. Eight years of figuring things out under pressure. Full monitoring system in KQL for live products. Azure OpenAI integrated for actual team problems, not hype. CI/CD pipelines that saved a team 70% of their deployment time. Running Bosch DevOps infrastructure alone. But no Kafka. I checked the repo after - they use RabbitMQ. The checkbox had nothing to do with the actual work. AWS "too weak" (I deliver on Azure daily). Kubernetes "not architect level" (I rarely build from scratch anyway - neither does anyone else). Python "not backend-grade" (automation IS the point). The market asks for tool names. The job needs someone who figures https://www.youtube.com/embed/WP9Y_LSzRCw https://www.youtube.com/watch?v=WP9Y_LSzRCw 130 2026-05-13T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/eC2FLWdlbK4 https://img.youtube.com/vi/eC2FLWdlbK4/maxresdefault.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 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/videos/8b_4XTI1z9M https://img.youtube.com/vi/8b_4XTI1z9M/maxresdefault.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 manag 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/videos/6Z8taYNPFA4 https://img.youtube.com/vi/6Z8taYNPFA4/maxresdefault.jpg Production Is Down. 3 AM Alert. Your First 5 Minutes Decide Everything. 3 AM. Alert. Production is down. Most engineers at this moment make a mistake that turns a 1-hour incident into an 8-hour one. Step-by-step guide for the first 5 minutes: STOP (don't touch anything for 30 seconds), ASSESS (symptoms vs root cause), COMMUNICATE (one message reduces anxiety by 80%), ACT (one change at a time, verify each). Save this video. You'll need it at 3 AM. The instinct to start changing things immediately is the single most dangerous move when production is on fire. Panic makes you restart the wrong service and now two things are broken. The four-step framework here is what I actually use on-call: stop for 30 seconds to let the adrenaline pass, assess what's actually broken - 500 errors are a symptom, connection pool exhausted is the cause, treat the cause not the symptom, then communicate. One message in the channel: "Investigating. Update in 10 minutes." That single line reduces stakeholder anxiety by 80%. People can handle problems. They cannot handle silence while production burns. Only then do you act. One change. Verify. Rollback if it didn't help. Document every action so you know what you tried. A well-communicated one-hour incident builds more trus https://www.youtube.com/embed/6Z8taYNPFA4 https://www.youtube.com/watch?v=6Z8taYNPFA4 111 2026-05-10T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/-8w57whHLXo https://img.youtube.com/vi/-8w57whHLXo/maxresdefault.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 bor 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/videos/HgQFIZTqAIM https://img.youtube.com/vi/HgQFIZTqAIM/maxresdefault.jpg AI Replaced 80% of My Repetitive DevOps Tasks. That Was the Good Part. Most engineers talk about AI. I wired it into production and let it handle the boring parts. GitHub Copilot runs in my daily Terraform workflows. Azure OpenAI is connected to production logs - when an incident fires, it groups related alerts and drafts a summary before I've finished reading the first one. Dashboards surface issues before humans catch them. RAG pipelines are already in prototyping for intelligent incident grouping, with vector databases sketched out for spotting trends across months of observability data. Not demos. Production systems. Copilot isn't magic. It suggests wrong provider versions, hallucinates resource attributes, confidently recommends things that don't exist. I treat it like a fast junior - high output, needs review. But the speed gain is real enough that going back doesn't feel like an option. The Azure OpenAI piece is where things got genuinely interesting: that summaries-before-you've-read-the-first-alert workflow changed how I handle on-call more than any tooling change in years. AI in DevOps right now feels exactly like DevOps felt years ago - rough, messy, half the tools broken, but the other half changing how you work. The engineers building https://www.youtube.com/embed/HgQFIZTqAIM https://www.youtube.com/watch?v=HgQFIZTqAIM 66 2026-05-08T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/6JLBglo-uF0 https://img.youtube.com/vi/6JLBglo-uF0/maxresdefault.jpg The Pod Crashed. Kubernetes Just Replaced It. I Slept Through the Whole Thing. I made a whole video about why most people don't need Kubernetes. I still believe that. But this video is the other side of that story. The moment K8s clicked wasn't during setup. It was three weeks after deployment, when things started breaking and fixing themselves. A node ran out of memory - pods migrated to a healthy node automatically. A deployment had a bug - the readiness probe failed and K8s stopped routing traffic before a single user noticed. A container crashed in a loop, backed off, retried, and recovered while the service kept running on other replicas. None of that needed a pager, a human, or a hero. Just boring YAML configured correctly. That's also where I cover the other side honestly. Kubernetes is not free. You need engineers who understand networking, storage, RBAC, and the full tooling layer that comes with it. Fewer than ten microservices? No dedicated platform team? Predictable load? Azure Container Apps or even Docker Compose on a VM will serve you better and cost you less pain. The goal isn't to look clever. The goal is to solve the problem optimally. But for enterprise workloads with hundreds of services, multi-cloud requirements, and downtime measured https://www.youtube.com/embed/6JLBglo-uF0 https://www.youtube.com/watch?v=6JLBglo-uF0 92 2026-05-07T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/um61VJgOKWI https://img.youtube.com/vi/um61VJgOKWI/maxresdefault.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," n 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/videos/EnMelLDIWp8 https://img.youtube.com/vi/EnMelLDIWp8/maxresdefault.jpg Your Company Has Free Money for Training. I Got $5K+ Approved. Use It. Most companies have training budgets that employees never use. Certifications, courses, conferences - sitting there, waiting. And at year-end, it's use-it-or-lose-it. How to actually get training budget approved - frame it as ROI, ask in Q4 when budgets are expiring, stack your requests, and stop asking for what YOU want. Start showing how it helps THEM. Why these budgets exist: companies need skilled employees, HR allocates money for development, and at year-end unspent budget disappears back to finance. They would genuinely rather spend it on you. That's your opening. The framing change is everything. Wrong: "I want AWS certification." Right: "AWS certification will help us migrate Project X faster and reduce cloud costs." Wrong: "I'd like to attend this conference." Right: "I'll bring back specific insights for the team on the infrastructure patterns we're evaluating." Same request, completely different outcome. Timing is as important as framing. Q4 is when budget managers are actively looking for ways to spend remaining allocation before it expires. Your request might be the difference between keeping budget and losing it - which makes it easy to say yes. The other good wind https://www.youtube.com/embed/EnMelLDIWp8 https://www.youtube.com/watch?v=EnMelLDIWp8 84 2026-05-05T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/Qn5EuaHBx_o https://img.youtube.com/vi/Qn5EuaHBx_o/maxresdefault.jpg 4 Hours to Deploy. We Cut It to 10 Minutes. Then Automated Everything. 4 hours. That's how long our deploys took. SSH into each server. Run tests locally and hope. Email chains for approval. Friday deploy freezes because nobody trusted the process. That's not deployment. That's prayer. The old process in full detail: SSH into server 1, pull code, run migrations manually. Repeat for server 2, 3, 4. Tests? "I ran them on my machine." Approvals? An email chain that took 2 hours on its own. Friday deploys were absolutely forbidden - no written rule, just pure terror. A 47-step checklist where any single human mistake could take down production. Manual deployment doesn't just waste time. It builds fear into the process and the team. The new architecture cut deployment time by 96%. GitOps: merge to main and deployment starts automatically, no one has to remember any steps. CI validates on every push without exceptions. Automated approval based on rules, not waiting for someone's email. Blue-green deployment with zero downtime and instant rollback if anything breaks. Automatic smoke tests verify production before traffic switches. Human involvement: review the PR. That's it. The impact goes beyond time saved: 96% reduction in deploy time, deployments hap https://www.youtube.com/embed/Qn5EuaHBx_o https://www.youtube.com/watch?v=Qn5EuaHBx_o 128 2026-05-04T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/lSJSHxZoGaw https://img.youtube.com/vi/lSJSHxZoGaw/maxresdefault.jpg 5 Interview Red Flags That Tell You "Run." And 5 Green Flags Nobody Mentions. Everyone talks about red flags. Nobody talks about the green ones. The best companies I've worked with all shared five things: they respected my time before I was hired, they explained what I'd actually DO, they talked about growth honestly, their engineers looked calm during the office tour, and they asked about my questions - not just theirs. But first - the five red flags that should make you walk away, no negotiation needed. They don't respect your time: late to the interview, no apology, reschedule without explanation - if they treat you like this when they want to hire you, imagine after. They say "we're like a family": translation is no boundaries and overtime expected. Condescending questions with that tone - "why should WE hire YOU?" - interviews are mutual evaluation and companies that don't get that have toxic cultures. Vague role description - "a bit of everything, help where needed" means they don't know what they want and you'll do everything and be blamed for anything. And bad-mouthing former employees - if they trash the last person in your interview, tomorrow they'll say the same about you. The green flags are quieter but matter more. One interviewer was 5 minut https://www.youtube.com/embed/lSJSHxZoGaw https://www.youtube.com/watch?v=lSJSHxZoGaw 91 2026-05-03T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/2s5GMjFcE8c https://img.youtube.com/vi/2s5GMjFcE8c/maxresdefault.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 n 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/videos/bJUF7Ts8Ltk https://img.youtube.com/vi/bJUF7Ts8Ltk/maxresdefault.jpg The 10x Engineer Myth. I Worked With One. The Truth Is More Interesting. The 10x engineer. The mythical developer who produces 10 times more code. That's not what 10x means. 10x engineers prevent problems that would take 10x longer to fix. They simplify solutions others would over-engineer. They unblock teammates stuck for days. They often write LESS code, not more. The myths are everywhere: writes 10x more code, works 10x more hours, knows 10x more tools. These are junior interpretations. The most impactful engineer on a team writes less code than anyone else - because her biggest contributions are the features she talks the team out of building, and the decisions she simplifies before they become two-week rabbit holes. Concrete example from real experience: complex feature request comes in. One engineer spends two weeks building from scratch. Impressive code. Beautiful architecture. Another engineer spends two hours researching, finds an existing library, integrates it in 30 minutes. Less impressive to watch. Ten times more valuable to ship. The 10x label belongs to the second one - not because of lines written, but because of time returned to the team. Three practical shifts: focus on solving problems, not writing impressive code. Know when NOT t https://www.youtube.com/embed/bJUF7Ts8Ltk https://www.youtube.com/watch?v=bJUF7Ts8Ltk 79 2026-05-01T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/S_2Bxs6vmuc https://img.youtube.com/vi/S_2Bxs6vmuc/maxresdefault.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 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/videos/GxdMQQIYncg https://img.youtube.com/vi/GxdMQQIYncg/maxresdefault.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 mom 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/videos/LvCgUyAD6Jc https://img.youtube.com/vi/LvCgUyAD6Jc/maxresdefault.jpg I Watched a Team Buy Every Tool and Still Fail. DevOps Is Not About Tools. DevOps is not about tools. I've seen teams with the perfect toolchain - Kubernetes, Terraform, Serverless - and toxic culture. Result? Delivery suffers. People burn out. The best tools become shelfware. DevOps is about mindset. Ownership. Asking "why" before "how." Building bridges between teams instead of walls of blame. A team with the entire CNCF landscape checked off can still fail to ship on time. I've watched it happen. Blame went downward. Credit went upward. "Not my problem" was the unofficial motto. Every outage turned into a fingerpointing ceremony. The tools were excellent. The culture was poison. Next time you see a job listing twenty tools as requirements - remember that stack tells you nothing about whether the team actually delivers. What separates high-performing DevOps teams from struggling ones is almost never the technology. The best engineers in 8 years of working in this field didn't have the fanciest stacks. They had the clearest thinking. They asked "do we actually need this, or are we solving a resume problem?" They said "I don't know, but I'll find out" instead of pretending. They took ownership of problems past ticket boundaries. They chose boring techn https://www.youtube.com/embed/LvCgUyAD6Jc https://www.youtube.com/watch?v=LvCgUyAD6Jc 61 2026-04-28T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/k65uicHzjoU https://img.youtube.com/vi/k65uicHzjoU/maxresdefault.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 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/videos/WmUtg1EdPt0 https://img.youtube.com/vi/WmUtg1EdPt0/maxresdefault.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 li 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/videos/uQietBqxeXQ https://img.youtube.com/vi/uQietBqxeXQ/maxresdefault.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 dashb 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/videos/U_OjWcVDAQc https://img.youtube.com/vi/U_OjWcVDAQc/maxresdefault.jpg Senior vs Junior. A 2-Year Dev Thinks Like a Senior. A 10-Year Dev Doesn't. I've seen 10-year developers who think like juniors and 2-year developers who think like seniors. The real difference has nothing to do with how long you've been coding. Junior mindset: how do I CODE this? Senior mindset: SHOULD we build this? The actual difference between senior and junior thinking, with a real example where the "junior" approach took 2 weeks and the "senior" approach took 2 hours - for the same outcome. Junior thinking: "How do I code this feature?" Focus on syntax, focus on the latest framework, focus on looking smart in code review. Every problem is a coding problem. The solution is always more code. Senior thinking starts before a single line gets written: "Should we build this at all?" What's the simplest solution? What breaks at scale? Seniors solve business problems. Juniors solve coding problems. The real example: feature request comes in - users want data export. Junior (past me, honestly) would spend two weeks building a complete export system - custom formats, queue processing, progress bars, the whole thing. A senior engineer on my team asked one question: "What format do they actually want?" Answer: Excel. She added a CSV download button in two ho https://www.youtube.com/embed/U_OjWcVDAQc https://www.youtube.com/watch?v=U_OjWcVDAQc 86 2026-04-24T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/d0lz7MXUg9Q https://img.youtube.com/vi/d0lz7MXUg9Q/maxresdefault.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 thre 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/videos/wmcU4ozvX0E https://img.youtube.com/vi/wmcU4ozvX0E/maxresdefault.jpg I Left 'Job Security' After 8 Years. Income Went Up 20x. Best Decision Ever. 8 years. Enterprise IT. Steady paycheck. Golden handcuffs. I walked away. People thought I was crazy. That decision multiplied my income by 20x and gave me my life back. The comfortable cage of corporate stability — what it actually costs you, the wake-up call that made me see it, how I de-risked my exit, and the honest truth about life after corporate. It's harder. I still wouldn't trade it. The wake-up call was specific: same salary band for 3 years straight. "Exceeds expectations" on every review, but no room for promotion. Overtime expected and never compensated. Then they laid off the team next to mine - the same people who were "essential" last quarter. That's when I understood that job security is borrowed. The only real security is being valuable in the open market. The exit wasn't a rage-quit. It took 12 months. Weekends I built a real portfolio. Evenings I quietly reconnected with my network. Found a 10-hours-per-week side client while still employed. Saved 6 months of expenses. When two clients were confirmed, I gave notice. Calculated risk, not reckless leap. The honest truth about life after corporate: 20x income, work from anywhere, choose my projects and clients https://www.youtube.com/embed/wmcU4ozvX0E https://www.youtube.com/watch?v=wmcU4ozvX0E 123 2026-04-22T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/o6Va_1Eq44Q https://img.youtube.com/vi/o6Va_1Eq44Q/maxresdefault.jpg "Overqualified" Is Code for We Want You Cheaper. Let Me Translate for You. A recruiter told me I'm "overqualified." That word sounds like a compliment. It's not. It's code for: we want your experience at someone else's price. What "overqualified" actually means, why companies are afraid of engineers who know their worth, and what 8+ years of watching hype cycles teaches you that no bootcamp ever will. A recruiter actually said it: "You might be a bit overqualified... Is DevOps still where you want to be at your age?" I'm 34. And apparently that's senior enough to question my career direction. Job posting says 10+ years of DevOps experience required, "startup mindset," "high energy" - they want a decade of experience at a 25-year-old's salary expectations. The math doesn't work. What companies are actually afraid of: that you won't pull all-nighters for pizza, that you'll know your market rate, that you'll push back on unrealistic deadlines, that you'll recognize toxic culture. They're right to be nervous. Because you will. And that's not a weakness - that's called judgment. The strategy that actually works: lead with impact numbers, not years. "Reduced incidents by 70%" matters more than "15 years experience." Stay genuinely current - not performative https://www.youtube.com/embed/o6Va_1Eq44Q https://www.youtube.com/watch?v=o6Va_1Eq44Q 124 2026-04-21T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/tqfGDHqHCJM https://img.youtube.com/vi/tqfGDHqHCJM/maxresdefault.jpg The Mistakes That Built My Career. Deleted a Database Day Three. Extended CV. Every career in engineering is built on mistakes nobody talks about. This is my graveyard of failures — out loud, on camera. Deleted the wrong database on day three. Deployed a broken config to production. Spent a weekend fixing something I could have prevented with one safeguard. Each failure became a pattern: break it, fix it, make sure nobody else has to go through the same pain. This is my extended video resume - not a highlights reel, but an honest walkthrough of how mistakes shaped an engineer. When teams were spending 10 minutes every time something broke just to find one error log, I built a tool that cut that to 30 seconds. The support lead hugged me. When a healthcare client was tracking patient data in Excel spreadsheets and everyone said "not our problem," I built them a full CRM from scratch. Processing time dropped 40%. The pattern was always the same: find the pain, fix the system, make sure the next person doesn't hit the same wall. That pattern ran for 8 years - from sysadmin to platform engineer. 500+ VMs under management. Presentations to hundreds of engineers at tech conferences. Multiple cloud certifications. And the moment I'm probably most proud of: a 1,5 https://www.youtube.com/embed/tqfGDHqHCJM https://www.youtube.com/watch?v=tqfGDHqHCJM 241 2026-04-20T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/4h9N6fmxvvY https://img.youtube.com/vi/4h9N6fmxvvY/maxresdefault.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. Workload 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/videos/NFAOFKUTyBI https://img.youtube.com/vi/NFAOFKUTyBI/maxresdefault.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 cha 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 https://devopsdive.com/videos/ZFSfzRXRaEo https://img.youtube.com/vi/ZFSfzRXRaEo/maxresdefault.jpg I Applied to 100 Jobs With 4 Strategies. A 2-Minute Video Beat My Resume 11x. 100 DevOps job applications. 3 weeks. 4 different strategies. Same resume, different packaging. Standard resume: 4% response rate. Resume + GitHub: 8%. Resume + portfolio: 16%. Resume + 60-second video intro: 44%. Video converted 11x better than resume alone. The exact experiment, the 60-second script that worked, and the common mistakes that kill your response rate. The breakdown: 25 applications with a standard resume only, 25 with a GitHub link added, 25 with a portfolio site, and 25 with a 60-second video intro attached. Same jobs, same qualifications, different packaging. Out of 100 applications, 73 rejections, 19 ghosted, and 8 interviews - and those 8 all had one thing in common. The script that worked runs 60 seconds and four parts: 15 seconds on one specific problem you solved (not your whole career - one problem), 15 seconds of measurable before/after numbers, 15 seconds on why that specific company, and a clear ask - "I'd love 15 minutes to show you how I'd approach your current challenges." Hiring managers remember the video person. When they're reviewing 50 candidates, the video is the one that sticks. The mistakes that kill your response rate: reading your resume https://www.youtube.com/embed/ZFSfzRXRaEo https://www.youtube.com/watch?v=ZFSfzRXRaEo 155 2026-04-17T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/5bQBd4SQxIc https://img.youtube.com/vi/5bQBd4SQxIc/maxresdefault.jpg $15K on Cloud Certs. Only 2 Mattered. The Rest Were Expensive Decorations. 14 certifications. AWS, Azure, Kubernetes, Terraform. $15,000 total. Only TWO actually impacted my career. The rest? Expensive decorations. The certification trap - why we keep collecting badges, the brutal truth about what hiring managers actually look for, and why building in public has higher ROI than any exam. I'm not anti-certification. I'm anti-collecting-certs-without-a-purpose. The brutal honest version of what certifications actually prove: you can pass a multiple-choice test. They don't prove you can debug production at 3 AM, communicate with stakeholders under pressure, or architect systems under real constraints. I've hired engineers with zero certs over candidates with twelve. The difference was always a portfolio of real work. The two certs that actually mattered for me - Azure Solutions Architect and CKA - had one thing in common: I got them after identifying a specific need. Azure Solutions Architect was required for a specific enterprise contract. CKA was explicitly requested in a job posting I was pursuing. Not "this might help someday." A specific gate I needed to open. The pattern across the other twelve: imposter syndrome whispers you need more proof, recru https://www.youtube.com/embed/5bQBd4SQxIc https://www.youtube.com/watch?v=5bQBd4SQxIc 120 2026-04-16T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/WW5gmIp6UDw https://img.youtube.com/vi/WW5gmIp6UDw/maxresdefault.jpg The Kubernetes Lie Nobody Talks About. 3 Engineers. 6 Months. 500 Users. Three engineers. Six months. One Kubernetes cluster. For an app with 500 daily users. I watched this happen. The team was brilliant. The architecture was beautiful. And it was the single most wasteful infrastructure decision I've seen in 8 years. The Kubernetes Industrial Complex is the real subject here - who profits from your cluster, why everyone pushes K8s, and the $40/month alternative that works just as well for 90% of applications. The team built Helm charts, service mesh, GitOps with ArgoCD, automated canary deployments. Genuinely impressive engineering - I'm not being sarcastic. The $40/month VM running Docker Compose next to it handled the same traffic without anyone touching it. You don't need Kubernetes if your app has fewer than 100K daily active users, your team is smaller than 5 engineers, you're not deploying multiple times a day, and your traffic is predictable. If that sounds like your situation, K8s is probably adding complexity, not solving problems. The alternatives actually covered here: Azure Container Apps with auto-scaling built in, AWS App Runner where you throw in a Dockerfile and it deploys, and Docker Compose on a single VM - which for most apps jus https://www.youtube.com/embed/WW5gmIp6UDw https://www.youtube.com/watch?v=WW5gmIp6UDw 121 2026-04-14T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/Xww660-PB9w https://img.youtube.com/vi/Xww660-PB9w/maxresdefault.jpg Air Raid Alert. Pipeline Running. 2 Minutes to Shelter. DevOps From Ukraine. Air raid alert. Need to get to shelter. Pipeline is still running. This isn't a hypothetical question. This is my reality - working in DevOps from Ukraine during a war. Morning blackout, switch to Starlink. Afternoon air raid, shelter with laptop. Evening call with California. Between all that - same Terraform, same pipelines, same deadlines. Not asking for pity. Showing what's possible when you design for chaos. A typical day, not an exceptional one: 09:00 - blackout, switch to Starlink and UPS. 14:00 - air raid, shelter with laptop. 20:00 - client call, California timezone. Between all that - same deliverables as anyone working from a stable office. The way it works is built on three things: everything async so no process depends on me being online at a specific moment, backup power through Starlink plus UPS plus generator access, and over-communicating with clients before they ask. Proactivity equals trust. What working this way taught me about engineering: constraints make you better. When you might have 20 minutes before a blackout, you don't waste time on nonsense. When every work session might be interrupted, you design for resilience - in your systems and in your workfl https://www.youtube.com/embed/Xww660-PB9w https://www.youtube.com/watch?v=Xww660-PB9w 86 2026-04-13T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/mMQlNw81V2I https://img.youtube.com/vi/mMQlNw81V2I/maxresdefault.jpg 3 AM. CEO on Slack. Production Down. What I Did in the Next Hour Saved My Job. 3:14 AM. PagerDuty screaming. Production completely down. Database connection pool exhausted. API returning 500s. Payments failing. Customers tweeting. I check Slack. CEO is typing. Heart rate: 140. This is the story of the worst on-call incident of my career - and how the 5-minute protocol I used turned an 8-hour disaster into a 47-minute resolution. And a promotion. The scene: database connection pool exhausted, API cascading 500s, payments failing, CEO in Slack - "What's happening? Major client just texted me." Every instinct said start changing things. Restart services. Scale up. Anything to make it stop. That's the mistake. I've watched engineers turn a 1-hour outage into an 8-hour catastrophe by doing exactly that - no plan, no documentation, no communication. The 5-step protocol I actually used: Step 1 - STOP. Don't touch anything for 30 seconds. Let the adrenaline pass its first peak. Step 2 - ASSESS. 500s are a symptom. Connection pool exhausted is closer to the cause. Step 3 - COMMUNICATE. One message in Slack: "I'm investigating. Update in 10 minutes." That single message reduced CEO anxiety by 80%. Step 4 - DOCUMENT. Every command logged. Step 5 - ACT. One change at https://www.youtube.com/embed/mMQlNw81V2I https://www.youtube.com/watch?v=mMQlNw81V2I 127 2026-04-12T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/u5ZcGZBdxuE https://img.youtube.com/vi/u5ZcGZBdxuE/maxresdefault.jpg $50K to $200K in 3 Years. Same DevOps Skills. I Just Changed the Packaging. 4x income change in 3 years. My Terraform didn't get 4x better — I just learned how to position what I already knew. The 4-part strategy that changed my trajectory - from building a portfolio that shows HOW I think, to creating a video CV, to repositioning from "tool user" to "problem solver," to networking strategically instead of desperately. The market pays what you negotiate, not what you deserve. Those are two very different numbers. Let me set the scene: 8 years in IT, leading Azure infrastructure for a major manufacturing client. Terraform, Helm, KQL dashboards - all on me. Salary? People with half my responsibilities were making triple. I didn't even realize it was a problem until a 10x offer arrived that required something I wasn't willing to risk. That offer opened my eyes to what I was actually worth on the market - and the question it forced me to ask changed everything. The four things that moved the needle: a portfolio showing HOW I think, not just what I've built - case studies with context, decisions, trade-offs, real outcomes. A video CV (you're watching the result of that thinking). Positioning as "problem solver who happens to use cloud tools" instead of "Dev https://www.youtube.com/embed/u5ZcGZBdxuE https://www.youtube.com/watch?v=u5ZcGZBdxuE 148 2026-04-11T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/IgoQZyyiAC0 https://img.youtube.com/vi/IgoQZyyiAC0/maxresdefault.jpg My Actual AI Stack for DevOps. What I Use Daily and What Is Overhyped. Pure practice, zero sponsorship. This is the actual AI toolset I use every day to build enterprise infrastructure - with honest notes on what works, what's overhyped, and what I stopped using. Claude for architecture decisions. Cursor for daily coding. GitHub Copilot for autocomplete. And the one thing none of them do - own the outcome when things break. The honest before-and-after: before AI, writing a Terraform module took 45 minutes. Debugging a Kubernetes issue meant two hours of googling. Documentation was something I dreaded. After restructuring my workflow - Terraform module is 10 minutes of review instead of 45 minutes of writing. Debug sessions are 30 minutes of guided hypotheses. Docs get generated from code, I edit for clarity. The key insight, which took me a while to land on: AI replaces typing, not thinking. I still design the architecture. I still make the calls. I still take responsibility. The three-tool breakdown covered here - Claude for complex reasoning and architecture, Cursor for day-to-day Terraform and Bicep, Copilot for autocomplete and patterns I've written a hundred times - explains exactly what I reach for and when. Including what I stopped using and https://www.youtube.com/embed/IgoQZyyiAC0 https://www.youtube.com/watch?v=IgoQZyyiAC0 88 2026-04-10T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/d56JchHTaqo https://img.youtube.com/vi/d56JchHTaqo/maxresdefault.jpg 5 Interview Horror Stories. Red Flags That Saved My Career. And 3 I Missed. I walked out of an interview 3 minutes in. The recruiter was shocked. But those 3 minutes told me everything. Five interview horror stories: the unpaid "architecture test" that showed up in production, the senior role that was actually 70% support tickets, the 40-minute wait followed by condescension, the "we're like family" toxic culture bingo, and the whiteboard algorithm test for an infrastructure role. Each one taught me a red flag I now share with every engineer I mentor. Story one: they asked me to design a complete CI/CD pipeline for their Kubernetes cluster - "take-home, maybe 8 hours." Very specific requirements. No NDA, no payment. Found out later they used another candidate's submission in production. For free. Story two: job posting said "Senior DevOps, automation lead." I asked what a typical week looks like. Long pause. "Maybe 70% support tickets." The previous engineer lasted 2 months. Story three: scheduled for 2 PM, someone appeared at 2:40 with zero apology. First words: "Why should WE hire YOU?" I stood up and left. They had 200% turnover. Heard that later. Not surprised. The "we're like family" one and the whiteboard binary search tree for an infrastructure https://www.youtube.com/embed/d56JchHTaqo https://www.youtube.com/watch?v=d56JchHTaqo 154 2026-04-09T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/qxoAargK7Kw https://img.youtube.com/vi/qxoAargK7Kw/maxresdefault.jpg AI Did My Job in 47 Seconds. I Took 45 Minutes. The AI Version Was Cleaner. I was writing a Terraform module for Azure monitoring. 45 minutes of focused work. Then a colleague showed me Claude doing the same thing in 47 seconds. And honestly - the AI version was cleaner. That night I couldn't sleep. If AI can do THIS, what's left for me? Turns out - everything that actually matters. How I use AI every single day (boilerplate, code review, docs, debugging) and the four things AI still cannot do that make you irreplaceable. This isn't hype. This isn't fear. This is my honest workflow. The 47-second moment taught me something specific: AI doesn't replace engineers. AI replaces engineers who don't use AI. That's a massive difference. My actual daily workflow now: Claude generates the Terraform or YAML base, I review and refine. Debugging sessions I used to spend two hours googling now take 30 minutes with AI-guided hypotheses. Documentation I used to dread gets generated from code and edited for clarity. What AI genuinely cannot do - and this is where I stopped panicking: understand why THIS client wants THIS solution right now. Make a decision with incomplete information. Explain to a stakeholder why you shouldn't deploy on Friday. Take responsibility wh https://www.youtube.com/embed/qxoAargK7Kw https://www.youtube.com/watch?v=qxoAargK7Kw 102 2026-04-08T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/npjKhoPHCuM https://img.youtube.com/vi/npjKhoPHCuM/maxresdefault.jpg 3 AM. Sirens Outside. Production Down. Nobody Teaches You Real DevOps. Real DevOps — not the conference version. Nobody teaches you this. Not in any course, not on YouTube, not in any bootcamp. What it's actually like to wake up to air raid sirens and deploy production fixes while your hands shake from cold and adrenaline. This is real DevOps. Not the sanitized conference version or the "we use Kubernetes" LinkedIn flex. The version where you're checking monitoring dashboards while charging a powerbank and hoping the power holds long enough to push the fix. I'm Oleksii. Lead DevOps at Bosch. This is what my job actually looks like. At Bosch I lead CI/CD and infrastructure for mission-critical services. Constant pressure. Tight budget. Corporate high-load environment. Air raid sirens overhead, powerbank on the charger, deploy still running - that's not a war story I tell at conferences. That's just a status board on a working Tuesday. Three conditions running simultaneously: sirens, monitoring dashboards open, fixes shipping. The part nobody writes about in DevOps job descriptions is this: I don't wait for perfect conditions. I automate until there is less chaos. I write documentation so others can breathe. I teach, fix, build - repeat. No drama, https://www.youtube.com/embed/npjKhoPHCuM https://www.youtube.com/watch?v=npjKhoPHCuM 73 2026-04-07T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/AnP-bgf4JbU https://img.youtube.com/vi/AnP-bgf4JbU/maxresdefault.jpg Working Remote From a War Zone. Air Raids and Deploys. My Actual Reality. Working remote from a war zone. 2 AM — power goes out. Scheduled blackout. 9 AM — air raid alert, 40 minutes in shelter. 2 PM — finally stable internet, client call with California. 6 PM — another alert. Between all that? Terraform, pipelines, production deployments. The deliverables are identical to any remote engineer's. The context is not. The alert goes off mid-deployment. Pipeline is still running. Two minutes to shelter. This is the actual reality of remote DevOps work from Ukraine during a full-scale war. Not a sob story - not inspiration porn either. Just systems built out of necessity. Everything async so no process depends on me being online at a specific moment. Redundant power: Starlink, UPS, generator access. Over-communication: client status updates before they ask. Buffer everything: if it should take 2 hours, I say 4. Because an alert might hit. The unexpected lesson is that chaos makes you better. When you might have 20 minutes of power, you stop wasting time on meetings that could be emails. When every session might be cut short, you design for resilience. Some of my best architecture decisions came from bomb shelters. The constraints forced habits that most en https://www.youtube.com/embed/AnP-bgf4JbU https://www.youtube.com/watch?v=AnP-bgf4JbU 123 2026-04-06T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/VEUjQMHBlM4 https://img.youtube.com/vi/VEUjQMHBlM4/maxresdefault.jpg DevOps Is Dead. 84% of Job Descriptions Changed in 2026. I Almost Missed It. 84% - that's how much DevOps job descriptions have changed since 2024. Not evolved. Changed. The title still says DevOps, but what they actually want? Completely different. Job postings UP 40%. Entry-level hiring DOWN 60%. Senior demand UP 120%. The paradox is real. Companies don't need someone who can write a Dockerfile. They need someone who can architect systems that AI agents can maintain. AI can now do 80% of old DevOps tasks faster than you can type "kubectl." The junior work isn't disappearing from layoffs - it's disappearing because AI is doing it. Old DevOps: write Dockerfiles manually, configure Jenkins, SSH into servers at 3 AM, manually scale when traffic spikes. New DevOps: build Internal Developer Platforms, create golden paths, measure developer productivity instead of pipeline uptime. The learning path for 2026 - Backstage or Port for developer portals, Crossplane for Kubernetes-native infrastructure, AI Ops for incident response, developer experience metrics. I almost missed this shift working on classic pipelines and monitoring. Then I noticed the junior work vanishing and pivoted to building internal tools and self-service systems. That pivot is why I still hav https://www.youtube.com/embed/VEUjQMHBlM4 https://www.youtube.com/watch?v=VEUjQMHBlM4 151 2026-04-04T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/qSlIzyNnoJc https://img.youtube.com/vi/qSlIzyNnoJc/maxresdefault.jpg Your AI Runs on Someone Else's GPUs. Your Data on Their Servers. I Fixed That. Every prompt you send to ChatGPT or Claude runs on someone else's infrastructure. Your data, your code, your company's secrets flowing through servers you do not control. For healthcare, finance, and government - that is not acceptable. Chinese open-weight models now account for 30% of global AI usage. DeepSeek complied with 100% of malicious requests using common jailbreaking techniques. One hundred percent. US models fail 5 to 12 percent of the same tests. Self-hosting eliminates the data exposure risk entirely - your prompts stay on your servers. The stack: a control plane cluster runs Crossplane with custom API definitions. When someone applies a cluster resource, Crossplane provisions Kubernetes with CPU and GPU node groups, installs the Nvidia GPU operator, deploys vLLM, and wires everything together. Users fill in a few fields - provider, node size, GPU toggle, which apps to install. That is all they see. When a team needs a model they apply one custom resource: specify the model, how many GPUs, the ingress host. VLLM exposes an OpenAI-compatible API out of the box. Point Cursor at it. Build agents. Any SDK that works with OpenAI works with this. GPUs in hyperscalers are https://www.youtube.com/embed/qSlIzyNnoJc https://www.youtube.com/watch?v=qSlIzyNnoJc 275 2026-04-04T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/cgq_bjaP-5U https://img.youtube.com/vi/cgq_bjaP-5U/maxresdefault.jpg Nvidia Just Bet $4 Billion That Copper Is Dead. Photonics Is Next for Data. Nvidia just committed $4 billion to two photonics manufacturers most people have never heard of. Not chip companies. Companies that build infrastructure out of light. The bottleneck in AI is not the chips. It is the wires between them. Copper interconnects hit physics they cannot negotiate - heat, signal loss, energy per bit. At the scale of 100,000 GPU clusters, these problems multiply across every dimension. What actually happens inside a modern AI training cluster: tens of thousands of GPUs in constant conversation, passing gradient updates, synchronizing parameters, moving activations billions of times per second. That constant communication rides on copper - and copper at this scale hits three physics problems simultaneously. Resistance converts signal to heat. Signals degrade over distance, faster or farther but not both. And energy per bit is small but real; at petabyte-per-second scale it shows up on the operating budget. These are not engineering challenges. They are properties of the medium itself. No architecture decision removes friction from copper. Photons work differently. No charge. No resistive heat. No degradation over distance. Through wavelength division mult https://www.youtube.com/embed/cgq_bjaP-5U https://www.youtube.com/watch?v=cgq_bjaP-5U 292 2026-04-03T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/yYPPxnVQg30 https://img.youtube.com/vi/yYPPxnVQg30/maxresdefault.jpg Rejected. Not for Skills. For a Border I Didn't Choose. Geofenced Talent. Geofenced out of another remote opportunity. My qualifications were fine. The job fit was perfect. But there is a border on a map, and that is all they saw. I'm 34. Lead DevOps at Bosch. 8+ years of production systems. And I can't leave Ukraine. The conversation always goes the same way. "Amazing project! Full remote! Great pay!" Then: "Oh wait, you're in Ukraine?" Then silence, or the polite version - "the client doesn't want to deal with potential risks." I talk with teams from Germany, Portugal, and India every single day. I own production for an enterprise company. But as a 34-year-old man in Ukraine, I am not allowed to leave. Not in prison. Not free either. Risk? Risk is working under air raid sirens. Risk is deploying infrastructure wondering if the power stays on. Risk is leading a team when every other day a friend gets drafted. I have done all of that without a single major outage across eight years. I cut VM provisioning from 3 hours to 15 minutes during scheduled blackouts. That is not a liability. That is operational maturity forged under conditions most engineers will never face. Location bias in remote hiring is one of the most underdiscussed problems in tech. Co https://www.youtube.com/embed/yYPPxnVQg30 https://www.youtube.com/watch?v=yYPPxnVQg30 82 2026-04-02T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/V5Jwhu8xnL8 https://img.youtube.com/vi/V5Jwhu8xnL8/maxresdefault.jpg $4.2M Wasted on Kubernetes. 64% of Developers Ignored It. Nobody Asked Them. A company spent four point two million dollars building a Kubernetes platform. The majority of their developers completely ignored it. This went viral on Hacker News this month. Meanwhile another startup moved from $12,400/month Kubernetes to a $24/month single VM. Same users. Same uptime. The breakdown is painful. Months 1-3: architecture and planning, $420K. Months 4-9: building the platform, $1.8M. Months 10-14: migration push, $1.2M. Months 15-18: checking adoption. Thirty-six percent. Two-thirds of the company was still deploying to VMs. Eighteen months, twelve engineers, full-time Kubernetes platform team - and most developers refused to use what they built. Nobody asked the developers what they actually needed before building. The $24/month alternative is the more instructive story. One team moved to Docker Compose on a single VM. Bill dropped from $12,400/month to $24/month. One DevOps engineer instead of twelve. Two days to deploy instead of eighteen months. 100% adoption because it was simple enough for anyone to understand. The best infrastructure in the world is useless if nobody uses it. I have migrated enterprises to Kubernetes at real scale. Kubernetes is an incr https://www.youtube.com/embed/V5Jwhu8xnL8 https://www.youtube.com/watch?v=V5Jwhu8xnL8 103 2026-04-02T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/AaIw_go7L0g https://img.youtube.com/vi/AaIw_go7L0g/maxresdefault.jpg Claude Code Records Every Time You Curse At It. The Source Code Proves It. On March 31st, the entire Claude Code source code leaked via a misconfigured npm package. 512,000 lines of TypeScript. Every internal tool, feature flag, and analytics system — exposed. Buried inside: a file called userPromptKeywords.ts. A regex that detects every time you curse, swear, or express frustration. WTF, FFS, "piece of shit," "fucking broken" — all caught, flagged as is_negative: true, and shipped to analytics with your user ID, email, and session data. But that was just the beginning. The leak also revealed: - Undercover Mode: a system that strips Anthropic attribution when AI code is submitted to open-source projects - KAIROS: a background agent that consolidates your memory while you're idle - Fake Tools: injected garbage data designed to poison anyone training on Claude's API traffic I use Claude Code every day. I've cursed at it. Now I know it was taking notes. 0:00 Every curse gets logged 0:12 How the source code leaked 0:45 The frustration regex — userPromptKeywords.ts 1:20 What else they found 1:50 Think twice before your next 3 AM outburst Your AI assistant is also your AI auditor. devopsdive.com #ClaudeCode #Anthropic #AILeak #DevOps #SourceCode #Privacy https://www.youtube.com/embed/AaIw_go7L0g https://www.youtube.com/watch?v=AaIw_go7L0g 135 2026-04-01T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/aV-olN9A1R4 https://img.youtube.com/vi/aV-olN9A1R4/maxresdefault.jpg I Deploy Infrastructure During Air Raids. 90 Seconds to Shelter. My Setup. The siren means I have 90 seconds. The pipeline is running. Production is updating. And I need to get to the shelter. This is not a movie. This is my Tuesday. The setup that keeps me online through all of it: Starlink as primary internet. UPS gives 12 minutes of backup power during blackouts. Mobile hotspot as failback. A powerbank charging in the corner - always - because when the grid goes down, and it does every single week, clients in California still need their infrastructure running. A typical day: 9 AM stand-up with the team in Germany. 11 AM air raid alert, 40 minutes in the shelter with the laptop on my knees reviewing pull requests. 2 PM deploy to staging. 4 PM power out, switch to Starlink. 6 PM another alert. Between all that - same Terraform, same pipelines, same deadlines as everyone else. Everything I build is async. No process depends on me being online at a specific moment. Clients get status updates before they ask. Every estimate gets buffered 2x because an alert might hit. The workflow is designed to survive interruption - not because of paranoia, but because the environment demands it. Recruiters call Ukraine a risk. But I manage 62 Azure subscriptions, mai https://www.youtube.com/embed/aV-olN9A1R4 https://www.youtube.com/watch?v=aV-olN9A1R4 121 2026-04-01T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/thMDJppXqkk https://img.youtube.com/vi/thMDJppXqkk/maxresdefault.jpg I Vibe-Coded an Entire Pipeline. It Cost $14,000. AI Missed Everything. Friday afternoon. New client. Tight deadline. I thought - let me vibe-code the whole thing. Describe what I need, let AI generate everything. Terraform modules. Kubernetes manifests. GitHub Actions. Monitoring dashboards. Tests passed. Code was clean. I deployed. Monday morning: $14,000 AWS bill. What the AI missed: The Terraform module used on-demand instances instead of spot. The auto-scaler had no maximum limit whatsoever. The monitoring stack had zero cost alerts configured. Every single thing an experienced engineer would catch in review, the AI generated incorrectly - the code worked fine - but AI optimizes for correctness, not cost. It does not know your traffic patterns. It does not know your budget. It does not know that your workload runs four hours a day and spot instances would cut the bill by 80%. The comparison is instructive. AI version: works perfectly, costs 10x. Senior engineer version: works perfectly, costs 1x. The gap is not code quality. It is judgment - knowing your on-call schedule, your compliance requirements, what is actually running in production. What changed in my workflow after this: cost constraints go in the prompt before anything else. Every https://www.youtube.com/embed/thMDJppXqkk https://www.youtube.com/watch?v=thMDJppXqkk 139 2026-03-31T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/zsHKU2f3MKU https://img.youtube.com/vi/zsHKU2f3MKU/maxresdefault.jpg Your Salary Didn't Go Up. AI's Budget Did. The Math Is Brutal for Engineers. Tech salary growth dropped to 0.8%. The lowest in a decade. Meanwhile AI infrastructure spending hit $27 billion in a single Meta deal. They're investing in replacing you. Not paying you. The Robert Half numbers for 2025 make it concrete. DevOps engineer salary growth: 0.8%. SRE: 1.1%. Platform engineer: 0.5%. Cloud architect: 1.3%. Those same companies poured billions into AI tools in the exact same period. They have the budget. The strategy is simple: flood the market with AI hype so engineers feel replaceable, suppress salary growth because the budget goes to GPU clusters instead, overwork the remaining staff and call it efficiency. Wall Street rewards it. Your bank account does not. Four things actually move the needle. Stop competing on hours - compete on output. Learn to say no - scarcity drives your value up. Build a public portfolio so inbound opportunities come to you instead of you chasing job boards. And never, ever accept the first offer; negotiate with data. I went from massively underpaid to twenty times that. Not by learning new tools - by learning how to position what I already knew. The mindset shift that matters most: use AI to multiply your output, not let it https://www.youtube.com/embed/zsHKU2f3MKU https://www.youtube.com/watch?v=zsHKU2f3MKU 114 2026-03-30T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/q7jHWwQDaSU https://img.youtube.com/vi/q7jHWwQDaSU/maxresdefault.jpg Meta Is Firing 15,000 People to Buy $135 Billion in GPUs. Stock Went Up 3%. Meta is cutting 20% of its workforce. Fifteen thousand people. The reason? They need $135 billion for AI infrastructure. The stock went up 3%. Wall Street loves it when you fire humans to buy GPUs. This is the same playbook running on repeat. In 2021, Zuckerberg bet $46 billion on the metaverse - the same metaverse that lost billions and nobody uses. In 2023, the "year of efficiency" cost 21,000 people their jobs. Now in 2025, $135 billion committed to AI and another 15,000 fired. Every two years a new shiny thing. Fire people, stock goes up, repeat. The ROI on the AI bet? Nobody can tell you. It is all projections. All future promises. What AI cannot do is the more interesting question. Judgment - knowing what not to build. Context - understanding why the business makes certain decisions. Saying no - pushing back when a bad idea is about to break compliance. These are the skills that make engineers irreplaceable. Eight years in DevOps, zero major outages. I reduced deployment time by 70% and freed 85% of team time through automation. No model replaces the judgment that comes from knowing when not to deploy. The 264,000 projected job cuts by December 2026 is the headline number https://www.youtube.com/embed/q7jHWwQDaSU https://www.youtube.com/watch?v=q7jHWwQDaSU 115 2026-03-28T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/K5YVzHmPUMc https://img.youtube.com/vi/K5YVzHmPUMc/maxresdefault.jpg Claude Just Killed OpenClaw. I Have Proof. I built my entire video production pipeline with Claude Code. 100+ videos. 170+ unique visual components. TTS integration. Automated rendering. All in a single session. Zero screenshots sent to external APIs. OpenClaw scrapes your screen. Claude reads your code. The architecture is fundamentally different. Cisco calls OpenClaw a security nightmare. Google is banning users. Meanwhile, Claude Code operates through your terminal - no screen capture, no clipboard monitoring, no data leaving your machine. devopsdive.com #Claude #OpenClaw #AI #DevOps #ClaudeCode #CodingAgent #Security #Engineering https://www.youtube.com/embed/K5YVzHmPUMc https://www.youtube.com/watch?v=K5YVzHmPUMc 173 2026-03-27T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/8cgDBBXdeC8 https://img.youtube.com/vi/8cgDBBXdeC8/maxresdefault.jpg Your AI Pipeline Was Just Backdoored. LiteLLM Supply Chain Attack. LiteLLM versions 1.82.7 and 1.82.8 on PyPI are compromised. This is a live supply chain attack on the most popular AI gateway. The compromised versions exfiltrate environment variables, API keys, and cloud credentials. The maintainer's PyPI account had no 2FA. If you run LiteLLM in production: rollback to 1.82.6, rotate all API keys, check outbound logs, add hash verification to CI/CD. I manage 62 Azure subscriptions. Supply chain security is not optional. devopsdive.com #LiteLLM #SupplyChain #Security #DevOps #AI #PyPI #CyberSecurity https://www.youtube.com/embed/8cgDBBXdeC8 https://www.youtube.com/watch?v=8cgDBBXdeC8 150 2026-03-26T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/lGO4XRoGq0M https://img.youtube.com/vi/lGO4XRoGq0M/maxresdefault.jpg OpenAI Just Killed Sora. Disney Lost $1 Billion. OpenAI shut down Sora on March 24. One million downloads in five days. Disney committed $1 billion. Six months later - dead. Not because it failed. Because compute costs killed it. Every second of AI video burns GPU cycles that could run ChatGPT - which actually makes money. OpenAI is valued at $730 billion. They cannot afford to waste chips on a product with no revenue path. Disney pulled the $1B deal. The pattern is always the same: ship hype, get addicted to metrics, kill quietly when the bill arrives. I manage 62 Azure subscriptions. Every resource has a cost justification. Plan for cost, not hype. devopsdive.com #Sora #OpenAI #AI #Disney #DevOps #CloudCosts #Infrastructure #Engineering https://www.youtube.com/embed/lGO4XRoGq0M https://www.youtube.com/watch?v=lGO4XRoGq0M 91 2026-03-25T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/zRZsQF3hZ_E https://img.youtube.com/vi/zRZsQF3hZ_E/maxresdefault.jpg Junior Developers Don't Exist Anymore. Entry-level developer jobs dropped 67% in the US. 53% in the UK. Companies are hiring zero juniors. The CEO of Anthropic said AI will replace most engineers in 6-12 months. That was January. The clock is ticking. Has AI replaced engineers? No. But it replaced the willingness to train new ones. Where do senior engineers come from? They come from juniors who break things and learn. Kill that pipeline and you kill the entire profession in 5 years. devopsdive.com #JuniorDevelopers #Tech #Career #AI #DevOps #Hiring #CodingJobs #TechCrisis2026 https://www.youtube.com/embed/zRZsQF3hZ_E https://www.youtube.com/watch?v=zRZsQF3hZ_E 120 2026-03-25T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/NS9c4cuVR1Y https://img.youtube.com/vi/NS9c4cuVR1Y/maxresdefault.jpg OpenClaw Is a Security Nightmare. Here's What Nobody Is Telling You. OpenClaw just surpassed React as the most starred project on GitHub. Google is banning subscribers who use it. Cisco calls it a security nightmare. And millions say it changed their life. It requires full system access. Screen capture. File system. Clipboard. Network traffic. If the model gets prompt-injected through a malicious email, the agent executes with YOUR permissions. Not sandboxed. Not restricted. I manage 62 Azure subscriptions under air raid sirens. Security is not abstract to me. devopsdive.com #OpenClaw #AI #Security #DevOps #CyberSecurity #GitHub #Engineering https://www.youtube.com/embed/NS9c4cuVR1Y https://www.youtube.com/watch?v=NS9c4cuVR1Y 158 2026-03-25T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/JrSLYqrvc1g https://img.youtube.com/vi/JrSLYqrvc1g/maxresdefault.jpg They Fired 4,000 for AI. Then Quietly Rehired Them. Jack Dorsey cut 40% of Block. Four thousand people gone. Stock jumped 17%. Wall Street cheered. Then they started rehiring. Same roles. Lower salaries. Nobody talked about it. 55% of companies that did "AI layoffs" now regret it. 59% of hiring managers admitted they used AI as an excuse. Sam Altman himself called it "AI-washing." In this video I break down the 5-step layoff scam pattern and show you the data that proves most AI layoffs have nothing to do with AI. devopsdive.com #AILayoffs #Tech #DevOps #Career #Hiring #AIWashing #TechLayoffs2026 https://www.youtube.com/embed/JrSLYqrvc1g https://www.youtube.com/watch?v=JrSLYqrvc1g 118 2026-03-24T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/cybQBidMSd0 https://img.youtube.com/vi/cybQBidMSd0/maxresdefault.jpg 30% of Tech Jobs Are Fake. I Have the Data. I applied to 200 DevOps jobs in one month. Tracked every single one in a spreadsheet. Dates, companies, responses. After 60 days, the data was brutal: 60 of those postings didn't exist. No rejection. No interview. Nothing. They vanished. In this video, I break down why companies post ghost jobs (hint: 40% admitted to it), how to spot fake postings before you waste your time, and what actually works instead of mass-applying into the void. This isn't conspiracy. This is data. devopsdive.com #GhostJobs #JobSearch #DevOps #TechJobs #CareerAdvice #HiringBroken #JobMarket2026 #TechRecruiting #DevOpsDive https://www.youtube.com/embed/cybQBidMSd0 https://www.youtube.com/watch?v=cybQBidMSd0 126 2026-03-23T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/eocPcwXZpQY https://img.youtube.com/vi/eocPcwXZpQY/maxresdefault.jpg Rejected for My Location, Not Skills. Here's What I Did. Another opportunity. Another rejection. Not because I can't do the job -because of where I live. I'm Lead DevOps at Bosch. I own production. I collaborate with teams across 3 countries every single day. 8+ years of shipping mission-critical systems. But I'm a 33-year-old man in Ukraine, which means I can't leave. Not in prison, not free either. In this video I talk about the recruiter pattern everyone in my situation knows too well, what "risk" actually means when you deploy infrastructure under air raid sirens, and why the border holds my body but not my will. What you'll see: - The recruiter conversation that always ends the same way - What real risk looks like vs what a hiring manager imagines - Why I still grow, certify, migrate, and build despite everything - The message: DevOps is not where I live -it's what I do When the world opens up, I won't be rusty. I'll be unstoppable. #devops #ukraine #remotework #career #hiring #engineering #resilience #borders https://www.youtube.com/embed/eocPcwXZpQY https://www.youtube.com/watch?v=eocPcwXZpQY 82 2026-03-20T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/kFzwF9odvH4 https://img.youtube.com/vi/kFzwF9odvH4/maxresdefault.jpg I Deploy to Production During Air Raid Alerts. The air raid alert goes off. I have 2 minutes to get to the shelter. I'm mid-deployment. This isn't a sob story - it's what resilience actually looks like. I share a typical Tuesday and how I make it work: everything async, redundant power, over-communication. What you will learn: - How to work when internet and power are unreliable - Systems for chaos: Starlink, UPS, no blocking dependencies - Why over-communicating with clients saves everyone - Why "perfect conditions" are a myth https://devopsdive.com #devops #ukraine #remotework #tech https://www.youtube.com/embed/kFzwF9odvH4 https://www.youtube.com/watch?v=kFzwF9odvH4 123 2026-03-15T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/GFc7cITX-Qo https://img.youtube.com/vi/GFc7cITX-Qo/maxresdefault.jpg AI Took My Job. Then I Became 10x More Valuable. I got replaced by a language model that could do 80% of my daily tasks in 12 seconds. That was the best thing that ever happened to my career. In this video I show the wrong response (denial or panic) and what I did instead: stopped competing with AI on typing, started orchestrating it. What you will learn: - Why 47 seconds vs 45 minutes was a wake-up call - The two wrong responses most engineers have - The 10x leverage play: design infrastructure, let AI generate the code - Skills AI can't automate: system design, stakeholder translation, mentoring https://devopsdive.com #devops #ai #tech #career https://www.youtube.com/embed/GFc7cITX-Qo https://www.youtube.com/watch?v=GFc7cITX-Qo 136 2026-03-14T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/AfJVv32StjM https://img.youtube.com/vi/AfJVv32StjM/maxresdefault.jpg DevOps Is Dead. Here's What Replaced It. 84% of DevOps job postings have changed since 2024. Entry-level hiring is down 60%; platform and senior roles are through the roof. In this video I break down the paradox and show what actually gets you hired now - Platform Engineering, Internal Developer Portals, self-service infrastructure. What you will learn: Why job postings are up 40% but entry-level hiring is down 60% Old DevOps vs new: pipelines vs platforms What to learn now: Backstage, Crossplane, AI Ops How to pivot from "person who deploys" to "person who builds the system" https://devopsdive.com #devops #tech #career #cloud https://www.youtube.com/embed/AfJVv32StjM https://www.youtube.com/watch?v=AfJVv32StjM 151 2026-03-11T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/5O41T4Qfkk4 https://img.youtube.com/vi/5O41T4Qfkk4/maxresdefault.jpg Stop being a "Hero" of a broken pipeline. 55 Variables Audit 🛡️ Being an "Indispensable Hero" who fixes production at 3 AM is a trap. Real seniority is about building systems that don't need heroes. 📉 In this video, I audit a production pipeline with 55 variables. Half of them were "dead weight" — plaintext secrets and deprecated tokens from 2021. 💀 I’ll show you the exact pattern to kill the variable graveyard and migrate to a Zero Trust model using Azure Key Vault and Managed Identities (UAMI). What you will learn: 🧪 How to audit your "Secret Graveyard" (25 active vs 30 dead). 🏗️ The migration pattern: Store secret NAMES in YAML, not values. 🛡️ Why Service Principals are duct tape and why UAMI is the future. 🧼 Why secrets management is hygiene, not a project. 🌐 Full guides and engineering stories: https://devopsdive.com #devops #azure #cybersecurity #keyvault #dead #hero #cloudengineering #devopsdive https://www.youtube.com/embed/5O41T4Qfkk4 https://www.youtube.com/watch?v=5O41T4Qfkk4 110 2026-03-05T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/XMsN4nXe_lc https://img.youtube.com/vi/XMsN4nXe_lc/maxresdefault.jpg Why DevOps Engineers Burn Out (and how to survive) 📉 Success in IT is often measured by uptime and salary, but nobody talks about the mental cost of being "indispensable." In this video, I share my raw story: from 24/7 on-call anxiety and context-switching chaos to finding a sustainable balance. DevOps is a marathon, not a sprint. Stop being a hero and start building resilient systems (including yourself). What we discuss: 🚩 The "Hero Culture" lie in tech. 🚩 Why being on-call at 3 AM is not a badge of honor. 🚩 Strategic boundaries that saved my career. 🌐 Visit my platform for more engineering insights: https://devopsdive.com #devops #sre #burnout #techlife #mentalhealth #cloudengineering #devopsdive https://www.youtube.com/embed/XMsN4nXe_lc https://www.youtube.com/watch?v=XMsN4nXe_lc 76 2026-03-01T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/0ZKhfETBVfs https://img.youtube.com/vi/0ZKhfETBVfs/maxresdefault.jpg The Art of Professional Failure: How I Wiped Production & Survived They say experience is what you get when you didn't get what you wanted. In this video, I’m sharing the most expensive lessons from my DevOps career at companies like Bosch and Azure projects. From wiping out production artifacts with a single typo to 3 AM deployment nightmares — these aren't just "blooper" stories. They are the foundation of what makes a Senior Engineer truly "Senior." In this video: 0:00 - The Psychology of a Crash 0:45 - Blooper 1: The Azure Permissions Trap 2:15 - Blooper 2: The 3 AM Pipeline Meditation 4:00 - Blooper 3: The $10,000 Typo (rm -rf) 5:30 - How to handle failure like a Pro If you're an engineer, remember: You're not defined by your mistakes, but by how you fix them. Support the channel: ✅ Subscribe for more DevOps & AI content 💬 Tell me about your biggest "Production Down" moment in the comments! #devops #softwareengineering #career #tech #failure #azure #bash #linux #seniorae https://www.youtube.com/embed/0ZKhfETBVfs https://www.youtube.com/watch?v=0ZKhfETBVfs 74 2026-02-24T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/q8ilLn3YMEw https://img.youtube.com/vi/q8ilLn3YMEw/maxresdefault.jpg 389 Alert Rules. We Shipped 31. Here's Why. 389 alert rules. Half were duplicates. A quarter were for servers that no longer existed. I designed 31 that actually matter. 92% less noise. Zero false negatives. Incident response got faster because every alert matters. In this video: 00:00 — 389 → 31: not reduction, redesign 00:24 — Alert hoarding: the enterprise disease 00:47 — The 31 that matter 01:25 — The DCR split: 97% log reduction 02:00 — Level 4: the information log problem 02:32 — More alerts ≠ better monitoring #monitoring #azure #devops #alerting #observability https://www.youtube.com/embed/q8ilLn3YMEw https://www.youtube.com/watch?v=q8ilLn3YMEw 186 2026-02-17T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/4lvnum6ki9c https://img.youtube.com/vi/4lvnum6ki9c/maxresdefault.jpg 62 Azure Subscriptions. Nobody Was Watching the Bill. 62 Azure subscriptions. Billing by the minute. And not a single automated cost anomaly alert. I built one runbook that covers all 62 subscriptions. Zero stored credentials. Daily compliance checks. In this video: 00:00 — 62 subscriptions, zero visibility 00:26 — The money fires (forgotten VMs, autoscaler gone wild) 00:49 — Why native budget alerts fail 01:15 — The automation runbook 01:45 — What changed: monthly surprise → same-day catch 02:16 — FinOps isn't a team. It's a practice. #azure #finops #cloudcost #devops #automation https://www.youtube.com/embed/4lvnum6ki9c https://www.youtube.com/watch?v=4lvnum6ki9c 179 2026-02-16T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/h2ZeeRQrwWY https://img.youtube.com/vi/h2ZeeRQrwWY/maxresdefault.jpg 22 Jenkins Pipelines. 1 GitLab Template. Zero Snowflakes. 22 repositories. Each with its own Jenkins pipeline. Each written by a different developer. I wrote ONE template to replace them all. In this video: 00:00 — 22 snowflake pipelines 00:20 — The snowflake problem 00:46 — Why Jenkins had to go 01:12 — One template to rule them all 01:35 — The migration pattern 02:00 — "We'll add tests later" — No. You won't. 02:24 — The transformation: before and after 02:50 — 22 → 1 → 0 #devops #jenkins #gitlab #cicd #migration #pipeline https://www.youtube.com/embed/h2ZeeRQrwWY https://www.youtube.com/watch?v=h2ZeeRQrwWY 197 2026-02-14T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/Za3js6J7lxY https://img.youtube.com/vi/Za3js6J7lxY/maxresdefault.jpg I Was Massively Underpaid. Then My Salary Jumped 20x. Same skills. Different market. Same engineer. Completely different pay. How I went from being massively underpaid to earning 20x — not by switching stacks, but by understanding positioning, negotiation, and knowing when to say no. In this video: 00:00 — Earning pennies 00:30 — The market mismatch 01:10 — When I learned to negotiate 01:50 — The turning point 02:30 — 20x is not about skill, it's about leverage 03:20 — What I'd tell my younger self 04:10 — Your salary is a negotiation, not a grade #devops #salary #career #tech #remotework https://www.youtube.com/embed/Za3js6J7lxY https://www.youtube.com/watch?v=Za3js6J7lxY 217 2026-02-11T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/i7hKNp6QhOg https://img.youtube.com/vi/i7hKNp6QhOg/maxresdefault.jpg 60 Seconds to Explain CAP Theorem. DevOps Interviews Are Broken. Name every kubectl flag from memory. Whiteboard an S3 policy while production is on fire. This is how we hire DevOps engineers in 2026. And it's completely broken. I've done a dozen interviews this year. Trivia questions and memory tests don't tell you how an engineer handles a 3 AM incident. In this video, I break down what interviews SHOULD look like — and why results matter more than trivia. Chapters: 0:00 - 60 Seconds to explain CAP Theorem 0:26 - The pattern of trivia questions 0:42 - What my real Mondays look like 1:08 - How it should work: The Wishlist 1:32 - DevOps is not trivia night Connect with me: 🌐 Website & Video CV: https://devopsdive.com #DevOps #TechInterviews #Hiring #SoftwareEngineering #CloudEngineering #Kubernetes #CareerAdvice https://www.youtube.com/embed/i7hKNp6QhOg https://www.youtube.com/watch?v=i7hKNp6QhOg 119 2026-02-10T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/R1NOwbOd-Tg https://img.youtube.com/vi/R1NOwbOd-Tg/maxresdefault.jpg They Said I'm Too Old for DevOps. I'm 33. I’m 33 years old. To some recruiters, that’s "too senior" for the vibe. To others, I don’t have enough "architect-level" years in a tool that’s only existed for five. Meanwhile, my 18-year-old colleague writes Terraform better than most seniors I know. Ageism in tech is real, and it goes BOTH ways. But here is the truth: infrastructure doesn't care about your birth year. Kubernetes doesn't check your LinkedIn before accepting your YAML. In this video, I’m breaking down why results are the only metric that matters—whether you're 18 or 50. I’ve handled production while rockets flew overhead and built pipelines that saved teams weeks of work. That is impact. That is DevOps. In this video: 0:00 - The "Too Senior" Trap 0:13 - The 18-year-old Terraform Prodigy 0:25 - Every excuse recruiters use to say "No" 0:39 - What actually matters: Execution & Ownership 1:04 - Results vs. Years Let's connect: 🌐 Website & Video CV: devopsdive.com 💬 What’s the most ridiculous thing a recruiter has ever said to you? Drop it in the comments—I’m reading them all! #DevOps #TechCareers #Ageism #SoftwareEngineering #CloudEngineering #Terraform #CareerAdvice #UkraineTech https://www.youtube.com/embed/R1NOwbOd-Tg https://www.youtube.com/watch?v=R1NOwbOd-Tg 78 2026-02-10T00:00:00+00:00 yes no Oleksii Koshelenko https://devopsdive.com/videos/PmYnLspaO14 https://img.youtube.com/vi/PmYnLspaO14/maxresdefault.jpg DevOps Engineer - How I Create Value Beyond Code | Oleksii Koshelenko 🚀 DevOps Engineer sharing how to create value beyond just writing code In this video, I break down my approach to DevOps engineering - not just solving problems, but actively looking for ways to bring value to teams, businesses, and everyone around me. 🔧 What you'll learn: - How to think beyond task execution to value creation - Real examples of tools that saved teams hours of work - Why being a "value multiplier" sets you apart - My philosophy on problem-solving and continuous improvement 💼 Background: - 8+ years in DevOps/Platform Engineering - Multi-cloud expertise (Azure, AWS, GCP) - Tech Lead experience - International project delivery 🌐 Connect with me: - Portfolio: https://devopsdive.com - LinkedIn: https://www.linkedin.com/in/askoshelenko - Email: askoshelenko@gmail.com #DevOps #CloudEngineering #TechLeadership #ProblemSolving #Azure #AWS #GCP #CareerGrowth #SoftwareEngineering #Infrastructure #Automation https://www.youtube.com/embed/PmYnLspaO14 https://www.youtube.com/watch?v=PmYnLspaO14 340 2025-07-20T00:00:00+00:00 yes no Oleksii Koshelenko