Blog
Engineering, security and AI: what we're learning while designing, building and defending production systems.
Agents and the Model Context Protocol are the loudest topics in AI right now, and most of what's written about them is either hype or hand-waving. Here's what they actually are in plain language, why a single model call still beats an agent most of the time, the few cases where agents earn their keep, and the production concerns the demos never mention.
The three big clouds are more alike than any of them would like you to believe, and the differences that matter have little to do with feature checklists. Here's what actually separates them, what genuinely doesn't, and a decision framework built on the factors that will still matter in five years.
Microservices solve real problems, just not the ones most teams have when they adopt them. Here's what the architecture actually buys you, what it costs in practice, and the signals that tell you it's genuinely time to split.
gRPC is dramatically better than REST at some jobs and clearly worse at others, and the difference isn't subtle. Here's what it actually is, where the performance claims hold up, and a decision rule you can defend in an architecture review.
The three titles get used interchangeably on CVs, proposals and org charts, but they describe genuinely different work. Here's what each one actually does, why the lines blur on purpose, and which one your project needs right now.
Most cloud bills are too high for the same reason: nobody ever went back to check. Here's the practical process we use to right-size compute, storage and bandwidth, cut waste without cutting reliability, and actually predict what a system will cost.
Most AI projects fail at the decision, not the build. Here's the framework we use to pick the right approach, the right model, and whether AI belongs in the project at all, plus a calculator to run the numbers.
Security is not a phase you bolt on before launch. Here's how we make application security part of the definition of done, so it ships with the feature instead of being chased afterwards.
Not every problem needs a model. Here's how we decide when AI genuinely beats the simpler option, and when reaching for it just adds cost, latency and risk.
We build with large language models every day. Here's what's actually changing about how software gets made, and why AI changes coding without replacing engineering.
A retrieval-augmented demo is easy. A RAG system that stays accurate, safe and affordable in production is the hard part. Here's what that actually takes.
A clear-eyed look at the modern threat landscape and what a normal team should actually do about it. Identity is the new perimeter, and most attacks log in rather than break in.
Choosing the wrong build partner is expensive and slow to undo. These are the ten questions that separate a real engineering partner from a body shop.
Most teams scale too early. Here's a practical, opinionated guide to building web apps that grow, by removing the bottlenecks you can actually measure.
DevOps is a culture, not a tool you buy. The pipelines only pay off when the culture underneath is right. Here's what high-performing teams actually do.
A pragmatic playbook for moving to the cloud without the usual disasters. The 6 Rs, avoiding the lift-and-shift trap, keeping the bill under control, and knowing when not to migrate.
Designing for the smallest screen first produces better products for everyone. Here's the discipline behind it, and why constraints from mobile clean up the desktop too.