Blog

Hard-won lessons from leading teams through high-stakes platform migrations — where the stakes are real and rollback isn't always an option.

After years of building event-driven systems with RabbitMQ, here's why I keep coming back to this pattern for mission-critical platforms.

After months of integrating AI into my development workflow, here's what actually works — and what doesn't.

DDD isn't just for textbooks. Here's how I've applied it to healthcare and financial systems — and the mistakes I made along the way.

What does a solutions architect actually do in 2025? It's not what the job description says.

Stop treating technical debt as a failure. Start treating it as a tool — one that needs to be managed, not eliminated.

Reflections on two decades of building high-stakes platforms where failure isn't an option.

The transition from individual contributor to engineering director is harder than anyone admits. Here's what I learned making that leap.

What engineers actually need to know about building HIPAA-compliant software — without the legal jargon.

Why I still write code as an engineering director — and why my prototypes are the most persuasive documents I produce.

After years of building microservices in production, here's what actually matters — and what's just conference talk fodder.

Most technical specs are either too vague or too detailed. Here's the framework I use to write specs that actually get read and implemented correctly.

Velocity isn't about working faster. It's about removing the things that slow you down.

PostgreSQL has been my database of choice for years. Here's what I've learned about running it at scale in high-throughput production systems.

EDI, HL7, DICOM — healthcare integration standards sound arcane, but the principles behind them are surprisingly universal.

A story about a code review that went wrong, what I learned from it, and how it shaped my approach to mentoring engineers.

I've written production systems in C#, Golang, PHP, and Java. I keep coming back to Node.js. Here's why.

Deploying without downtime isn't magic. It's a series of boring, deliberate engineering decisions. Here's the playbook.