Blog.
Thoughts, opinions, and technical articles on software engineering, cloud, AI, teamwork and anything that crosses my mind.
Agile theater: stand-ups, post-its, and zero decisions
How so many companies adopt the Agile look without changing anything that matters, turning their ceremonies into corporate theater.
How I Built My Own Personal Cloud
How I built a six-node cluster running local AI at home: the design decisions, the incidents that put it to the test, and why it was worth it.
Multi-Project Hell: On Three Teams at Once and Truly on None
Why being spread across four or five projects at once doesn't make you more efficient — it just leaves you shallow on all of them, according to the science of context switching.
Meetings That Should Have Been a Pull Request
Why so many technical decisions that could fit in three paragraphs of a PR end up becoming an hour-long video call with ten people and a Head of Something.
Feature flags, canary releases, and the art of not breaking production (too badly)
How to use feature flags and canary releases to deploy safely, reduce incident risk, and keep your velocity without sacrificing your weekend.
The False Consensus: When Nobody Dares Say the Idea Is Bad
Why teams nod along when they should push back, how silence turns into a collective decision, and what it takes to break that pattern.
The cult of urgency: when everything was needed yesterday and tomorrow will be worse
False urgency has become the default operating mode in tech companies, with a real cost in productivity and mental health.
"Senior": the title you earn by surviving, not by standing out
The 'senior' title in the tech industry is handed out far too often for tenure and chaos tolerance, not for real technical judgment.
Security by design: stop patching holes you dug yourself
Why security must be integrated from the design phase instead of bolted on at the end: threat modeling, OWASP, 12-Factor Apps, CVEs, and pentesting.
The full-stack developer cult: lots of stack, not much depth
Why the all-powerful full-stack myth benefits companies and coding schools, and what it costs developers in quality, career growth, and mental health.
Yes, there's an AI bubble. No, it's not the end of the world.
Generative AI has the hallmarks of an economic bubble and a real underlying technology: how to navigate the hype without falling for the apocalypse or the infomercial.
A Combat Manual for Shipping Changes Without Breaking Everything
A practical guide to deploying changes to production without drama: feature flags, canary releases, the strangler pattern, and pipelines that stop bad code before it ships.
The Committee: Where Good Ideas Go to Die Slowly
Why committee-based decisions tend to be inefficient, and what organizational research says about designing better collective decision-making processes.
The Price of Being Right
Why technical discussions turn into identity battles — and how to survive without losing your craft or your sanity.
The cloud isn't cheap anymore: welcome to the FinOps era
The promise that the cloud cuts costs has expired: now it's FinOps, the practice that turns your cloud bill into just another system metric.
Serverless, Containers, and VMs: Pick Your Poison (and Your Bill)
VMs, containers, and serverless compared without dogma: control, costs, lock-in, and when to pick each deployment model.
Toxic metrics: story points, commits, and other creative ways to fool yourself
Why measuring productivity with story points, commits, or lines of code destroys teams, and what metrics actually make sense.
Rewriting from scratch: 'hold my beer'
The urge to throw out the code and rewrite from scratch almost always costs more than you think: why we underestimate the real price and when it actually makes sense.
Infrastructure as Code: Why Your Infrastructure Deserves Version Control Just Like Your Code
Your infrastructure is already software: it has state, bugs, and side effects. IaC is how you version it — and when you screw up, at least leave a trail.
AI everywhere: the ketchup-on-everything syndrome
AI-washing and AI slop are eroding trust in real AI: how to spot the smoke and what to do instead.
How to Make Technical Decisions Without Selling Your Soul to the Hype
There are technical decisions, and then there are hype-driven ones. Learn to spot the difference before your team spends the next two years fighting fires in your shiny new architecture.
Microservices, Monoliths, and Other Mythical Creatures
Monolith or microservices? A calm, noise-free look at both options, real case studies from Netflix, Amazon and Uber, the myths that deserve retirement, and a framework you can actually use to decide.
The subscription model sucks
We keep paying anyway, because they've got us right where they want us. On subscription fatigue, BWM's heated seat fiasco, enshittification, and what you can actually do about it.
Modern Architecture Fundamentals (No Snake Oil Included)
What 'modern architecture' actually means beyond the buzzwords: monoliths, modular monoliths, microservices, events, and cloud-native design — with a survival guide to help you decide.
The psychological cost of always being "up to date"
If you measure your worth against an aggregate of other people's highlights, you always lose. On tech FOMO, training burnout, and why falling a bit behind on purpose is a good idea.
A "professional hygiene" guide for developers
It's not about productivity or 'wake up at 5 AM.' It's about how not to burn yourself out along a 25-30 year career.
SLOs, SLAs, and SLIs: putting numbers on "it kinda works"
SLI, SLO, and SLA are the grown-up version of 'it more or less works'. Go from 'I think it's fine' to 'this is what it handles and what's at stake'.
Metrics and observability strategy: measuring without fooling yourself
The difference between a healthy team and one stuck in endless theater usually comes down to how they use metrics.
Checklist: "Is this idea worth a tech article?"
How to decide if an idea deserves an article (and your time), or if you're better off closing the tab and getting back to your coffee.
From "Move Fast" to "Ship Crap": When Speed Eats Quality
How bad metrics (OKRs, velocity, features per quarter) are pushing a lot of products over the edge.