Blog on I am Lino

Infrastructure as Code: Why Your Infrastructure Deserves Version Control Just Like Your Code

Mon, 30 Mar 2026 00:00:00 +0000

For years we’ve treated infrastructure and software as two separate religions, each with their own gods, their own rituals, and most importantly, their own people to blame. The code lived in Git; the infrastructure lived “in AWS,” some ethereal thing that “we manage with scripts and the console.”

But the truth is your infrastructure already behaves like software: it has state, dependencies, bugs, versions, and side effects when you change it.

AI everywhere: the ketchup-on-everything syndrome

Mon, 23 Mar 2026 00:00:00 +0000

Every so often, the tech industry latches onto a word and repeats it until it’s completely hollow. First it was “cloud”, then “blockchain”, then “web3”. Now the magic word is “AI”. If you don’t put “AI-powered ” on your product page, it looks like your product comes in black and white with a Nokia 3310 thrown in for free (for my younger readers: those were the indestructible phones that only made calls and lasted a week on a single charge).

How to Make Technical Decisions Without Selling Your Soul to the Hype

Mon, 16 Mar 2026 00:00:00 +0000

There are technical decisions made with data, time, and a bit of judgment.

And then there are the other kind: the ones made after watching three conference talks, scrolling through two X threads, and half-reading a case study , that somehow end with phrases like “well… now that we’ve set it all up, we might as well get some use out of it, right?”

One day you’re perfectly happy with your API running on a plain old VPS, and the next you find yourself building a serverless-event-driven-data-mesh-multi-cloud architecture because you watched a video claiming “that’s how Netflix does it.”

Microservices, Monoliths, and Other Mythical Creatures

Mon, 09 Mar 2026 00:00:00 +0000

Some architecture decisions are made calmly, with data, over a nice cup of coffee.

And then there’s real life, where you pick your tech stack the same way you pick a favorite sports team: because you saw it in a cool conference talk, because some big-name company uses it, or because someone tweeted that “if you don’t have 80 microservices running on Kubernetes, you’re a dinosaur.”

Next thing you know, you’ve gone from a lovable monolith — a little messy but functional — to a circus of services where nobody really knows what talks to what, your cloud bill is terrifying, and the only microservice running flawlessly is the one that charges you at the end of the month. All because, at some point, somebody stopped asking the only question that actually matters:

The subscription model sucks

Thu, 05 Mar 2026 00:00:00 +0000

Back in the day, you’d buy a CD, a game, a copy of Word 2003, and that thing was yours “forever” – or at least until you switched computers or your music taste moved on.

Now you blink and discover that everything is a subscription: movies, TV shows, music, the gym, your car, razor blades, cat food, courses, IDEs, design suites, servers… and if you’re not careful, even your couch will hit you with a monthly fee just for sitting near it.

Modern Architecture Fundamentals (No Snake Oil Included)

Mon, 02 Mar 2026 00:00:00 +0000

Imagine someone telling you: “I’ve set up my app on an on-premises server with Oracle 9i, but don’t worry, it’s modern architecture because it runs Docker.” That’s the moment you understand why people bail on architecture meetings pretending they have a dental emergency.

When we talk about “modern architecture,” we’re not talking about slapping Kubernetes onto everything or cramming as many buzzwords as possible into a slide deck. We’re talking about something far less flashy and far more difficult: building systems that survive in today’s ecosystem without going obsolete or blowing up every time the business changes a “simple” requirement. Systems that live in the cloud (or several clouds), communicate over networks that fail, store data scattered across half the planet, and still need to keep responding when someone decides “we also need to go multi-region because an important client said so.”

The psychological cost of always being "up to date"

Thu, 26 Feb 2026 00:00:00 +0000

There’s a very specific kind of tiredness that only people in tech truly understand. It’s not sleepiness, it’s not laziness, it’s not “I hate coding.” It’s that moment when you close your laptop at a reasonable hour, go make dinner… and five minutes later open your phone “just to check” LinkedIn or X. In that personal micro-hell , everyone seems to have launched a side project, contributed to open source, migrated to another framework, shoved AI into everything including their grocery list, and written a thread explaining how you can do it too “if you just get organized” .

A "professional hygiene" guide for developers

Mon, 23 Feb 2026 00:00:00 +0000

There comes a moment, in almost every tech career, when you catch yourself thinking: “maybe the problem is me.”

Not because you don’t enjoy coding, but because you feel like you’re always two frameworks behind, three blog posts short, and five certifications trailing whatever your LinkedIn feed suggests you should be. You open Twitter on a Sunday morning and it looks like everyone has contributed to open source, built a side project in Rust, and read the latest architecture book… while you were, I don’t know, living .

SLOs, SLAs, and SLIs: putting numbers on "it kinda works"

Fri, 20 Feb 2026 00:00:00 +0000

In almost every company, there’s a magical phrase used to describe a system’s health: “it more or less works.” Translated into plain English: nobody knows how often it goes down, how many requests fail, or how much money is lost when it decides not to work. But hey, “more or less.”

SLI , SLO , and SLA are the grown-up version of that phrase. They’re the way to go from “I think it’s fine” to “this is what it handles, this is what we promise, and this is what’s at stake” — without having to fall back on the classic “trust me, I’m an engineer.”

Metrics and observability strategy: measuring without fooling yourself

Wed, 18 Feb 2026 00:00:00 +0000

In almost every team, there’s a magical moment when someone opens a dashboard, points at a green graph, and says: “See? We’re doing great.” Meanwhile, support is on fire, the payments API is going down every other hour, and the development team hasn’t slept properly in three weeks.

The difference between a healthy team and one stuck in that endless theater usually comes down to how they use metrics: as a flashlight to see better… or as a stick to beat each other with.

Checklist: "Is this idea worth a tech article?"

Mon, 16 Feb 2026 00:00:00 +0000

Most good technical articles are born the same way: someone got burned by a real problem and decided that, since they’d already bled, the least they could do was save others from tripping over the same spot. Then there’s the other kind: the one you end up writing after seeing yet another LinkedIn post claiming that “X is going to revolutionize software development” and thinking, “this smells like snake oil, but let me take a look just in case.”

From "Move Fast" to "Ship Crap": When Speed Eats Quality

Sun, 15 Feb 2026 00:00:00 +0000

We were standing right on the edge of the cliff… and decided to take a big step forward.

For years, “move fast” has been sold to us as an unquestionable virtue. The problem is that, in far too many teams, it’s been translated into “ship crap”: ship fast, break things… and then spend months trapped in technical debt, bugs, angry customers, and general frustration.

In this article I want to show you how bad metrics (OKRs, velocity, “features per quarter”) are pushing a lot of products over the edge—and what you can do about it, because it’s not all doom and gloom.