Thoughts, insights,
and lessons learned.
Sharing ideas on AI, architecture, automation, engineering, and building impactful solutions.
Explore by Category
LLM Integration in Production — What Nobody Tells You
Integrating large language models into a real system is a different discipline than using them via a chat interface. Here's what that actually looks like from an engineering standpoint.
Mindset
2 articles
Building Systems for Myself
For years I built systems for other people, but never for myself. This is the story of that realization — and why I finally started this channel.
Hidden Privilege
Most people see privilege as something they don't have. But privilege is often hiding in the conditions we're already living.
Engineering
15 articles
Metrics You Must Measure From Day One
Most teams only start measuring after something breaks. But there are metrics that should be tracked from the very first line of code — even before you have a single user.
When Is a Technical Improvement Worth Prioritizing?
Not every technical improvement needs to be done. But that does not mean all of them can be ignored. There is a simple framework for deciding which ones deserve priority — and which ones can wait.
The Best Stack Is the One Your Team Can Execute With
Engineers obsess over picking the right technology, but the biggest predictor of success isn't the stack — it's the team's mastery, cohesion, and execution discipline.
Choosing the Right Stack for the Job
A practical breakdown of what Node.js, .NET/C#, Python, Java, and Go are genuinely best at — ignoring team preferences and focusing purely on technical fit.
Folder Structure in Practice: One Feature, Five Architectures (C# / .NET)
Building the same Orders feature using Simple MVC, Layered, Feature-Based, Clean Architecture, and Microservices — with testing strategies for each, using real code examples in C# and ASP.NET Core.
Folder Structure in Practice: One Feature, Five Architectures (Node.js)
Building the same Orders feature using Simple MVC, Layered, Feature-Based, Clean Architecture, and Microservices — with testing strategies for each, using real code examples in TypeScript, Express, and NestJS.
Folder Structure in Practice: One Feature, Five Architectures (Python)
Building the same Orders feature using Simple MVC, Layered, Feature-Based, Clean Architecture, and Microservices — with testing strategies for each, using real code examples in Python and FastAPI.
Modular Monolith in Practice: Enforced Module Boundaries (C# / .NET)
Building the Orders feature using Modular Monolith with C# and ASP.NET Core — project separation, the internal keyword, ArchUnit for architecture tests, and the right testing strategy.
Modular Monolith in Practice: Enforced Module Boundaries (Node.js)
Building the Orders feature using Modular Monolith with TypeScript and NestJS — public API per module, inter-module communication, boundary enforcement with ESLint, and the right testing strategy.
Modular Monolith in Practice: Enforced Module Boundaries (Python)
Building the Orders feature using Modular Monolith with Python and FastAPI — public API via __init__.py, Python Protocol as interface, import-linter for boundary enforcement, and the right testing strategy.
The Evolution of Folder Structure in Software Engineering
How folder structure evolved from simple MVC to Clean Architecture and Microservices — and why it reflects the engineering mindset of each era.
Using Claude Code and GitNexus with Multi-Service Systems
How to analyze and refactor complex microservices architectures safely with Claude Code and GitNexus across multiple repositories
Testing Microservices in Practice with FastAPI and PostgreSQL
A comprehensive guide to testing strategies for microservices built with FastAPI and PostgreSQL
Getting Started with Next.js 15
Learn how to build modern web applications with Next.js 15 and the App Router
Building Scalable APIs with FastAPI
Best practices for designing and implementing high-performance APIs
AI & ML
6 articles
Introduction to RAG Systems — Giving LLMs Access to Your Data
Large language models are powerful reasoners but their knowledge is frozen at training time. Retrieval-Augmented Generation solves this by connecting models to live, private, and up-to-date information at query time.
Introduction to Large Language Models — What Engineers Need to Know
LLMs are not magic, not sentient, and not unpredictable once you understand what they actually are. Here's the conceptual foundation every engineer working with AI systems needs before writing a single line of integration code.
Introduction to Prompt Engineering — The Engineer's Starting Point
Prompt engineering is the practice of structuring inputs to get reliable, useful outputs from language models. It's learnable, systematic, and the first skill every AI engineer needs.
LLM Integration in Production — What Nobody Tells You
Integrating large language models into a real system is a different discipline than using them via a chat interface. Here's what that actually looks like from an engineering standpoint.
Prompt Engineering in Practice — A Field Guide for AI Engineers
Prompt engineering is not magic words and trial-and-error. It's a systematic discipline with learnable principles. Here's how to approach it like an engineer.
Building RAG Systems That Actually Work in Production
Retrieval-Augmented Generation sounds simple — retrieve context, inject it, generate. The production reality is more complex. Here's a field guide to building RAG pipelines that are accurate, fast, and maintainable.
Stay Updated
Get notified when I publish new articles about software engineering and entrepreneurship.