A diagram showing multiple identical API requests with the same idempotency key, where only the first executes business logic while duplicates return cached responses.

Designing Idempotent APIs in ASP.NET Core

Network failures and retries are inevitable in distributed systems. Without idempotency, duplicate requests create double charges and data corruption. This guide shows how to implement idempotent APIs in ASP.NET Core using action filters, Redis, and idempotency keys to handle retries safely.

January 16, 2026 · 9 min
A minimal diagram showing features grouped by vertical slices, with entire folders being removed cleanly to illustrate delete-ability and localized change.

Delete-Driven Design: How to Write Code You Can Remove

Most design principles focus on extensibility and reuse. Delete-Driven Design flips the question: how easy is it to remove code safely? This post explains why delete-ability is the ultimate test of boundaries, abstractions, and tests—and how to design systems that accept change without fear.

January 12, 2026 · 8 min
A minimal architectural diagram showing controllers, services, and domain entities, with business logic drifting upward into services and increasing complexity.

Why Most Service Layers Make Code Worse

Service layers were meant to coordinate use cases, but in many systems they become dumping grounds for business logic. This post explains why that happens, how it leads to anemic domain models and brittle tests, and what to do instead.

January 5, 2026 · 11 min
A minimal diagram showing tools and frameworks fading into the background while judgment, domain understanding, and maintainability remain central.

What Senior Developers Should Care About in 2026

Frameworks change, but the hardest problems in production software don’t. This post explores what senior developers should actually care about in 2026 - judgment, boundaries, domain modeling, performance, testing, and communication - long after the hype fades.

December 31, 2025 · 9 min
A minimal architectural diagram showing layers becoming more complex over time, with arrows highlighting trade-offs between abstraction, simplicity, and maintainability.

The Engineering Trade-offs I Got Wrong

Most engineering mistakes don’t come from ignorance—they come from good intentions applied too early. This post reflects on real-world trade-offs around abstractions, service layers, Clean Architecture, testing, and what I’d do differently today.

December 25, 2025 · 9 min

Violating SOLID for Performance: When It’s Okay and How to Isolate It

Discover when it’s justified to break SOLID principles for performance in C#. Learn how to measure, isolate, and document exceptions, see real-world trade-offs, and keep your codebase maintainable, even in the engine bay of high-throughput systems.

July 10, 2025 · 10 min
×